- krisis dan kemartiran

(itu subtitle karena subtitle keren)

Dalam tantangan king-of-the-hill dengan python (ya; Anda tidak perlu pergi lebih jauh untuk mengetahui bahwa Anda tidak boleh mengirimkan di java), Anda perlu membuat bot yang memainkan permainan yang sangat mirip untuk menyambut ke ruang bawah tanah.

Aturan Game

(perhatikan bahwa ini bukan game asli)

Ada setumpuk, set item, dan beberapa kartu hadiah dan kartu kematian. Base HP adalah 3. Dek terdiri dari 13 kartu monster bernomor 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 9untuk menunjukkan kekuatan mereka.

Daftar Barang

1. Pakta iblis: Kalahkan iblis (kekuatan 7 monster), dan monster di bawahnya di tumpukan penjara bawah tanah. - (hanya mengalahkan iblis jika iblis adalah yang terakhir di penjara bawah tanah)

2. Ramuan kesehatan: Saat kamu jatuh ke 0 HP, kalahkan monster itu dan kembali ke 3 HP.

3. Holy grail: Kalahkan monster dengan kekuatan genap (dalam game, ini adalah undead). Jika monster bilangan genap terjadi setelah pakta iblis digunakan, itu akan bertindak terlebih dahulu, dan kamu tidak akan mendapatkan kill pakta ekstra setelah monster ini.

4. Belati Vorpal: Pilih satu monster sebelum memasuki ruang bawah tanah; jenis monster ini dikalahkan. Jika monster yang ditargetkan terjadi setelah pakta iblis digunakan, itu bertindak terlebih dahulu, dan kamu tidak akan mendapatkan pakta ekstra setelah monster ini.

5. Shield: Tambahkan 3 ke total HP sebelum spelunking. Ini tidak mempengaruhi penggunaan ramuan kesehatan, yang akan selalu mengembalikan kesehatan ke 3.

6. Armor: Tambahkan 5 ke total HP sebelum spelunking. Ini tidak mempengaruhi penggunaan ramuan kesehatan, yang akan selalu mengembalikan kesehatan ke 3.

Kartu hadiah digunakan untuk melacak siapa yang telah berhasil di ruang bawah tanah. Kartu kematian melacak siapa yang gagal di ruang bawah tanah.

Fase Menggambar

Sebelum fase menggambar dimulai, semua kartu monster dikembalikan ke geladak, kedua pemain dikembalikan ke 3 HP, dan semua barang yang dibuang dikembalikan sehingga ada masing-masing.

Pemain pertama memutuskan apakah akan mengambil kartu dari dek, menyembunyikannya dari pemain lain. Jika demikian, mereka harus memilih untuk meletakkannya di atas tumpukan bawah tanah atau membuangnya bersama dengan item pilihan mereka. Item dan kartu yang dibuang akan tidak tersedia untuk salah satu pemain hingga ronde berikutnya.

Setelah pemain satu bergiliran, pemain dua melakukan hal yang sama. Para pemain secara bergantian memutuskan apakah akan menggambar dan apa yang harus dilakukan dengan kartu yang ditarik, sampai seseorang memutuskan untuk tidak menggambar atau seorang pemain mengambil kartu terakhir dari geladak. Jika seorang pemain memutuskan untuk tidak menggambar, atau menggambar kartu terakhir, fase menggambar berakhir dan pemain lain sekarang harus memasuki ruang bawah tanah dan mulai spelunking.

Fase spelunking

Jika belati Vorpal belum dibuang, pemain spelunking sekarang harus memutuskan kartu yang akan digunakan. Tidak ada keputusan aktif yang harus dibuat untuk sisa fase ini.

Pemain pertama mengambil kartu teratas; yaitu, kartu terakhir yang ditempatkan di ruang bawah tanah, dan lihat nomor kekuatannya. Jika pakta iblis aktif dari belokan sebelumnya, kartu yang ditarik dibuang. Jika tidak, item pemain akan diperiksa dalam urutan 'pakta iblis', 'cawan suci', 'belati Vorpal'. Item un-discarded pertama yang mampu mengalahkan kartu yang ditarik kemudian akan digunakan, dan kartu tersebut dibuang. Jika pakta iblis digunakan, sekarang akan aktif untuk kartu berikutnya. Item yang digunakan tidak dibuang.

Jika tidak ada item yang berlaku tersedia, kekuatan kartu dikurangi dari kesehatan pemain. Jika kesehatan mereka tidak lagi positif, mereka akan dikembalikan ke 3 HP dan ramuan dibuang jika tersedia, jika penjelajahan bawah tanah berakhir dan mereka mengambil kartu kematian.

Sementara pemain tidak dikalahkan dan ada kartu yang tersisa di ruang bawah tanah, proses menggambar kartu teratas diulang. Setelah berhasil mengalahkan semua kartu di ruang bawah tanah, penjelajahan ruang bawah tanah berakhir dan pemain spelunking mengumpulkan kartu hadiah.

Deskripsi Game Lengkap

