- von Krise und Martyrium

(das ist der Untertitel, weil Untertitel cool sind)

Bei dieser King-of-the-Hill- Herausforderung in Python (yup; Sie müssen nicht weiter gehen, um zu wissen, dass Sie sich nicht in Java einreichen dürfen) müssen Sie einen Bot erstellen, der ein Spiel spielt, das dem Willkommen im Dungeon sehr ähnlich ist

Spielregeln

(Beachten Sie, dass dies nicht das ursprüngliche Spiel ist)

Es gibt ein Deck, ein Item-Set und einige Belohnungs- und Todeskarten. Die Basis-HP sind 3. Das Deck besteht aus 13 Monsterkarten, die nummeriert sind 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 9, um ihre Stärken anzuzeigen.

Artikelliste

1. Dämonischer Pakt: Besiege den Dämon (Monster der Stärke 7) und das Monster darunter auf dem Dungeonstapel. - (besiegt nur den Dämon, wenn der Dämon der letzte im Dungeon war)

2. Heiltrank: Wenn du auf 0 HP fällst, besiege das Monster und kehre zu 3 HP zurück.

3. Heiliger Gral: Besiege Monster mit gerader Stärke (im Spiel sind diese Untote). Wenn ein Monster mit gerader Nummer auftritt, nachdem der dämonische Pakt angewendet wurde, handelt dies zuerst und Sie erhalten nach diesem Monster keinen zusätzlichen Pakt-Kill.

4. Vorpal-Dolch: Wähle ein Monster aus, bevor du den Dungeon betrittst. Diese Art von Monster ist besiegt. Wenn das Zielmonster auftritt, nachdem der dämonische Pakt angewendet wurde, handelt dies zuerst und Sie erhalten nach diesem Monster keinen zusätzlichen Pakt-Kill.

5. Schild: Addiere 3 zur Gesamt-HP vor dem Höhlenforschen. Dies hat keinen Einfluss auf die Verwendung von Heiltrank, wodurch die Gesundheit immer wieder auf 3 zurückgesetzt wird.

6. Rüstung: Addiere 5 zu den gesamten HP, bevor du Höhlenforscher bist. Dies hat keinen Einfluss auf die Verwendung von Heiltrank, wodurch die Gesundheit immer wieder auf 3 zurückgesetzt wird.

Belohnungskarten werden verwendet, um zu verfolgen, wer im Dungeon erfolgreich war. Todeskarten verfolgen, wer im Dungeon versagt hat.

Zeichenphase

Bevor die Ziehphase beginnt, werden alle Monsterkarten in das Deck zurückgelegt, beide Spieler werden auf 3 HP wiederhergestellt und alle weggeworfenen Gegenstände werden so wiederhergestellt, dass es jeweils eine gibt.

Der erste Spieler entscheidet, ob er eine Karte aus dem Stapel zieht und sie vor dem anderen Spieler versteckt. In diesem Fall müssen sie entweder auf den Dungeonstapel legen oder zusammen mit einem Gegenstand ihrer Wahl wegwerfen. Abgeworfene Gegenstände und Karten sind für beide Spieler bis zur nächsten Runde nicht verfügbar.

Nachdem Spieler eins an der Reihe ist, macht Spieler zwei dasselbe. Die Spieler entscheiden abwechselnd, ob sie ziehen und was mit der gezogenen Karte geschehen soll, bis sich jemand entscheidet, nicht zu ziehen, oder ein Spieler die letzte Karte vom Stapel nimmt. Wenn ein Spieler beschließt, nicht zu ziehen oder die letzte Karte zu ziehen, endet die Ziehphase und der andere Spieler muss nun den Dungeon betreten und mit dem Höhlenforschen beginnen.

Höhlenforschungsphase

Wenn der Vorpal-Dolch nicht abgelegt wurde, muss der Höhlenforscher nun entscheiden, auf welche Karte er angewendet werden soll. Für den Rest dieser Phase sind keine aktiven Entscheidungen zu treffen.

