Camel Up Cup: un torneo di giochi da tavolo AI

Camel Up Cup 2k18

In questa sfida, giocheremo al semi-popolare gioco da tavolo Camel Up.

Camel Up! è un gioco da tavolo in cui i giocatori scommettono sui cammelli per vincere round, vincere la partita o perdere la partita, impostare trappole per influenzare il movimento o spostare un cammello. Ognuna di queste decisioni ti premia con la possibilità di ottenere dei soldi, che è ciò che determina il vincitore. I giocatori dovrebbero usare la probabilità, le considerazioni sullo stato del gioco e l'affitto degli avversari per prendere le loro decisioni. Ecco un breve video che mostra ai giocatori come si gioca .

Come giocare

Ecco un'idea approssimativa di come giocare. Guardare uno dei video può essere più utile perché hanno elementi visivi :)

Al tuo turno hai 4 opzioni.

1. Sposta un cammello. Questo prende un cammello da coloro che non si sono mossi e lo sposta tra 1-3 spazi. Ottieni 1 moneta. I round terminano quando tutti e cinque i cammelli si sono mossi, quindi possono muoversi tutti
2. Metti una trappola. Questo va sul tabellone fino alla fine del round. Scegli tra + 1 / -1 trap. Se un cammello o una pila di cammelli atterra su di essa, si muovono + 1 / -1 e ottieni una moneta. Non puoi posizionare una trappola sul quadrato 0. Puoi posizionare una trappola dove si trovano i cammelli, anche se influenzerà solo i cammelli che vi atterrano dopo.
3. Scommessa sul vincitore del round. Fai una scommessa su un vincitore del round. Vincono ricevi 5/5/2/1 a seconda che tu fossi il 1 ° / 2 ° / 3 ° a scommettere su quel cammello.
4. Vincitore / perdente del gioco. Fai una scommessa su chi sarà il primo o l'ultimo alla fine del gioco. ottieni 8/5/3/1/1 (credo) in base al fatto che fossi il 1 ° / 2 ° / 3 ° / ecc. a scommettere su quel cammello

Appunti:

• Ci sono 5 cammelli. Iniziano in una posizione casuale da 0-2.
• Quando un cammello viene spostato (vedi sopra per ciò che lo scatena) si muovono di 1-3 quadrati. Se fossero posizionati su un quadrato con un altro cammello, sarebbero messi "in cima" all'altro, creando una pila di cammelli. Se un cammello deve muoversi, sposta tutti i cammelli sopra di esso sulla pila di cammelli. Il cammello nella parte superiore della pila è considerato in testa
• Se atterri su una trappola +1 (vedi sopra per ciò che la innesca) ti sposti di un quadrato in avanti. Si applicano le regole di impilamento standard.
• Tuttavia, se colpisci una trappola -1, ti sposti di un quadrato all'indietro. Vai sotto la pila di cammelli che si trovano su quel quadrato, se presente.
• Il gioco termina quando un cammello colpisce il quadrato 16. Questo provoca immediatamente la fine del round e si innesca
• Le scommesse sul vincitore del gioco / perdente possono essere fatte solo una volta per cammello. Cioè non puoi scommettere su un cammello per vincere e perdere la partita

Sfida

In questa sfida, scriverai un programma Python 3 per giocare a quattro giocatori, il vincitore prende tutto il gioco della gloria di Camel Up

Il tuo programma riceverà il gamestate, che contiene:

• camel_track : con le posizioni dei cammelli
• trap_track : con la posizione delle trappole (voce del modulo [trap_type (-1,1), player])
• player_has_placed_trap : un array che ti dice se i giocatori hanno piazzato una trappola in questo round
• round_bets : una matrice delle scommesse piazzate in questo round. Della forma [cammello, giocatore]
• game_winner_bets / game_loser_bets : matrici delle scommesse fatte dai giocatori per i cammelli per vincere o perdere la partita. Sarai solo in grado di vedere il valore dei giocatori che hanno fatto le scommesse, non su chi scommettono. Puoi sapere su chi scommetti. #oforma [cammello, giocatore]
• player_game_bets : un'altra rappresentazione di game_winner_bets / game_loser_bets. Ancora una volta, guarda solo le scommesse fatte dal tuo bot.
• player_money_values : un array che mostra la quantità di denaro che ogni giocatore ha.
• camel_yet_to_move : un array che mostra se un cammello si è spostato in questo round.

Oltre al gamestato ottieni anche:

• giocatore : un numero intero che ti dice quale numero di giocatore sei (0-3).

La sintassi di ciò che i giocatori dovrebbero restituire è:

• [0]: sposta il cammello
  
• [1, trap_type, trap_location]: Posiziona Trap
  
