Camel Up Cup: un tournoi de jeux de société IA

Camel Up Cup 2k18

Dans ce défi, nous jouerons au jeu de société semi-populaire Camel Up.

Camel Up! est un jeu de société où les joueurs parient sur des chameaux pour gagner des tours, gagner ou perdre le jeu, poser des pièges pour influencer le mouvement ou déplacer un chameau. Chacune de ces décisions vous récompense avec la possibilité d'obtenir de l'argent, ce qui détermine le gagnant. Les joueurs doivent utiliser la probabilité, les considérations de l'état du jeu et la location de l'adversaire pour prendre leurs décisions. Voici une courte vidéo montrant aux joueurs comment jouer .

Comment jouer

Voici une idée approximative de la façon de jouer. Regarder l'une des vidéos peut être plus utile car elles ont des visuels :)

A votre tour, vous avez 4 options.

1. Déplacez un chameau. Cela choisit un chameau parmi ceux qui n'ont pas bougé et le déplace entre 1 à 3 espaces. Vous obtenez 1 pièce. Les tours se terminent lorsque les cinq chameaux se sont déplacés, ils peuvent alors tous se déplacer
2. Placez un piège. Cela va sur le plateau jusqu'à la fin du tour. Vous choisissez le piège + 1 / -1. Si un chameau ou une pile de chameaux y atterrit, ils se déplacent de + 1 / -1 et vous obtenez une pièce. Vous ne pouvez pas placer de piège sur la case 0. Vous pouvez placer un piège là où se trouvent des chameaux, bien que cela n'affecte que les chameaux qui s'y posent ensuite.
3. Pari gagnant rond. Vous prenez un pari sur un vainqueur du tour. Ils gagnent vous obtenez 5/3/2/1 selon que vous étiez le 1er / 2e / 3e à parier sur ce chameau.
4. Gagnant / perdant du jeu. Vous pariez sur qui sera le premier ou le dernier à la fin de la partie. vous obtenez 8/5/3/1/1 (je pense) basé sur si vous étiez 1er / 2ème / 3ème / etc à parier sur ce chameau

Remarques:

• Il y a 5 chameaux. Ils commencent sur une position aléatoire de 0-2.
• Lorsqu'un chameau est déplacé (voir ci-dessus pour ce qui déclenche cela), il se déplace de 1 à 3 cases. S'ils devaient être placés sur une case avec un autre chameau, ils sont placés "au-dessus" de l'autre, créant une pile de chameaux. Si un chameau doit se déplacer, il déplace tous les chameaux au-dessus de lui sur la pile de chameaux. Le chameau en haut de la pile est considéré en tête
• Si vous atterrissez sur un piège +1 (voir ci-dessus pour ce qui déclenche cela), vous avancez d'une case plus loin. Les règles d'empilement standard s'appliquent.
• Cependant, si vous frappez un piège -1, vous reculez d'un carré. Vous passez sous la pile de chameaux qui se trouvent sur cette case, le cas échéant.
• Le jeu se termine lorsqu'un chameau atteint la case 16. Cela déclenche immédiatement les déclencheurs de fin de partie et de fin de partie.
• Les paris gagnants / perdants ne peuvent être effectués qu'une seule fois par chameau. C'est-à-dire que vous ne pouvez pas parier sur un chameau pour gagner et perdre le jeu

Défi

Dans ce défi, vous écrirez un programme Python 3 pour jouer à quatre joueurs, le gagnant remporte tout le jeu de gloire de Camel Up

Votre programme recevra le gamestate, qui contient:

• camel_track : avec les emplacements des chameaux
• trap_track : avec l'emplacement des pièges (entrée du formulaire [trap_type (-1,1), player])
• player_has_placed_trap : un tableau vous indiquant si les joueurs ont placé un piège ce tour
• round_bets : un tableau des paris placés ce tour. De la forme [chameau, joueur]
• game_winner_bets / game_loser_bets : tableaux des paris que les joueurs ont faits pour que les chameaux gagnent ou perdent la partie. Vous ne pourrez voir que la valeur des joueurs qui ont fait les paris, pas sur qui ils parient. Vous pouvez savoir sur qui vous pariez. #de la forme [chameau, joueur]
• player_game_bets : une autre représentation des game_winner_bets / game_loser_bets. Encore une fois, ne regardez que les paris que votre bot a faits.
• player_money_values : un tableau montrant le montant d'argent dont dispose chaque joueur.
• camel_yet_to_move : un tableau indiquant si un chameau a bougé ce tour.

En plus du gamestate, vous obtenez également:

• joueur : un entier vous indiquant le numéro de joueur que vous êtes (0-3).

La syntaxe de ce que les joueurs doivent retourner est:

• [0]: Déplacer le chameau
  
• [1, trap_type, trap_location]: placer le piège
  
• [2, projection_round_winner]: Faire un pari gagnant
  
• [3, projection_game_winner]: Faire un pari gagnant
  
• [4, projection_game_loser]: Faire une mise perdante
  

Cela devrait être enveloppé dans une méthode de déplacement (joueur, gamestate)

Par exemple, voici un joueur qui fera un pari gagnant rond s'il est à la dernière place. S'ils ne le sont pas, ils placeront un piège sur une case aléatoire.

class Player1(PlayerInterface):
     def move(player,g):
         if min(g.player_money_values) == g.player_money_values[player]:
            return [2,random.randint(0,len(g.camels)-1)]
        return [1,math.floor(2*random.random())*2-1,random.randint(1,10)]

