- của khủng hoảng và tử đạo

(đó là phụ đề vì phụ đề rất tuyệt)

Trong thử thách vua đồi này trong python (yup; bạn không cần phải đi xa hơn để biết bạn có thể không gửi java), bạn cần tạo một bot chơi một trò chơi rất giống với chào mừng đến ngục tối

Luật chơi

(lưu ý rằng đây không phải là trò chơi gốc)

Có một bộ bài, một bộ vật phẩm, và một số thẻ phần thưởng và thẻ tử thần. HP cơ bản là 3. Bộ bài gồm 13 lá bài quái vật được đánh số 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 9để biểu thị sức mạnh của chúng.

Danh sách vật phẩm

1. Hiệp ước quỷ: Đánh bại yêu quái (sức mạnh 7 quái vật) và quái vật bên dưới nó trên đống ngục tối. - (chỉ cần đánh bại con quỷ nếu con quỷ là người cuối cùng trong ngục tối)

2. Thuốc bổ máu: Khi bạn rơi xuống 0 HP, đánh bại quái vật và trở về 3 HP.

3. Chén thánh: Đánh bại quái vật có sức mạnh số chẵn (trong trò chơi, đây là những xác sống). Nếu một quái vật được đánh số chẵn xuất hiện sau khi hiệp ước ma quỷ được sử dụng, hành động đó trước tiên và bạn sẽ không bị giết thêm hiệp ước sau con quái vật này.

4. Dao găm Vorpal: Chọn một quái vật trước khi vào ngục tối; loại quái vật này bị đánh bại. Nếu quái vật được nhắm mục tiêu xảy ra sau khi hiệp ước ma quỷ được sử dụng, hành động đó trước tiên và bạn sẽ không bị giết thêm hiệp ước sau con quái vật này.

5. Khiên: Thêm 3 vào tổng HP trước khi chơi game. Điều này không ảnh hưởng đến việc sử dụng thuốc trong sức khỏe, nó sẽ luôn trả lại sức khỏe cho 3.

6. Giáp: Thêm 5 vào tổng HP trước khi chơi game. Điều này không ảnh hưởng đến việc sử dụng thuốc trong sức khỏe, nó sẽ luôn trả lại sức khỏe cho 3.

Thẻ phần thưởng được sử dụng để theo dõi những người đã thành công trong ngục tối. Thẻ tử thần theo dõi những người đã thất bại trong ngục tối.

Vẽ giai đoạn

Trước khi giai đoạn vẽ bắt đầu, tất cả các thẻ bài quái vật được đưa trở lại bộ bài, cả hai người chơi được khôi phục lại 3 HP và tất cả các vật phẩm bị loại bỏ được khôi phục sao cho có một thẻ.

Người chơi đầu tiên quyết định có rút thẻ từ bộ bài hay không, giấu nó khỏi người chơi khác. Nếu vậy, họ phải chọn đặt nó lên trên cùng của đống ngục tối hoặc loại bỏ nó cùng với một vật phẩm mà họ lựa chọn. Các vật phẩm và thẻ bị loại bỏ sẽ không có sẵn cho bất kỳ người chơi nào cho đến vòng tiếp theo.

Sau khi người chơi thay phiên nhau, người chơi thứ hai cũng làm như vậy. Người chơi thay phiên nhau quyết định rút và làm gì với thẻ đã rút, cho đến khi ai đó quyết định không rút hoặc người chơi lấy lá bài cuối cùng từ bộ bài. Nếu một người chơi quyết định không rút hoặc rút lá bài cuối cùng, giai đoạn vẽ kết thúc và người chơi khác bây giờ phải vào ngục tối và bắt đầu chơi trò chơi.

Giai đoạn phát triển

Nếu dao găm Vorpal chưa bị loại bỏ, người chơi trò chơi bây giờ phải quyết định áp dụng thẻ nào. Không có quyết định tích cực nào được đưa ra cho phần còn lại của giai đoạn này.