Der erste Spieler nimmt die oberste Karte; Das heißt, die letzte Karte, die in den Dungeon gelegt wurde, und ihre Stärkezahl sehen. Wenn der dämonische Pakt aus dem vorherigen Zug aktiv ist, wird die gezogene Karte abgelegt. Andernfalls werden die Gegenstände des Spielers in der Reihenfolge "Dämonischer Pakt", "Heiliger Gral", "Vorpal-Dolch" überprüft. Der erste nicht weggeworfene Gegenstand, der die gezogene Karte besiegen kann, wird dann verwendet und die Karte weggeworfen. Wenn ein dämonischer Pakt verwendet wird, ist er jetzt für die nächste Karte aktiv. Der gebrauchte Gegenstand wird nicht weggeworfen.

Wenn kein zutreffender Gegenstand verfügbar ist, wird die Stärke der Karte von der Gesundheit des Spielers abgezogen. Wenn ihre Gesundheit nicht mehr positiv ist, werden sie auf 3 HP wiederhergestellt und der Trank weggeworfen, falls verfügbar. Andernfalls endet der Dungeon-Crawl und sie erhalten eine Todeskarte.

Während der Spieler nicht besiegt ist und noch Karten im Dungeon sind, wird dieser Vorgang des Ziehens der obersten Karte wiederholt. Wenn alle Karten im Dungeon erfolgreich besiegt wurden, endet der Dungeon-Crawl und der Höhlenforscher sammelt eine Belohnungskarte.

Vollständige Spielbeschreibung

Ein Spiel besteht aus einer Reihe von Runden, die jeweils eine Ziehphase und dann eine Höhlenforschungsphase haben. Am Ende jeder Runde hat ein Spieler entweder eine Todeskarte oder eine Belohnungskarte gesammelt. Sobald ein Spieler 5 von beiden Typen gesammelt hat, endet das Spiel. Wenn sie 5 Todeskarten haben, verlieren sie das Spiel. Wenn sie 5 Belohnungskarten haben, gewinnen sie. In jedem Fall erhält der andere Spieler das gegenteilige Ergebnis. Wenn keiner der Spieler 5 Karten eines Typs hat, geht das Spiel in die nächste Runde und der Spieler, der in der vorherigen Runde Zweiter wurde, geht jetzt zuerst und umgekehrt.

KOTH Details

Jeder Bot spielt 400 Spiele gegen jeden anderen Bot gemäß den oben beschriebenen Regeln. Welcher Bot Spieler eins ist (und so geht er in der ersten Runde als Erster), wechselt jedes Spiel und jeder Status wird zwischen den Spielen zurückgesetzt.

Hier sind noch einmal die Artikel:

1. Dämonischer Pakt: Besiege den Dämon (Monster der Stärke 7) und das Monster darunter auf dem Dungeonstapel. - (besiegt nur den Dämon, wenn der Dämon der letzte im Dungeon war)

2. Heiltrank: Wenn du auf 0 HP fällst, besiege das Monster und kehre zu 3 HP zurück.

3. Heiliger Gral: Besiege Monster mit gerader Stärke (im Spiel sind diese Untote). Wenn ein Monster mit gerader Nummer auftritt, nachdem der dämonische Pakt angewendet wurde, handelt dies zuerst und Sie erhalten nach diesem Monster keinen zusätzlichen Pakt-Kill.

4. Vorpal-Dolch: Wähle ein Monster aus, bevor du den Dungeon betrittst. Diese Art von Monster ist besiegt. Wenn das Zielmonster auftritt, nachdem der dämonische Pakt angewendet wurde, handelt dies zuerst und Sie erhalten nach diesem Monster keinen zusätzlichen Pakt-Kill.

5. Schild: Addiere 3 zur Gesamt-HP vor dem Höhlenforschen. Dies hat keinen Einfluss auf die Verwendung von Heiltrank, wodurch die Gesundheit immer wieder auf 3 zurückgesetzt wird.

6. Rüstung: Addiere 5 zu den gesamten HP, bevor du Höhlenforscher bist. Dies hat keinen Einfluss auf die Verwendung von Heiltrank, wodurch die Gesundheit immer wieder auf 3 zurückgesetzt wird.

und das Deck : 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 9.