Sebuah permainan terdiri dari serangkaian putaran, masing-masing memiliki fase menggambar dan kemudian fase spelunking. Pada akhir setiap putaran satu pemain akan mengumpulkan kartu kematian atau kartu hadiah; setelah seorang pemain menumpuk 5 dari kedua jenis permainan berakhir. Jika mereka memiliki 5 kartu kematian, mereka kalah. Jika mereka memiliki 5 kartu hadiah, mereka menang. Either way, pemain lain menerima hasil sebaliknya. Jika tidak ada pemain yang memiliki 5 kartu dari satu jenis, permainan berlanjut ke babak berikutnya dan pemain yang menempati posisi kedua di babak sebelumnya sekarang menjadi yang pertama dan sebaliknya.

Rincian KOTH

Setiap bot akan memainkan 400 pertandingan melawan setiap bot lainnya sesuai dengan aturan yang dijelaskan di atas. Bot mana yang merupakan pemain satu (dan seterusnya di babak pertama) bergantian setiap pertandingan, dan semua negara disetel ulang di antara permainan.

Ini barangnya lagi:

1. Pakta iblis: Kalahkan iblis (kekuatan 7 monster), dan monster di bawahnya di tumpukan penjara bawah tanah. - (hanya mengalahkan iblis jika iblis adalah yang terakhir di penjara bawah tanah)

2. Ramuan kesehatan: Saat kamu jatuh ke 0 HP, kalahkan monster itu dan kembali ke 3 HP.

3. Holy grail: Kalahkan monster dengan kekuatan genap (dalam game, ini adalah undead). Jika monster bilangan genap terjadi setelah pakta iblis digunakan, itu akan bertindak terlebih dahulu, dan kamu tidak akan mendapatkan kill pakta ekstra setelah monster ini.

4. Belati Vorpal: Pilih satu monster sebelum memasuki ruang bawah tanah; jenis monster ini dikalahkan. Jika monster yang ditargetkan terjadi setelah pakta iblis digunakan, itu bertindak terlebih dahulu, dan kamu tidak akan mendapatkan pakta ekstra setelah monster ini.

5. Shield: Tambahkan 3 ke total HP sebelum spelunking. Ini tidak mempengaruhi penggunaan ramuan kesehatan, yang akan selalu mengembalikan kesehatan ke 3.

6. Armor: Tambahkan 5 ke total HP sebelum spelunking. Ini tidak mempengaruhi penggunaan ramuan kesehatan, yang akan selalu mengembalikan kesehatan ke 3.

dan dek: 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 9.

Anda harus mengimplementasikan kelas bot yang tidak menggunakan variabel kelas, berasal dari kelas dasar berikut:

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

Kelas dasar ini menunjukkan metode yang perlu diterapkan oleh kelas Anda, dan jumlah argumen yang diambil oleh masing-masing.

Deskripsi Metode Argumen

• last_turnin vorpal_choicedan start_turnmerupakan integer atau nilai None. Nilai 0 hingga 5 menunjukkan bahwa musuh membuang kartu yang ditarik bersama dengan item yang ditunjukkan oleh nilai itu (lihat daftar item di atas). Nilai 6 menunjukkan bahwa musuh meletakkan kartu di penjara bawah tanah. Nilai Tidak ada menunjukkan bahwa bot bermain pertama di babak ini (tidak mungkin untuk vorpal_choice). Dalam vorpal_choicelast_turn cenderung 7, menunjukkan bahwa mereka melewati belokan itu. Satu-satunya keadaan di mana itu bukan 7 adalah ketika musuh menarik kartu terakhir.

• card adalah angka yang mewakili kekuatan salah satu kartu dari dek seperti yang disebutkan di atas.

Sekarang, argumen resultuntuknya sedikit lebih kompleks:

• botmenunjukkan bot yang memasuki ruang bawah tanah. 0 menunjukkan memasuki ruang bawah tanah, dan 1 menunjukkan bahwa musuh memasuki ruang bawah tanah.

• resultmenunjukkan keberhasilan perjalanan. Salah menunjukkan bot spelunking berhasil, sementara True menunjukkan mereka gagal.

• dungeonadalah daftar kartu / int yang mewakili kartu yang ada di ruang bawah tanah. Penjara bawah tanah dipesan berdasarkan pesanan; kartu pertama yang ditempatkan di ruang bawah tanah adalah yang pertama dalam daftar, dan kartu terakhir yang ditempatkan adalah di akhir. Anda tidak akan menerima info apa pun tentang kartu yang dibuang; mereka rahasia dari bot lain.

• vorpedadalah integer yang mewakili vorpal_choicebot spelunking. Jika bot==0, Anda sudah tahu ini, tetapi jika bot==1, ini bisa menjadi informasi yang berguna.

Saya akan jujur, saya tidak sepenuhnya ingat mengapa saya membuat hasil kemenangan False, tapi saya pikir itu ide yang bagus saat itu.

Nilai Pengembalian

• start_turn: Kembali 1 untuk menggambar kartu, atau 0 untuk lulus.

• play: Kembalikan 0 hingga 5 untuk membuang item yang sesuai dan kartu yang ditarik, atau 6 untuk menempatkan kartu di penjara bawah tanah (konsisten dengan input last_turn, kecuali untuk passing, yang dilakukan selama start_turn).