Le jeu a été choisi pour plusieurs raisons: il dispose d'un ensemble d'options relativement restreint (environ 20 choix par tour, facilement réduits à environ 3-4), les jeux sont courts et il y a un élément de chance (le rend donc même les "mauvais" robots peuvent gagner).

Gameplay

Le coureur du tournoi peut être trouvé ici: camel-up-cup . Exécuter camelup.pypour exécuter un tournoi ou la fonction PlayGame pour exécuter des jeux. Je garderai ce référentiel à jour avec de nouvelles soumissions. Des exemples de programmes se trouvent dans players.py.

Un tournoi se compose de 100 parties pour 10 joueurs (arrondi, donc 14 joueurs signifie 200 parties). Chaque jeu sera composé de quatre joueurs choisis au hasard parmi le groupe de joueurs pour combler les quatre postes. Les joueurs ne pourront pas participer deux fois au jeu.

Notation

Le gagnant de chaque partie est le joueur avec le plus d'argent à la fin de la partie. En cas d'égalité à la fin d'une partie, tous les joueurs avec le montant maximum d'argent reçoivent un point. Le joueur avec le plus de points à la fin du tournoi gagne. Je publierai des scores pendant que je dirige les jeux.

Les joueurs soumis seront ajoutés au pool. J'ai ajouté trois robots vraiment stupides et un que j'ai créé pour commencer.

Avertissements

Ne modifiez pas les entrées. N'essayez pas d'affecter l'exécution de tout autre programme, sauf en coopérant ou en faisant défaut. Ne faites pas de soumission sacrificielle qui tente de reconnaître une autre soumission et de bénéficier à cet adversaire à ses propres frais. Les failles standard sont interdites.

Limitez le temps pris par votre bot à environ 10 secondes par tour.

Les soumissions ne peuvent pas reproduire des soumissions antérieures.

Veuillez ne pas voir les paris game_winner ou game_loser des autres joueurs. C'est assez facile à faire mais toujours à tricher.

Si vous avez des questions, n'hésitez pas à les poser.

Gagnant

Le concours restera ouvert indéfiniment, à mesure que de nouvelles soumissions seront publiées. Cependant, je déclarerai un gagnant (accepter une réponse) sur la base des résultats un mois après la publication de cette question (20 juillet).

Résultats

Player0: 12
Player1: 0
Player2: 1
Sir_Humpfree_Bogart: 87

Sir_Humpfree_Bogart.py

Ceci est un bot que j'ai fait pour le tournoi Camel Up Cup .

Tout d'abord, ils examinent toutes les configurations possibles que les chameaux pourraient finir à la fin du tour. Ensuite, ils déterminent la valeur attendue de parier sur un chameau gagnant le tour en utilisant

EV_roundwin = (chance_1st)*(payout) + (chance_2nd)*(payout) - (chance_3rd_or_worse)*(cost)

Ensuite, ils déplacent des chameaux au hasard jusqu'à ce qu'un chameau gagne. Après avoir fait cela plusieurs milliers de fois, vous pouvez estimer les chances de gagner et de perdre de chaque chameau. Encore une fois, nous obtenons la valeur attendue de ceux-ci en utilisant

EV_gamewin = (chance_1st)*(payout) - (chance_2nd_or_worse)*(cost)

Les seules autres options sont de déplacer un chameau (qui rapporte toujours une pièce, donc sa valeur attendue est une) et de placer un piège. Les deux équipes ont estimé que placer un piège était une option suffisamment faible pour l'ignorer complètement. Avec ces informations, les bots ont choisi l'option avec la valeur attendue la plus élevée.

Étant donné que le tournoi a vu une deuxième place terminer de la même manière qu'une dernière place, il est logique que vous soyez derrière pour prendre des chances d'entrer en première place. SBH a utilisé distance_from_first_place et nearness_to_end pour déterminer le niveau de risque du bot, où si vous êtes loin du premier et proche de la fin, le risque serait élevé et si vous êtes en premier ou loin de la fin du jeu, le risque serait faible . Avec un faible risque, le bot déciderait d'une action avec une option à haute valeur attendue et un risque élevé donnant l'option avec un résultat élevé. L'équation exacte était

Functional_EV = EV + (upshot-EV) * riskiness

où le résultat est le paiement le plus élevé que vous pouvez obtenir d'une décision et le risque varie de 0 à 1.

players.py

Ce sont des robots incroyablement stupides pour lancer le tournoi. Ils n'ont presque pas de logique mais agissent comme des cadres que les gens peuvent utiliser

import random
import math
from playerinterface import PlayerInterface

class Player0(PlayerInterface):
    def move(player,g):
        #This dumb player always moves a camel
        return [0]

class Player1(PlayerInterface):
    def move(player,g):
        #This player is less dumb. If they have the least amount of money they'll make a round winner bet
        #If they aren't in last then they'll place a trap on a random square. Still p dumb though
        if min(g.player_money_values) == g.player_money_values[player]:
            return [2,random.randint(0,len(g.camels)-1)]
        return [1,math.floor(2*random.random())*2-1,random.randint(1,10)]

class Player2(PlayerInterface):
    def move(player,g):
        #This dumb player always makes a round winner bet
        return [2,random.randint(0,len(g.camels)-1)]