Sie müssen eine Bot-Klasse implementieren, die keine Klassenvariablen verwendet und von der folgenden Basisklasse abgeleitet ist:

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

Diese Basisklasse zeigt die Methoden, die Ihre Klasse implementieren muss, und die Anzahl der Argumente, die von jeder Klasse verwendet werden.

Beschreibungen der Methodenargumente

• last_turnin vorpal_choiceund start_turnist eine Ganzzahl oder ein Wert von None. Ein Wert von 0 bis 5 zeigt an, dass der Feind die gezogene Karte zusammen mit dem durch diesen Wert angegebenen Gegenstand abgelegt hat (siehe Liste der Gegenstände oben). Ein Wert von 6 zeigt an, dass der Feind die Karte in den Dungeon gelegt hat. Ein Wert "Keine" zeigt an, dass der Bot in dieser Runde zuerst spielt (nicht möglich für vorpal_choice). In vorpal_choicelast_turn ist es wahrscheinlich 7, was darauf hinweist, dass sie diese Runde bestanden haben. Der einzige Umstand, unter dem es nicht 7 ist, ist, als der Feind die letzte Karte gezogen hat.

• card ist eine Zahl, die die Stärke einer der oben aufgeführten Karten aus dem Stapel darstellt.

Jetzt sind die Argumente für resultetwas komplexer:

• botzeigt den Bot an, der den Dungeon betreten hat. 0 zeigt an, dass der Dungeon betreten wurde, und 1 zeigt an, dass der Feind den Dungeon betreten hat.

• resultzeigt den Erfolg der Reise an. False zeigt an, dass der Höhlenforscher erfolgreich war, während True anzeigt, dass sie fehlgeschlagen sind.

• dungeonist eine Liste von Karten / Ints, die die Karten darstellen, die sich im Dungeon befanden. Der Dungeon wird auf Bestellung bestellt. Die erste Karte im Dungeon steht an erster Stelle in der Liste und die letzte Karte am Ende. Sie erhalten keine Informationen über weggeworfene Karten. Sie sind vor dem anderen Bot geheim.

• vorpedist eine Ganzzahl, die vorpal_choicedie vom Höhlenforscher erstellte darstellt. Wenn bot==0, wissen Sie das bereits, aber wenn bot==1, kann dies eine nützliche Information sein.

Ich bin ehrlich, ich erinnere mich nicht ganz, warum ich das Gewinnergebnis falsch gemacht habe, aber ich denke, es war damals eine gute Idee.

Rückgabewerte

• start_turn: Gib 1 zurück, um eine Karte zu ziehen, oder 0, um zu passen.

• play: Geben Sie 0 bis 5 zurück, um den entsprechenden Gegenstand und die gezogene Karte abzulegen, oder 6, um die Karte in den Dungeon zu legen (im Einklang mit der Eingabe von last_turn, außer beim Übergeben, das während start_turn erfolgt).

• vorpal_choice: Geben Sie die Nummer der Karte zurück, die Sie mit dem Vorpal-Dolch eliminieren möchten (1, um 1s zu eliminieren, 5, um 5s zu eliminieren). Wenn Sie eine nicht vorhandene Karte auswählen, werden Sie getötet (8 ist illegal, 10 ist illegal, 0 ist illegal).

• result: Sie können alles zurückgeben, da dies eine Informationsfunktion zum Aktualisieren der Bot-Daten ist.

Sie können den Controller hier überprüfen

Zusätzliche Erläuterungen oder nur das Wiederholen einiger kleiner Details, die Sie möglicherweise übersprungen haben und schnell wissen möchten:

Bots spielen 400 Spiele miteinander.

Keine Klassenvariablen

Kein Targeting auf bestimmte andere Bots

Kein Stützen anderer Bots

Keine Reflexionssachen wie das Ändern des Zufallsmoduls oder anderer Bots.

Maximal 6 Bots (pro Person), es sei denn, es ist offensichtlich, dass alle Bots es wert sind, in den KOTH aufgenommen zu werden (aber wahrscheinlich machen Sie trotzdem keine Bots)

Es gibt keine bestimmte Endzeit für diesen KOTH, außer das Ende der Prämie für das, was das wert ist. Versuchen Sie einfach, jedes Mal zu gewinnen.

