–危機と殉教

（字幕がかっこいいのでそれが字幕です）

Python でのこの挑戦的な挑戦（うん、あなたはJavaで送信しないかもしれないと知る必要はありません）では、ダンジョンへようこそと非常によく似たゲームをプレイするボットを作成する必要があります

ゲームのルール

（これは元のゲームではないことに注意してください）

デッキ、アイテムセット、そしていくつかのポイントカードとデスカードがあります。基本HPは3です。このデッキ1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 9は、強みを示すために番号が付けられた13枚のモンスターカードで構成されています。

アイテムリスト

1. 悪魔の契約：デーモン（強度7のモンスター）とその下のモンスターをダンジョンパイルで倒します。-（デーモンがダンジョンの最後だった場合、デーモンを倒すだけです）

2. 体力ポーション：0 HPに落ちたら、モンスターを倒して3 HPに戻る。

3. 聖杯：偶数の強さのモンスターを倒す（ゲームでは、これらはアンデッドです）。悪魔の協定が使用された後に偶数番号のモンスターが発生した場合、それが最初に動作し、このモンスターの後に余分な協定のキルは得られません。

4. ヴォーパルダガー：ダンジョンに入る前にモンスターを1つ選択してください。このタイプのモンスターは打ち負かされます。悪魔の契約が使用された後に対象のモンスターが発生した場合、それが最初に機能し、このモンスターの後に追加の契約キルを得ることができません。

5. シールド：スペルを上げる前に、合計HPに3を追加します。これはヘルスポーションの使用には影響しません。ヘルスポーションは常にヘルスを3に戻します。

6. 装甲：スペルする前に、合計HPに5を追加します。これはヘルスポーションの使用には影響しません。ヘルスポーションは常にヘルスを3に戻します。

ポイントカードは、誰がダンジョンで成功したかを追跡するために使用されます。デスカードは、ダンジョンで失敗した人を追跡します。

描画フェーズ

引き分け段階が始まる前に、すべてのモンスターカードがデッキに戻され、両方のプレイヤーが3 HPに回復し、廃棄されたすべてのアイテムがそれぞれ1つになるように回復されます。

最初のプレイヤーはデッキからカードを引くかどうかを決定し、他のプレイヤーからそれを隠します。もしそうなら、彼らはそれをダンジョンパイルの上に置くか、自分の選んだアイテムと一緒に捨てるかを選ばなければなりません。捨てられたアイテムとカードは、次のラウンドまでどちらのプレイヤーも利用できません。

プレーヤー1が自分の番になった後、プレーヤー2も同じようにします。プレイヤーは、誰かがドローしないことを決定するか、プレイヤーが最後のカードをデッキから取り出すまで、ドローするかどうか、およびドローしたカードをどうするかを交互に決定します。プレイヤーがドローしないことを決定した場合、または最後のカードをドローした場合、ドローフェーズは終了し、他のプレイヤーはダンジョンに入り、洞窟探検を開始する必要があります。

Spelunkingフェーズ

ヴォーパルダガーが捨てられていない場合、スペルを打ったプレイヤーは、どのカードに適用するかを決定する必要があります。このフェーズの残りの部分について、積極的な決定はありません。

最初のプレイヤーが一番上のカードを取ります。つまり、ダンジョンに配置された最後のカードで、その強さの数値が表示されます。悪魔の契約が前のターンからアクティブである場合、引かれたカードは捨てられます。それ以外の場合、プレイヤーのアイテムは「悪魔の契約」、「聖杯」、「ヴォーパルダガー」の順にチェックされます。引き出されたカードを倒すことができる最初の捨てられていないアイテムが使用され、カードは捨てられます。悪魔の契約が使用されている場合は、次のカードで有効になります。使用済みのアイテムは廃棄されません。

該当するアイテムがない場合、カードの強さはプレイヤーのヘルスから差し引かれます。体力がポジティブでなくなった場合、3 HPに回復し、可能な場合はポーションが破棄されます。そうでない場合、ダンジョンクロールは終了し、デスカードを取得します。

プレイヤーが敗北せず、ダンジョンにカードが残っている間、このトップのカードを引くプロセスが繰り返されます。ダンジョン内のすべてのカードを無事に倒すと、ダンジョンクロールは終了し、洞窟探検家はポイントカードを集めます。

