- de crise e martírio

(essa é a legenda porque as legendas são legais)

Neste desafio do rei da colina em python (sim; você não precisa ir mais longe para saber que não pode enviar em java), você precisa criar um bot que jogue um jogo muito semelhante ao bem-vindo à masmorra

Regras do jogo

(note que este não é o jogo original)

Há um baralho, um conjunto de itens e algumas cartas de recompensa e cartas de morte. O HP base é 3. O baralho consiste em 13 cartas de monstro numeradas 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 9para indicar seus pontos fortes.

Item da lista

1. Pacto demoníaco: Derrote o demônio (monstro de força 7) e o monstro abaixo dele na pilha de masmorras. - (apenas derrota o demônio se o demônio foi o último na masmorra)

2. Poção de Vida: Quando você cair para 0 PV, derrote o monstro e retorne para 3 PV.

3. Santo Graal: Derrote monstros com força par (no jogo, eles são mortos-vivos). Se um monstro de número par ocorrer após o pacto demoníaco ter sido usado, ele age primeiro, e você não terá uma morte extra-pacto após esse monstro.

4. Adaga Vorpal: Escolha um monstro antes de entrar na masmorra; esse tipo de monstro é derrotado. Se o monstro-alvo ocorrer após o pacto demoníaco ter sido usado, ele age primeiro, e você não terá uma morte extra-pacto após esse monstro.

5. Escudo: Adicione 3 ao HP total antes de fazer spelunking. Isso não afeta o uso da poção de saúde, que sempre retornará a saúde para 3.

6. Armadura: Adicione 5 ao HP total antes de fazer spelunking. Isso não afeta o uso da poção de saúde, que sempre retornará a saúde para 3.

Os cartões de recompensa são usados ​​para rastrear quem foi bem-sucedido na masmorra. As cartas da morte rastreiam quem falhou na masmorra.

Fase de desenho

Antes do início da fase de desenho, todas as cartas de monstros são devolvidas ao baralho, ambos os jogadores são restaurados para 3 PV e todos os itens descartados são restaurados, de modo que exista um de cada.

O primeiro jogador decide se deve retirar uma carta do baralho, escondendo-a do outro jogador. Nesse caso, eles devem optar por colocá-lo no topo da pilha de masmorras ou descartá-lo junto com um item de sua escolha. Itens e cartões descartados ficarão indisponíveis para qualquer jogador até a próxima rodada.

Após o jogador um ter sua vez, o jogador dois faz o mesmo. Os jogadores decidem alternadamente se empatam e o que fazer com a carta comprada, até que alguém decida não comprar ou que um jogador pegue a última carta do baralho. Se um jogador decide não comprar ou comprar a última carta, a fase de compra termina e o outro jogador agora precisa entrar na masmorra e começar a spelunking.

Fase de Espeleologia

Se a adaga Vorpal não tiver sido descartada, o jogador de spelunking deve agora decidir em qual carta aplicá-la. Não há decisões ativas a serem tomadas para o restante desta fase.

O primeiro jogador pega a carta do topo; isto é, a última carta colocada na masmorra e ver o seu número de força. Se o pacto demoníaco estiver ativo no turno anterior, a carta retirada será descartada. Caso contrário, os itens do jogador serão verificados na ordem 'pacto demoníaco', 'santo graal', 'punhal vorpal'. O primeiro item não descartado, capaz de derrotar o cartão sorteado, será usado e o cartão descartado. Se o pacto demoníaco for usado, ele estará ativo para a próxima carta. O item usado não é descartado.

Se não houver um item aplicável disponível, a força da carta é subtraída da saúde do jogador. Se a saúde deles não for mais positiva, eles serão restaurados para 3 PV e a poção descartada, se disponível, caso contrário, o rastreamento da masmorra termina e eles recebem um cartão de morte.

Enquanto o jogador não é derrotado e há cartas restantes na masmorra, esse processo de retirada da carta do topo é repetido. Após derrotar com sucesso todas as cartas da masmorra, o rastejamento termina e o jogador spelunking recebe uma carta de recompensa.

Descrição completa do jogo