Bisherige Ergebnisse (Entschuldigung, dass ich mit diesen Jungs ziemlich faul bin: 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 "stiehlt" das Kopfgeld. nicht wirklich, weil es es verdient hat. Gute Arbeit, Sleafar!

GrailThief

Ein alter und erfahrener Dungeon-Crawler. Er weiß, dass die meisten anderen hoffen, dass der heilige Gral sie rettet, deshalb sorgt er dafür, dass er verschwindet.

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()

DevilWorshipper

Mein erster Versuch einer KOTH-Herausforderung:

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()

Im Wesentlichen werden wir den Pakt und den Vorpal-Dolch los, warten, bis der Dämon ins Deck kommt, und gehen vorbei. In jeder Runde, in der der Gegner den Dämon gezogen hat, besteht die prozentuale Wahrscheinlichkeit, dass die letzte Karte, die der Gegner gezogen hat, ein Dämon war, um einfach anzunehmen, dass er den Dämon bereits gespielt hat.

Lassen Sie mich wissen, wenn ich etwas falsch gemacht habe. Ich habe eine Weile nicht mehr mit Python rumgespielt, dies ist mein erster KOTH und es ist 2 Uhr morgens, also wird es bestimmt etwas geben.

EDITS:

Das Herausnehmen der Zufälligkeit hilft ihm sehr. Mit der Zufälligkeit ist es sehr dumm. Wie in den Kommentaren unten erwähnt, wird auch versucht, den Dämon oder Drachen zu beschwören.

Steve

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()

Steve versucht zu erraten, ob der Dungeon tödlich ist oder nicht. Wenn er glaubt, dass es so ist, geht er vorbei. Davon abgesehen habe ich versucht, ihn dazu zu bringen, Gegenstände klug loszuwerden. Er passte seine PASS-Schwelle an, je nachdem, ob er im Dungeon starb oder der Gegner lebte, aber es machte ihn viel dümmer, so dass ich ihn loswurde.

Er schlägt GrailThief auf meiner Maschine immer noch nicht, kommt aber zumindest näher.

SlapAndFlap

Zum ersten Mal in KOTH, also schlag mich hart für Fehler.

Dieser eine Simpleton versucht immer, alle guten Gegenstände mit Monstern mit geringer Stärke zu entfernen, während er mächtige behält und dann den Gegner zum Spielen zwingt.
Es schlägt RunAway und DumDum mindestens: D
Mein anderer Bot in gelöschter Antwort für einige Zeit, ich muss ihn bis morgen reparieren

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!

RandomMandom

Der obligatorische Zufallsbot. Passenderweise verliert er schwer gegen die Standard-Bots, was gut ist, weil es bedeutet, dass das Spiel zumindest eine Strategie hat.

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

DareDevilDumDum

irgendwie klar. macht niemals einen Rückzieher. Der einzige Weg, wie Sie (konsequent; RunAway verliert manchmal, aber es schlägt dies meistens immer noch) gegen diesen Bot verlieren können, ist, wenn Sie keine Gegenstände entfernen oder ein Super-Feigling sind. Stellen Sie sich diesen Bot als Erinnerung vor, um Gegenstände zu entfernen, sonst kann auch dieser gewinnen.

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!

Und

Renn weg

so ziemlich entfernen sie Rüstungen und rennen dann einige Zeit vor dem Ende weg. als daredevildumdum erinnert es sich an nichts, außer an die Anzahl der Karten im Deck (an die sich tbh im eigentlichen Spiel nicht erinnern würde (Sie würden nur nachsehen)) und ob jemand die Rüstung entfernt hat (meistens die gleiche wie zuvor ).

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

Auch weil ich ein spezielles Herausforderungsposter bin, zählen diese Bots nicht für meine Botanzahl, da es sich um Beispielbots handelt, die dumm sind

BoringPlayer

Im Gegensatz zu RandomMandom trifft BoringPlayer immer die gleichen Entscheidungen. Das Problem ist, dass es für einen so einfachen Bot zu erfolgreich zu sein scheint. In meinem lokalen Test werden 3800+ Punkte erzielt.

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