完全なゲームの説明

ゲームは一連のラウンドで構成されており、それぞれが描画フェーズとそれからスペルフェーズを持っています。各ラウンドの終わりに、1人のプレイヤーがデスカードまたはポイントカードのいずれかを収集します。プレイヤーがいずれかのタイプの5を蓄積すると、ゲームは終了します。彼らが5枚のデスカードを持っている場合、彼らはゲームに負けます。彼らが5枚のポイントカードを持っている場合、彼らは勝ちます。いずれにしても、他のプレイヤーは反対の結果を受け取ります。どちらのプレイヤーも1つのタイプのカードを5枚持っていない場合、プレイは次のラウンドに進み、前のラウンドで2番目に進んだプレイヤーが最初に進み、その逆も同様です。

コス詳細

各ボットは、上記のルールに従って、他のすべてのボットに対して400ゲームをプレイします。プレイヤー1であるボット（つまり、最初のラウンドで最初に実行されるボット）が各ゲームを交互に切り替え、すべての状態がゲーム間でリセットされます。

再びアイテムは次のとおりです。

1. 悪魔の契約：デーモン（強度7のモンスター）とその下のモンスターをダンジョンパイルで倒します。-（デーモンがダンジョンの最後だった場合、デーモンを倒すだけです）

2. 体力ポーション：0 HPに落ちたら、モンスターを倒して3 HPに戻る。

3. 聖杯：偶数の強さのモンスターを倒す（ゲームでは、これらはアンデッドです）。悪魔の協定が使用された後に偶数番号のモンスターが発生した場合、それが最初に動作し、このモンスターの後に余分な協定のキルは得られません。

4. ヴォーパルダガー：ダンジョンに入る前にモンスターを1つ選択してください。このタイプのモンスターは打ち負かされます。悪魔の契約が使用された後に対象のモンスターが発生した場合、それが最初に機能し、このモンスターの後に追加の契約キルを得ることができません。

5. シールド：スペルを上げる前に、合計HPに3を追加します。これはヘルスポーションの使用には影響しません。ヘルスポーションは常にヘルスを3に戻します。

6. 装甲：スペルする前に、合計HPに5を追加します。これはヘルスポーションの使用には影響しません。ヘルスポーションは常にヘルスを3に戻します。

デッキ：1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 9。

次の基本クラスから派生したクラス変数を使用しないボットクラスを実装する必要があります。

class BasePlayer:
    def start_turn(self, last_turn):
        raise NotImplementedError

    def play(self, card):
        raise NotImplementedError

    def vorpal_choice(self, last_turn):
        raise NotImplementedError

    def result(self, bot, result, dungeon, vorped):
        raise NotImplementedError

この基本クラスは、クラスが実装する必要があるメソッドと、各メソッドが取る引数の数を示します。

メソッド引数の説明

• last_turn中vorpal_choice及びstart_turn整数又はなしの値です。0から5の値は、敵がその値で示されたアイテム（上記のアイテムのリストを参照）とともにドローカードを破棄したことを示します。値6は、敵がカードをダンジョンに置いたことを示します。None値は、ボットがこのラウンドの最初にプレイしていることを示します（では不可能vorpal_choice）。でvorpal_choicelast_turn彼らはそのターンを通過したことを示す、7である可能性が高いです。7でない唯一の状況は、敵が最後のカードを引いたときです。

• card 上記のように、デッキのカードの1枚の強さを表す数値です。

ここでの引数resultはもう少し複雑です：

• botダンジョンに入ったボットを示します。0はダンジョンに入ったことを示し、1は敵がダンジョンに入ったことを示します。

• result旅行の成功を示します。Falseはスペルボットが成功したことを示し、Trueは失敗したことを示します。

• dungeonダンジョンにあったカードを表すカード/ intのリストです。ダンジョンは、注文順に並べられています。ダンジョンに配置された最初のカードがリストの最初になり、配置された最後のカードが最後になります。廃棄されたカードに関する情報は受け取りません。彼らは他のボットから秘密です。

• vorpedvorpal_choicespelunkingボットによって作成されたを表す整数です。の場合bot==0、あなたはすでにこれを知っていますが、の場合bot==1、これは有用な情報になる場合があります。