Um jogo consiste em uma série de rodadas, cada uma tendo uma fase de desenho e depois uma fase de spelunking. No final de cada rodada, um jogador coletará uma carta de morte ou uma recompensa; uma vez que um jogador acumule 5 dos dois tipos, o jogo termina. Se eles tiverem 5 cartas da morte, eles perderão o jogo. Se eles tiverem 5 cartões de recompensa, eles vencem. De qualquer maneira, o outro jogador recebe o resultado oposto. Se nenhum jogador tiver 5 cartas de um tipo, o jogo progride para a próxima rodada e o jogador que ficou em segundo na rodada anterior agora passa primeiro e vice-versa.

Detalhes KOTH

Cada bot jogará 400 jogos contra todos os outros bot de acordo com as regras descritas acima. Qual bot é o jogador um (e, portanto, o primeiro na primeira rodada) alterna cada jogo, e todo o estado é redefinido entre os jogos.

Aqui estão os itens novamente:

1. Pacto demoníaco: Derrote o demônio (monstro de força 7) e o monstro abaixo dele na pilha de masmorras. - (apenas derrota o demônio se o demônio foi o último na masmorra)

2. Poção de Vida: Quando você cair para 0 PV, derrote o monstro e retorne para 3 PV.

3. Santo Graal: Derrote monstros com força par (no jogo, eles são mortos-vivos). Se um monstro de número par ocorrer após o pacto demoníaco ter sido usado, ele age primeiro, e você não terá uma morte extra-pacto após esse monstro.

4. Adaga Vorpal: Escolha um monstro antes de entrar na masmorra; esse tipo de monstro é derrotado. Se o monstro-alvo ocorrer após o pacto demoníaco ter sido usado, ele age primeiro, e você não terá uma morte extra-pacto após esse monstro.

5. Escudo: Adicione 3 ao HP total antes de fazer spelunking. Isso não afeta o uso da poção de saúde, que sempre retornará a saúde para 3.

6. Armadura: Adicione 5 ao HP total antes de fazer spelunking. Isso não afeta o uso da poção de saúde, que sempre retornará a saúde para 3.

eo deck: 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 9.

Você deve implementar uma classe bot que não usa variáveis ​​de classe, derivadas da seguinte classe base:

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

Essa classe base mostra os métodos que sua classe precisa implementar e o número de argumentos usados ​​por cada um.

Descrições de Argumentos do Método

• last_turnin vorpal_choicee start_turné um número inteiro ou um valor Nenhum. Um valor de 0 a 5 indica que o inimigo descartou a carta comprada junto com o item indicado por esse valor (veja a lista de itens acima). Um valor de 6 indica que o inimigo colocou a carta na masmorra. Um valor Nenhum indica que o bot está jogando primeiro nesta rodada (não é possível para vorpal_choice). Em vorpal_choicelast_turn, é provável que seja 7, indicando que eles passaram nesse turno. A única circunstância em que não é 7 é quando o inimigo sacou a última carta.

• card é um número que representa a força de uma das cartas do baralho, conforme enumerado acima.

Agora, os argumentos para resultsão um pouco mais complexos:

• botindica o bot que entrou na masmorra. 0 indica entrar na masmorra e 1 indica que o inimigo entrou na masmorra.

• resultindica o sucesso da viagem. False indica que o bot de spelunking foi bem-sucedido, enquanto True indica que eles falharam.

• dungeoné uma lista de cartões / entradas representando os cartões que estavam na masmorra. A masmorra é encomendada por encomenda; a primeira carta colocada no calabouço é a primeira da lista e a última carta colocada no final. Você não receberá nenhuma informação sobre cartões descartados; eles são secretos do outro bot.

• vorpedé um número inteiro que representa o vorpal_choicefeito pelo bot de spelunking. Se bot==0você já sabe disso, mas se bot==1pode ser uma informação útil.

Serei sincero, não me lembro inteiramente por que fiz o resultado da vitória Falso, mas acho que foi uma boa ideia na época.

Retornar valores

• start_turn: Retorne 1 para comprar um cartão ou 0 para passar.

• play: Retorne de 0 a 5 para descartar o item correspondente e a carta sacada, ou 6 para colocar a carta na masmorra (consistente com a entrada da última volta, exceto a passagem, que é feita durante a partida inicial).