• vorpal_choice: Kembalikan jumlah kartu yang ingin Anda hilangkan dengan belati Vorpal (1 untuk menghilangkan 1s, 5 untuk menghilangkan 5s). Memilih kartu yang tidak ada akan membunuh Anda (8 ilegal, 10 ilegal, 0 ilegal).

• result: Anda dapat mengembalikan apa pun, karena ini adalah fungsi menginformasikan untuk memperbarui data bot.

Anda dapat memeriksa pengontrol di sini

Klarifikasi tambahan, atau hanya mengulangi beberapa detail kecil yang mungkin Anda lewatkan dan mungkin ingin Anda ketahui dengan cepat:

Bot memainkan 400 game dengan satu sama bot lainnya.

Tidak ada variabel kelas

Tidak ada penargetan bot khusus lainnya

Tidak mendukung bot lainnya

Tidak ada hal-hal refleksi seperti memodifikasi modul acak atau bot lainnya.

Maksimal 6 bot (per orang), kecuali jika jelas bahwa semua bot bernilai termasuk dalam KOTH (tapi masih mungkin jangan membuat banyak bot)

Tidak ada waktu akhir yang spesifik untuk KOTH ini, kecuali akhir dari hadiah untuk apa yang bernilai. Cobalah untuk menang setiap saat.

Hasil sejauh ini (maaf karena agak malas dengan orang-orang ini: 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 "mencuri" hadiah itu. tidak juga, karena ia mendapatkannya. Kerja bagus, Sleafar!

GrailThief

Perayap bawah tanah yang lama dan berpengalaman. Dia tahu bahwa sebagian besar yang lain berharap, bahwa cawan suci menyelamatkan mereka, oleh karena itu dia memastikan itu lenyap.

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

Upaya pertama saya pada tantangan 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()

Pada dasarnya, kita menyingkirkan pakta dan belati vorpal, menunggu iblis masuk ke geladak, dan berlalu. Setiap putaran lawan mungkin telah menggambar iblis, itu memiliki% peluang bahwa kartu terakhir yang digambar lawan adalah iblis untuk mengasumsikan mereka sudah memainkan iblis itu.

Beri tahu saya jika ada kesalahan saya; Saya belum pernah mengacaukan python, ini KOTH pertama saya, dan ini jam 2 pagi, jadi pasti ada sesuatu.

EDIT:

Menghilangkan keacakan ternyata sangat membantu. Dengan keacakan itu sangat bodoh. Juga, seperti yang dikatakan di komentar di bawah, ia mencoba memanggil iblis atau naga.

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 mencoba menebak apakah ruang bawah tanah itu mematikan atau tidak. Jika dia pikir itu benar, dia lewat. Selain itu, saya mencoba membuatnya menyingkirkan barang dengan cerdas. Dia biasa menyesuaikan ambang LULUS nya tergantung pada apakah dia mati di penjara bawah tanah atau lawan hidup, tapi itu akhirnya membuatnya banyak bodoh jadi aku menyingkirkannya.

Dia masih belum mengalahkan GrailThief di mesin saya, tapi setidaknya semakin dekat.

SlapAndFlap

Pertama kali di KOTH, jadi tampar aku keras karena kesalahan.

Simpleton yang satu ini selalu berusaha untuk menghapus semua item bagus dengan monster kekuatan rendah, sambil tetap mempertahankan yang kuat dan kemudian hanya memaksa lawan untuk bermain.
Ini mengalahkan RunAway dan DumDum setidaknya: D
bot saya yang lain dalam jawaban yang dihapus untuk beberapa waktu, saya perlu memperbaikinya oleh besok

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

Bot acak wajib. Secara tepat, ia kalah keras dari bot default, yang bagus, karena itu berarti permainan memiliki setidaknya beberapa strategi.

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

agak jelas. tidak pernah mundur. satu-satunya cara Anda dapat (secara konsisten; RunAway kadang-kadang kehilangan tetapi masih mengalahkan ini sebagian besar waktu) kehilangan bot ini adalah jika Anda tidak menghapus item apa pun atau pengecut super. anggap bot ini sebagai pengingat untuk menghapus item, jika tidak, bahkan ini bisa menang.

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!

Dan

Melarikan diri

cukup banyak mereka melepas baju besi dan kemudian melarikan diri beberapa saat sebelum akhir. sebagai daredevildumdum, tidak ingat apa-apa, kecuali untuk jumlah kartu di dek (yang tbh tidak akan diingat dalam permainan yang sebenarnya (Anda baru saja memeriksa)) dan apakah seseorang melepaskan baju besi (kebanyakan sama seperti sebelumnya ).

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

Juga karena saya poster tantangan khusus, bot ini tidak dihitung terhadap jumlah bot saya, karena mereka adalah contoh bot yang bodoh

BoringPlayer

Kebalikan dari RandomMandom, BoringPlayer selalu membuat pilihan yang sama. Masalahnya adalah tampaknya terlalu sukses untuk bot sederhana. Skor 3800+ dalam tes lokal saya.

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