正直に言って、なぜ勝った結果をFalseにしたのか完全には思い出しませんが、当時はそれは良い考えだったと思います。

戻り値

• start_turn：カードを引くには1を、パスするには0を返します。

• play：対応するアイテムと描画されたカードを破棄する場合は0から5を、ダンジョンにカードを配置する場合は6を返します（start_turn中に行われるパスを除いて、last_turn入力と同じです）。

• vorpal_choice：Vorpalダガーを使用して、削除するカードの番号を返します（1を削除するには1、5を削除するには5）。存在しないカードを選択すると、殺されます（8は違法、10は違法、0は違法）。

• result：これはボットのデータを更新する通知機能なので、何でも返すことができます。

ここでコントローラを確認できます

追加の説明、または単にスキップして、すぐに知りたいと思うかもしれないいくつかの小さな詳細を繰り返す：

ボットは他のボットと400ゲームをプレイします。

クラス変数なし

特定の他のボットをターゲットにしない

他のボットを支持しない

ランダムモジュールや他のボットを変更するようなリフレクションはありません。

すべてのボットがKOTHに含める価値があることが明らかでない限り、最大6ボット（1人あたり）（ただし、ボットの束を作成しないでください）

このKOTHに特定の終了時間はありませんが、それだけの価値がある報奨金の終了を除きます。ただ毎回勝つようにしてください。

これまでの結果（これらの人にかなり怠惰だったのは残念です：P）

1 GrailThief 2732 0.98
2 Steve 2399 0.86
3 DevilWorshipper 1854 0.66
4 RunAway 1336 0.48
5 BoringPlayer 1190 0.42
6 SlapAndFlap 783 0.28
7 DareDevilDumDum 750 0.27
8 RandomMandom 156 0.06

杯泥棒は賞金を「盗み」ます。それはそれを獲得したからです。よくできました、スリーファー！

GrailThief

古い経験豊富なダンジョンクローラー。彼は他のほとんどの人が望んでいること、聖杯が彼らを救うことを知っているので、彼はそれが確実に消えるようにします。

from base import BasePlayer
import copy

class GrailThief(BasePlayer):
    class Stats:
        def __init__(self):
            self.deck = [1, 2, 3, 4, 5] * 2 + [6, 7, 9]
            self.items = {0, 1, 2, 3, 4, 5}
            self.dungeon_known = []
            self.dungeon_unknown = 0
            self.monsters_safe = {2, 4, 6, 7}
            self.update()

        def update(self):
            self.dungeon_total = len(self.dungeon_known) + self.dungeon_unknown
            deck_factor = float(self.dungeon_unknown) / len(self.deck) if len(self.deck) > 0 else 1.0
            self.dungeon_weighted = [(i, 0.0 if i in self.monsters_safe else 1.0) for i in self.dungeon_known] + [(i, 0.0 if i in self.monsters_safe else deck_factor) for i in self.deck]
            dungeon_weighted_sums = dict.fromkeys(self.dungeon_known + self.deck, 0.0)
            for i in self.dungeon_weighted:
                dungeon_weighted_sums[i[0]] += i[0] * i[1]
            self.vorpal = max(dungeon_weighted_sums, key = dungeon_weighted_sums.get)
            if 3 in self.items:
                self.dungeon_weighted = [(i[0], 0.0 if i[0] == self.vorpal else i[1]) for i in self.dungeon_weighted]

        def discard_item(self, item, card):
            new = copy.copy(self)
            new.items = {i for i in new.items if i != item}
            if item == 0:
                new.monsters_safe = {i for i in new.monsters_safe if i != 7}
            elif item == 2:
                new.monsters_safe = {i for i in new.monsters_safe if i not in {2, 4, 6}}
            if card is not None:
                new.deck = list(new.deck)
                new.deck.remove(card)
            new.update()
            return new

        def to_dungeon(self, card):
            new = copy.copy(self)
            if card is None:
                new.dungeon_unknown += 1
            else:
                new.deck = list(new.deck)
                new.deck.remove(card)
                new.dungeon_known = list(new.dungeon_known)
                new.dungeon_known.append(card)
            new.update()
            return new

        def effective_hp(self):
            hp = 3.0
            if 1 in self.items:
                hp += 3.0
                if self.dungeon_total > 0:
                    hp += sum([(i[0] - 1) * i[1] for i in self.dungeon_weighted]) / self.dungeon_total
            if 4 in self.items:
                hp += 3.0
            if 5 in self.items:
                hp += 5.0
            return hp

        def effective_damage(self):
            damage = sum([i[0] * i[1] for i in self.dungeon_weighted])
            if 0 in self.items:
                if self.dungeon_total > 1:
                    damage -= damage / (self.dungeon_total - 1)
            return damage

    def __init__(self):
        self.stats = self.Stats()

    def process_last_turn(self, last_turn):
        if last_turn in [0, 1, 2, 3, 4, 5]:
            self.stats = self.stats.discard_item(last_turn, None)
        elif last_turn == 6:
            self.stats = self.stats.to_dungeon(None)

    def start_turn(self, last_turn):
        self.process_last_turn(last_turn)
        if self.stats.effective_hp() > self.stats.effective_damage() + 1.5:
            return 1
        else:
            return 0

    def play(self, card):
        if 2 in self.stats.items:
            self.stats = self.stats.discard_item(2, card)
            return 2
        else:
            self.stats = self.stats.to_dungeon(card)
            return 6

    def vorpal_choice(self, last_turn):
        self.process_last_turn(last_turn)
        return self.stats.vorpal

    def result(self, bot, result, dungeon, vorped):
        self.stats = self.Stats()