• vorpal_choice: Devolva o número da carta que você deseja eliminar com a adaga Vorpal (1 para eliminar 1s, 5 para eliminar 5s). Escolher um cartão inexistente mata você (8 é ilegal, 10 é ilegal, 0 é ilegal).

• result: Você pode retornar qualquer coisa, porque esta é uma função de informação para atualizar os dados do bot.

Você pode conferir o controlador aqui

Esclarecimentos adicionais ou apenas repetindo alguns pequenos detalhes que você pode ter ignorado e talvez queira saber rapidamente:

Bots jogam 400 jogos entre si, bot.

Nenhuma variável de classe

Sem segmentação específica de outros bots

Não há como apoiar outros bots

Não há reflexões, como modificar o módulo aleatório ou outros bots.

6 bots no máximo (por pessoa), a menos que seja óbvio que todos os bots valem a pena incluir no KOTH (mas ainda assim provavelmente não fazem muitos bots, por favor)

Não existe um horário final específico para este KOTH, exceto o final da recompensa pelo que vale a pena. Apenas tente ganhar a cada vez.

Resultados até agora (desculpe por ser um tanto preguiçoso com esses caras: 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

O ladrão "rouba" a recompensa. não de verdade, porque valeu a pena. Bom trabalho, Sleafar!

GrailThief

Um rastreador de masmorra antigo e experiente. Ele sabe que a maioria dos outros espera que o Santo Graal os salve; portanto, ele garante que ele desapareça.

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

Minha primeira tentativa de um desafio 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()

Essencialmente, nos livramos do pacto e da adaga vorpal, esperamos o demônio entrar no convés e passamos. A cada rodada que o oponente possa ter atraído o demônio, ela tem a% de chance de que a última carta que o oponente tenha sacado seja um demônio, para apenas assumir que ele já jogou o demônio.

Deixe-me saber se há algo que eu fiz de errado; Eu não mexo com python há algum tempo, este é o meu primeiro KOTH, e são 2 da manhã, então é provável que haja algo.

EDITAR% S:

Tirar a aleatoriedade acaba ajudando muito. Com a aleatoriedade, é muito idiota. Além disso, como dito nos comentários abaixo, ele tenta convocar o demônio ou dragão.

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 tenta adivinhar se a masmorra é ou não letal. Se ele pensa que é, ele passa. Fora isso, tentei fazê-lo se livrar dos itens de maneira inteligente. Ele costumava ajustar seu limiar de PASS, dependendo se ele morria na masmorra ou se o oponente vivia, mas acabou ficando muito mais tonto, então eu me livrei disso.

Ele ainda não vence o GrailThief na minha máquina, mas pelo menos se aproxima.

SlapAndFlap

Primeira vez em KOTH, então me dê um tapa forte por erros.

Este simplório está sempre tentando remover todos os itens bons com monstros de baixa força, enquanto mantém itens poderosos e apenas força o oponente a jogar.
Ele vence o RunAway e o DumDum pelo menos: D
Meu outro bot na resposta excluída por algum tempo, eu preciso corrigi-lo amanhã.

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

O bot aleatório obrigatório. Apropriadamente, ele perde muito com os bots padrão, o que é bom, porque significa que o jogo tem pelo menos alguma estratégia.

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

meio claro. nunca recua. a única maneira que você pode (consistentemente; o RunAway perde às vezes, mas ainda supera isso na maioria das vezes) perder para esse bot é se você não remover nenhum item ou for um super covarde. pense neste bot como um lembrete para remover itens, caso contrário, mesmo isso poderá ganhar.

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!

E

Fugir

praticamente eles removem a armadura e fogem um pouco antes do fim. como daredevildumdum, ele não se lembra de nada, exceto pelo número de cartas no baralho (que não seriam lembradas no jogo real (você apenas verificaria)) e se alguém removeu a armadura (principalmente a mesma de antes) )

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

Também porque eu sou um pôster de desafio especial, esses bots não contam para a minha contagem de bots, porque são bots de exemplo que são burros

BoringPlayer

O oposto de RandomMandom, o BoringPlayer sempre faz as mesmas escolhas. O problema é que parece que ele é muito bem-sucedido para um bot tão simples. Ele marca 3800+ no meu teste local.

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