Người chơi đầu tiên lấy thẻ hàng đầu; đó là lá bài cuối cùng được đặt trong ngục tối và xem số sức mạnh của nó. Nếu hiệp ước ma quỷ được kích hoạt từ lượt trước, thẻ rút ra sẽ bị loại bỏ. Nếu không, các vật phẩm của người chơi sẽ được kiểm tra theo thứ tự 'hiệp ước ma quỷ', 'chén thánh', 'dao găm Vorpal'. Vật phẩm đầu tiên không bị loại bỏ có khả năng đánh bại thẻ đã rút sẽ được sử dụng và thẻ bị loại bỏ. Nếu hiệp ước ma quỷ được sử dụng, bây giờ nó sẽ hoạt động cho thẻ tiếp theo. Các mặt hàng được sử dụng không được loại bỏ.

Nếu không có vật phẩm áp dụng có sẵn, sức mạnh của thẻ sẽ bị trừ khỏi sức khỏe của người chơi. Nếu sức khỏe của họ không còn tích cực, họ sẽ được phục hồi lên 3 HP và thuốc sẽ bị loại bỏ nếu có, nếu không thì hầm ngục kết thúc và họ lấy thẻ tử thần.

Trong khi người chơi không bị đánh bại và vẫn còn những lá bài trong ngục tối, quá trình rút lá bài trên cùng được lặp lại. Khi đánh bại thành công tất cả các thẻ trong ngục tối, việc thu thập thông tin kết thúc và người chơi chơi trò chơi thu thập một thẻ phần thưởng.

Mô tả trò chơi đầy đủ

Một trò chơi bao gồm một loạt các vòng, mỗi vòng có một pha vẽ và sau đó là một pha chơi trò chơi. Vào cuối mỗi vòng, một người chơi sẽ thu được thẻ tử thần hoặc thẻ phần thưởng; một khi người chơi tích lũy được 5 trong số các loại trò chơi kết thúc. Nếu họ có 5 thẻ tử thần, họ sẽ thua trò chơi. Nếu họ có 5 thẻ thưởng, họ sẽ thắng. Dù bằng cách nào, người chơi khác nhận được kết quả ngược lại. Nếu không có người chơi nào có 5 thẻ loại một, thì chơi tiến tới vòng tiếp theo và người chơi thứ hai ở vòng trước sẽ đi trước và ngược lại.

Chi tiết

Mỗi bot sẽ chơi 400 trò chơi với mọi bot khác theo các quy tắc được mô tả ở trên. Bot nào là người chơi một (và cứ thế đi trước trong vòng đầu tiên) xen kẽ mỗi trò chơi và tất cả trạng thái được đặt lại giữa các trò chơi.

Đây là các mục một lần nữa:

1. Hiệp ước quỷ: Đánh bại yêu quái (sức mạnh 7 quái vật) và quái vật bên dưới nó trên đống ngục tối. - (chỉ cần đánh bại con quỷ nếu con quỷ là người cuối cùng trong ngục tối)

2. Thuốc bổ máu: Khi bạn rơi xuống 0 HP, đánh bại quái vật và trở về 3 HP.

3. Chén thánh: Đánh bại quái vật có sức mạnh số chẵn (trong trò chơi, đây là những xác sống). Nếu một quái vật được đánh số chẵn xuất hiện sau khi hiệp ước ma quỷ được sử dụng, hành động đó trước tiên và bạn sẽ không bị giết thêm hiệp ước sau con quái vật này.

4. Dao găm Vorpal: Chọn một quái vật trước khi vào ngục tối; loại quái vật này bị đánh bại. Nếu quái vật được nhắm mục tiêu xảy ra sau khi hiệp ước ma quỷ được sử dụng, hành động đó trước tiên và bạn sẽ không bị giết thêm hiệp ước sau con quái vật này.

5. Khiên: Thêm 3 vào tổng HP trước khi chơi game. Điều này không ảnh hưởng đến việc sử dụng thuốc trong sức khỏe, nó sẽ luôn trả lại sức khỏe cho 3.

6. Giáp: Thêm 5 vào tổng HP trước khi chơi game. Điều này không ảnh hưởng đến việc sử dụng thuốc trong sức khỏe, nó sẽ luôn trả lại sức khỏe cho 3.

và bộ bài : 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 9.

Bạn phải triển khai một lớp bot không sử dụng các biến lớp, xuất phát từ lớp cơ sở sau:

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

Lớp cơ sở này hiển thị các phương thức mà lớp của bạn cần thực hiện và số lượng đối số được thực hiện bởi mỗi phương thức.