悪魔の崇拝者

KOTHチャレンジでの最初の試み：

from base import BasePlayer
#from random import randint

class DevilWorshipper(BasePlayer):
    def reset(self):
        self.items = [0, 1, 2, 3, 4, 5]
        self.turns = 0
        self.demon = False
        self.dragon = False

    def __init__(self):
        self.reset()

    def start_turn(self, last_turn):
        if last_turn in self.items:
            self.items.remove(last_turn)

        if last_turn is not None:
            #self.demon = True if randint(1, 13 - self.turns) <= 2 else False
            self.turns += 1

        if (((self.demon == True and not (0 in self.items)) or (self.dragon == True)) and not (3 in self.items)):
            return 0
        if (len(self.items) <= 1):
            return 0
        return 1

    def play(self, card):
        self.turns += 1

        if (card == 9):
            self.dragon = True
            return 6

        if (card == 7):
            self.demon = True
            return 6

        for i in [3, 0, 2, 1, 5, 4]:
            if (i in self.items):
                self.items.remove(i)
                return i

        return 6

    def vorpal_choice(self, last_turn):
        return 5 #If it works for others maybe it will work for us

    def result(self, bot, result, dungeon, vorped):
        self.reset()

基本的に、私たちは協定と渦状短剣を取り除き、悪魔が甲板に入るのを待って通過します。対戦相手が悪魔を引いた可能性があるすべてのラウンドでは、対戦相手が最後に引いたカードが、彼らがすでに悪魔をプレイしたと想定するために悪魔であった確率が％です。

何か間違ったことがあるかどうか教えてください。私はしばらくPythonに手を出していないので、これが私の最初のKOTHであり、午前2時なので、何かがあるはずです。

編集：

ランダム性を取り除くことは、それを大いに助けることがわかります。ランダム性は非常にばかげています。また、以下のコメントで述べたように、悪魔やドラゴンを召喚しようとします。

スティーブ

from base import BasePlayer
from random import choice