• [2, projected_round_winner]: scommetti sul vincitore del round
  
• [3, projected_game_winner]: scommetti sul vincitore del gioco
  
• [4, projected_game_loser]: scommetti perdente gioco
  

Questo dovrebbe essere racchiuso in un metodo di mossa (giocatore, giocatore)

Ad esempio, ecco un giocatore che farà una scommessa sul vincitore del round se si trova all'ultimo posto. Se non lo sono, posizioneranno una trappola su un quadrato casuale.

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

Il gioco è stato scelto per diversi motivi: ha un pool relativamente piccolo di opzioni tra cui scegliere (circa 20 scelte per turno, facilmente restringibili a circa 3-4), i giochi sono brevi e c'è un elemento di fortuna (lo rende così anche i "cattivi" robot possono vincere).

gameplay

Il corridore del torneo può essere trovato qui: cammello-up-cup . Esegui camelup.pyper eseguire un torneo o la funzione PlayGame per eseguire i giochi. Terrò quel repository aggiornato con nuovi invii. Programmi di esempio sono disponibili in players.py.

Un torneo è composto da 100 partite per 10 giocatori (arrotondato per eccesso, quindi 14 giocatori significano 200 partite). Ogni partita sarà composta da quattro giocatori casuali selezionati dal pool di giocatori per riempire le quattro posizioni. I giocatori non potranno essere in gioco due volte.

punteggio

Il vincitore di ogni partita è il giocatore con più soldi alla fine della partita. In caso di pareggio alla fine di una partita viene assegnato un punto a tutti i giocatori con l'importo massimo in denaro. Vince il giocatore con il maggior numero di punti alla fine del torneo. Pubblicherò i punteggi mentre corro i giochi.

I giocatori inviati verranno aggiunti al pool. Ho aggiunto tre robot davvero stupidi e uno che ho fatto iniziare.

Avvertenze

Non modificare gli ingressi. Non tentare di influire sull'esecuzione di altri programmi, se non attraverso la cooperazione o il difetto. Non fare una sottomissione sacrificale che tenti di riconoscere un'altra sottomissione e avvantaggiare quell'avversario a proprie spese. Le scappatoie standard sono vietate.

Limita il tempo impiegato dal tuo bot a ~ 10s per turno.

Gli invii non possono duplicare gli invii precedenti.

Non visualizzare le scommesse game_winner o game_loser da altri giocatori. È abbastanza facile da fare ma ancora barare.

Se avete domande non esitate a chiedere.

vincente

Il concorso rimarrà aperto a tempo indeterminato, poiché verranno inviati nuovi invii. Tuttavia, dichiarerò un vincitore (accetto una risposta) in base ai risultati un mese dopo la pubblicazione della domanda (20 luglio).

risultati

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

Sir_Humpfree_Bogart.py

Questo è un bot che ho realizzato per il torneo Camel Up Cup .

Innanzitutto, esaminano tutte le possibili configurazioni che i cammelli potrebbero finire alla fine del round. Quindi determinano il valore atteso delle scommesse su un cammello che vince il round usando

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

Quindi muovono i cammelli in modo casuale fino a quando un cammello vince. Dopo averlo fatto alcune migliaia di volte, puoi stimare la probabilità che ogni cammello vinca e perda. Ancora una volta, otteniamo il valore atteso di questi usando

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

Le uniche altre opzioni sono spostare un cammello (che produce sempre una moneta, quindi il suo valore atteso è uno) e posizionare una trappola. Entrambe le squadre hanno ritenuto che piazzare una trappola fosse un'opzione abbastanza debole da ignorarla del tutto. Con queste informazioni i robot hanno scelto l'opzione con il valore atteso più alto.

Dal momento che il torneo ha visto un secondo posto finire lo stesso di un ultimo posto finale, ha senso se sei dietro per correre il rischio di arrivare al primo posto. SBH ha usato distance_from_first_place e nearness_to_end per determinare quanto rischioso dovrebbe essere il bot, dove se si è lontani dal primo e vicini alla fine, la rischiosità sarebbe alta e se ci si trova al primo o lontano dalla fine del gioco la rischiosità sarebbe bassa . Con una bassa rischiosità, il bot decide su un'azione con un'opzione ad alto valore atteso e un'alta rischiosità che produce l'opzione con un risultato elevato. L'equazione esatta era

Functional_EV = EV + (upshot-EV) * riskiness

dove il risultato è il pagamento più alto che puoi ottenere da una decisione e la rischiosità varia da 0 a 1.

players.py

Questi sono robot incredibilmente stupidi per iniziare il torneo. Non hanno quasi alcuna logica ma fungono da framework per le persone da usare

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