Phương pháp mô tả đối số

• last_turntrong vorpal_choicevà start_turnlà một số nguyên hoặc một giá trị Không có. Giá trị từ 0 đến 5 chỉ ra rằng kẻ thù đã loại bỏ thẻ đã rút cùng với vật phẩm được chỉ định bởi giá trị đó (xem danh sách các vật phẩm ở trên). Giá trị 6 chỉ ra rằng kẻ thù đã đặt thẻ vào ngục tối. Giá trị Không chỉ ra rằng bot đang chơi đầu tiên trong vòng này (không thể thực hiện được vorpal_choice). Trong vorpal_choicelast_turn có khả năng là 7, chỉ ra rằng họ đã vượt qua lượt đó. Tình huống duy nhất không phải là 7 là khi kẻ địch rút được lá bài cuối cùng.

• card là một con số đại diện cho sức mạnh của một trong những lá bài từ bộ bài như được liệt kê ở trên.

Bây giờ, các đối số resultphức tạp hơn một chút:

• botcho biết bot đã vào ngục tối. 0 chỉ ra vào ngục tối và 1 chỉ ra rằng kẻ thù đã vào ngục tối.

• resultchỉ ra sự thành công của chuyến đi. Sai cho thấy bot chơi game đã thành công, trong khi True cho thấy họ thất bại.

• dungeonlà một danh sách các thẻ / ints đại diện cho các thẻ trong ngục tối. Hầm ngục được sắp xếp theo thứ tự được đặt; thẻ đầu tiên được đặt trong ngục tối là đầu tiên trong danh sách, và thẻ cuối cùng được đặt ở cuối. Bạn sẽ không nhận được bất kỳ thông tin nào về thẻ bị loại bỏ; họ là bí mật từ các bot khác.

• vorpedlà một số nguyên đại diện cho vorpal_choicethực hiện bởi bot chơi game. Nếu bot==0, bạn đã biết điều này, nhưng nếu bot==1, đây có thể là thông tin hữu ích.

Tôi sẽ thành thật, tôi hoàn toàn không nhớ tại sao tôi lại giành được kết quả Sai, nhưng tôi nghĩ đó là một ý tưởng tốt vào thời điểm đó.

Giá trị trả về

• start_turn: Trả về 1 để rút thẻ hoặc 0 để vượt qua.

• play: Trả về 0 đến 5 để loại bỏ vật phẩm tương ứng và thẻ đã rút hoặc 6 để đặt thẻ vào ngục tối (phù hợp với đầu vào last_turn, ngoại trừ việc vượt qua, được thực hiện trong start_turn).

• vorpal_choice: Trả về số lượng thẻ bạn muốn loại bỏ bằng dao găm Vorpal (1 để loại bỏ 1s, 5 để loại bỏ 5s). Chọn một thẻ không tồn tại sẽ giết chết bạn (8 là bất hợp pháp, 10 là bất hợp pháp, 0 là bất hợp pháp).

• result: Bạn có thể trả lại bất cứ điều gì, vì đây là chức năng thông báo để cập nhật dữ liệu của bot.

Bạn có thể kiểm tra bộ điều khiển ở đây

Làm rõ thêm hoặc chỉ lặp lại một số chi tiết nhỏ mà bạn có thể đã bỏ qua và có thể muốn biết nhanh chóng:

Bots chơi 400 trò chơi với nhau bot.

Không có biến lớp

Không nhắm mục tiêu các bot cụ thể khác

Không chống đỡ các bot khác

Không có những thứ phản ánh như sửa đổi mô-đun ngẫu nhiên hoặc các bot khác.

Tối đa 6 bot (mỗi người), trừ khi rõ ràng là tất cả các bot đều có giá trị bao gồm trong KOTH (nhưng vẫn có thể không tạo ra một loạt các bot vui lòng)

Không có thời gian kết thúc cụ thể cho KOTH này, ngoại trừ kết thúc tiền thưởng cho những gì có giá trị. Chỉ cần cố gắng để giành chiến thắng mỗi lần.