class Steve(BasePlayer):

    def reset(self):
        self.items = [0, 1, 2, 3, 4, 5]
        self.turns = 0
        self.dungeon = []
        self.possibledungeon = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 9]
        self.lastDied = 0

    def __init__(self):
        self.TRIALS = 10 #How many dungeon runs to do each turn
        self.PASS = 8    #How many dungeon runs have to have died to pass
        self.SMASHITEMS = 4 #If less dungeon runs died, smash items.
        self.reset()


    def start_turn(self, last_turn):
        if (last_turn is not None):
            self.turns += 1

            if (last_turn in self.items):
                self.items.remove(last_turn)
            else:
                self.dungeon.append(-1)


        #Check if the dungeon is lethal
        died = 0
        total_hp = 3
        if (5 in self.items):
            total_hp += 5
        if (3 in self.items):
            total_hp += 3
        vorpal = self.vorpal_choice(None)
        for i in range(self.TRIALS):
            hp = total_hp
            temppossible = self.possibledungeon.copy()
            usedpotion = False
            killedDemon = False
            #Going for a crawl
            for j in self.dungeon[::-1]:
                if (killedDemon == True): #If last round we killed the Demon
                    killedDemon = False
                    j = 0
                if (j == -1): #If we don't know what this card is
                    j = choice(temppossible)
                    temppossible.remove(j)
                if (j == 7 and 0 in self.items): #If we kill demon with the pact
                    j = 0
                    killedDemon = True
                if (j % 2 == 0 and 2 in self.items) or (j == vorpal): #If we vorpal or grail
                    j = 0

                hp -= j

                if (hp <= 0):
                    if (not usedpotion and 1 in self.items):
                        hp = 3
                        usedpotion = True
                    else:
                        died += 1
                        break

        if (died >= self.PASS):
            return 0

        died = self.lastDied
        return 1


    def play(self, card):
        self.possibledungeon.remove(card)

        if (self.lastDied < self.SMASHITEMS):
            if (7 in self.dungeon) and (0 in self.items):
                self.items.remove(0)
                return 0
            if ( (9 in self.dungeon) or (5 in self.dungeon) ) and (3 in self.items):
                self.items.remove(3)
                return 3
            for i in [2, 1, 5, 4, 3, 0]:
                if (i in self.items):
                    self.items.remove(i)
                    return i

        self.dungeon.append(card)
        return 6

    def vorpal_choice(self, last_turn):
        if (last_turn is not None):
            self.turns += 1

            if (last_turn in self.items):
                self.items.remove(last_turn)
            else:
                self.dungeon.append(-1)

        if (self.dungeon.count(5) == 2):
            return 5
        if (9 in self.dungeon):
            return 9
        if (self.dungeon.count(4) == 2 and not 2 in self.items):
            return 4
        if (7 in self.dungeon and not 0 in self.items):
            return 7
        for i in range(6)[::-1]:
            if (i+1 in self.dungeon):
                return i+1
        return 5

    def result(self, bot, result, dungeon, vorped):
        self.reset()

スティーブは、ダンジョンが致命的かどうかを推測しようとします。彼がそうだと思うなら、彼は合格する。それ以外は、彼がアイテムを賢く取り除くようにしようとしました。彼はダンジョンで死んだか、対戦相手が生きたかに応じてPASSしきい値を調整していましたが、結局彼は非常に地味だったのでそれを取り除きました。

彼はまだ私のマシンでGrailThiefを倒していませんが、少なくとも近づいています。

SlapAndFlap

KOTHでの初めてなので、間違いのために私を強く叩きます。

この1つのシンプルトンは、強力なアイテムを保持し、対戦相手に強制的にプレイさせながら、低強度のモンスターを持つすべての良いアイテムを常に削除しようとしています。
それは少なくともRunAwayとDumDumに勝っています：D
私の他のボットはしばらくの間、回答を削除しました。私はtomorowで彼を修正する必要があります

from base import BasePlayer

class SlapAndFlap(BasePlayer):

    def reset(self):
        # Monsters that you pushed in
        self.know_monster = list(self.deck)

        # Items still in game
        self.items_in_game = [True, True, True, True, True, True]

        # List of items, sorted by value
        self.valuables = [3,1,5,0,2,4]

        # Counter
        self.cards = 13

    def __init__(self):
        # Deck
        self.deck = (1,1,2,2,3,3,4,4,5,5,6,7,9)
        # Indexes of item cards
        self.items = (0, 1, 2, 3, 4, 5)

        self.reset()

    def start_turn(self, last_turn):
        if last_turn is not None:
            self.cards -= 1

        # Sneak peak at items removed by opponent
        if last_turn is not None and  last_turn < 6:
            self.items_in_game[last_turn] = False
            self.valuables.remove(last_turn)

        # Flap!
        if self.cards < 6:
            return 0
        return 1

    def play(self, card):
        if card < 6 and any(self.items_in_game):
            self.know_monster.remove(card)
            to_return = self.valuables[0]   # remove the best of the rest
            self.valuables = self.valuables[1:]
            self.items_in_game[to_return] = False
            return to_return
        else:
            return 6

    def vorpal_choice(self, last_turn):
        # We can just guess what monster will be there
        # But we know ones, we removed

        # If we have pact, no need to remove demon
        if self.items_in_game[0]:
            self.know_monster.remove(7)
        # If we have grail, no need to remove even monsters (kinda)
        if self.items_in_game[2]:
            self.know_monster = [i for i in self.know_monster if i%2]

        # Find what threatens us the most, counting its strength multiplied by number
        weight = [i * self.know_monster.count(i) for i in self.know_monster]
        return weight.index(max(weight)) + 1


    def result(self, bot, result, dungeon, vorped):
        self.reset()  # we live for the thrill, not the result!