Kết quả cho đến nay (xin lỗi vì khá lười biếng với những người này: 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 "đánh cắp" tiền thưởng. không thực sự, bởi vì nó kiếm được nó. Làm tốt lắm, Sleafar!

Chén

Một trình thu thập dungeon cũ và có kinh nghiệm. Anh ta biết rằng hầu hết những người khác hy vọng, rằng chén thánh cứu họ, do đó anh ta chắc chắn rằng nó biến mất.

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

Quỷ dữ

Nỗ lực đầu tiên của tôi tại một thử thách 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()

Về cơ bản, chúng ta thoát khỏi hiệp ước và con dao găm vorpal, đợi con quỷ chui vào boong tàu và vượt qua. Mỗi vòng đối thủ có thể đã rút quỷ, nó có% khả năng lá bài cuối cùng mà đối thủ rút ra là một con quỷ chỉ cho rằng họ đã chơi quỷ.

Hãy cho tôi biết nếu có bất cứ điều gì tôi đã làm sai; Tôi đã không nhắn tin với con trăn trong một thời gian, đây là KOTH đầu tiên của tôi và bây giờ là 2 giờ sáng, vì vậy chắc chắn sẽ có một cái gì đó.

CHỈNH SỬA:

Lấy ra sự ngẫu nhiên hóa ra lại giúp nó rất nhiều. Với sự ngẫu nhiên trong đó là rất ngu ngốc. Ngoài ra, như đã nói trong các bình luận dưới đây, nó cố gắng triệu hồi quỷ hoặc rồng.

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 cố gắng đoán xem hầm ngục có gây chết người hay không. Nếu anh ta nghĩ rằng nó là, anh ta vượt qua. Ngoài ra, tôi đã cố gắng làm cho anh ta thoát khỏi các mặt hàng một cách thông minh. Anh ta thường điều chỉnh ngưỡng PASS của mình tùy thuộc vào việc anh ta chết trong ngục tối hay đối thủ còn sống, nhưng cuối cùng anh ta trở nên ngu ngốc hơn nên tôi đã thoát khỏi nó.

Anh ta vẫn không đánh bại GrailThief trên máy của tôi, nhưng ít nhất là đến gần hơn.

SlapAndFlap

Lần đầu tiên ở KOTH, vì vậy hãy tát tôi thật nhiều vì những sai lầm.

Người đơn giản này luôn cố gắng loại bỏ tất cả các vật phẩm tốt với những con quái vật có sức mạnh thấp, trong khi vẫn giữ những thứ mạnh mẽ và sau đó chỉ buộc đối thủ chơi.
Nó đánh bại RunAway và DumDum ít nhất: D
Bot khác của tôi trong câu trả lời đã bị xóa trong một thời gian, tôi cần sửa nó bằng tommorow

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

Các bot ngẫu nhiên bắt buộc. Một cách thích hợp, anh ta thua khó với các bot mặc định, điều này là tốt, bởi vì điều đó có nghĩa là trò chơi có ít nhất một số chiến lược.

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

rõ ràng không bao giờ lùi bước cách duy nhất bạn có thể (nhất quán; RunAway đôi khi thua nhưng phần lớn thời gian này vẫn thua bot này là nếu bạn không xóa bất kỳ mục nào hoặc là một kẻ hèn nhát. nghĩ về bot này như một lời nhắc nhở để loại bỏ các mục, nếu không điều này thậm chí có thể giành chiến thắng.

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!

Và

Chạy trốn

Khá nhiều họ gỡ bỏ áo giáp và sau đó bỏ chạy một thời gian trước khi kết thúc. như daredevildumdum, nó không nhớ bất cứ thứ gì, ngoại trừ số lượng thẻ trong bộ bài (mà tbh sẽ không được nhớ trong trò chơi thực tế (bạn chỉ cần kiểm tra)) và liệu có ai gỡ bỏ bộ giáp (hầu hết giống như trước đây không ).

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

Ngoài ra bởi vì tôi là người thách thức đặc biệt, những bot này không được tính vào số bot của tôi, bởi vì chúng là những bot bị câm

BoredPlayer

Trái ngược với RandomMandom, BoringPlayer luôn đưa ra những lựa chọn giống nhau. Vấn đề là có vẻ như nó quá thành công đối với một bot đơn giản như vậy. Nó đạt 3800+ trong bài kiểm tra địa phương của tôi.

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