ランダムマンダム

必須のランダムボット。適切なことに、彼はデフォルトのボットに強く負けています。これは良いことです。これは、ゲームに少なくとも何らかの戦略があることを意味します。

from base import BasePlayer
from random import randint
from random import choice
class RandomMandom(BasePlayer):
    def __init__(self):
        self.items = [0,1,2,3,4,5]

    def start_turn(self, last_turn):
        if last_turn in self.items:
            self.items.remove(last_turn)
        if len(self.items) > 0:
            return randint(0,1)
        return 1

    def play(self, card):            
        if len(self.items) > 0:
            if randint(0,1) == 1:
                selection = choice(self.items)
                self.items.remove(selection)
                return selection
        return 6

    def vorpal_choice(self, last_turn):
        return choice([1,2,3,4,5,6,7,9])

    def result(self, bot, result, dungeon, vorped):
        # Never learns
        pass

デアデビルダムダム

ちょっとクリア。決して後退しません。（一貫して、RunAwayは時々負けますが、ほとんどの場合これを上回ります）このボットに負ける唯一の方法は、アイテムを削除しないか、非常に臆病な場合です。このボットはアイテムを削除することを思い出させるものと考えてください。

from base import BasePlayer


class DareDevilDumDum(BasePlayer):
    def start_turn(self, last_turn):
        return 1  # damn squiggles. Draw a card

    def play(self, card):
        return 6+card*0  # put the card in the dungeon, and use card to avoid squiggles :P

    def vorpal_choice(self, last_turn):
        return 9+last_turn*0  # dragon

    def result(self, bot, result, dungeon, vorped):
        pass  # we live for the thrill, not the result!

そして

逃げる

だいたい彼らは鎧を取り除き、それから終わりの少し前に逃げる。daredevildumdumと同様に、デッキ内のカードの数（実際のゲームではtbhは記憶されません（確認するだけです））と、誰かがアーマーを削除したかどうか（ほとんど同じです）を除いて、何も覚えていません。 ）。

from base import BasePlayer


class RunAway(BasePlayer):

    def __init__(self):
        self.cards = 13
        self.armoured = True

    def start_turn(self, last_turn):
        if last_turn is not None:
            self.cards -= 1  # opponents play
        if last_turn is 5:
            self.armoured = False

        if self.cards < 4:
            return 0 * last_turn  # avoid the ---noid--- squiggles
        else:
            return 1

    def play(self, card):
        if self.cards > 11 and self.armoured:  # if it is the first turn and armour has not been removed
            choice = 5  # remove armour
        else:
            choice = 6  # put the card in the dungeon
        self.cards -= 1  # this play
        return choice

    def vorpal_choice(self, last_turn):
        return 5  # without using more memory, this is the best choice statistically

    def result(self, bot, result, dungeon, vorped):
        self.cards = 13
        self.armoured = True

また、私は特別なチャレンジポスターであるため、これらのボットは私のボット数にはカウントされません。

BoringPlayer

RandomMandomとは逆に、BoringPlayerは常に同じ選択を行います。問題は、そのような単純なボットにとってはあまりにも成功しているように見えることです。それは私のローカルテストで3800+を獲得しました。

from base import BasePlayer

class BoringPlayer(BasePlayer):
    def start_turn(self, last_turn):
        return 1

    def play(self, card):
        return 6

    def vorpal_choice(self, last_turn):
        return 5

    def result(self, bot, result, dungeon, vorped):
        # Never learns
        pass