Camel Up Cup: Ein KI-Brettspielturnier

Camel Up Cup 2k18

In dieser Herausforderung spielen wir das beliebte Brettspiel Camel Up.

Kamel hoch! ist ein Brettspiel, bei dem Spieler auf Kamele setzen, um Runden zu gewinnen, das Spiel zu gewinnen oder das Spiel zu verlieren, Fallen zu stellen, um die Bewegung zu beeinflussen oder ein Kamel zu bewegen. Jede dieser Entscheidungen belohnt Sie mit der Chance, etwas Geld zu bekommen, was den Gewinner bestimmt. Spieler sollten Wahrscheinlichkeit, Überlegungen zum Spielstatus und das Mietverhältnis des Gegners verwenden, um ihre Entscheidungen zu treffen. Hier ist ein kurzes Video, das den Spielern zeigt, wie man spielt .

Spielanleitung

Hier ist eine grobe Vorstellung davon, wie man spielt. Das Anschauen eines der Videos kann hilfreicher sein, da sie visuell sind :)

In deinem Zug hast du 4 Möglichkeiten.

1. Bewege ein Kamel. Dies nimmt ein Kamel von denen, die sich nicht bewegt haben, und bewegt es zwischen 1-3 Feldern. Sie erhalten 1 Münze. Runden enden, wenn sich alle fünf Kamele bewegt haben, sie können sich dann alle bewegen
2. Stelle eine Falle. Dies geht auf dem Brett bis zum Ende der Runde. Sie wählen + 1 / -1 Falle. Wenn ein Kamel oder ein Kamelstapel darauf landet, bewegen sie sich + 1 / -1 und Sie erhalten eine Münze. Sie können keine Falle auf Feld 0 platzieren. Sie können eine Falle dort platzieren, wo sich Kamele befinden, obwohl dies nur Kamele betrifft, die danach darauf landen.
3. Runde Gewinner Wette. Sie setzen auf einen Rundengewinner. Sie gewinnen, Sie erhalten 5/3/2/1, je nachdem, ob Sie der 1. / 2. / 3. waren, der auf dieses Kamel gewettet hat.
4. Spielgewinner / -verlierer. Sie setzen darauf, wer am Ende des Spiels an erster oder letzter Stelle steht. Sie erhalten 8/5/3/1/1 (glaube ich) basierend darauf, ob Sie 1./2 ./3. / etc waren, um auf dieses Kamel zu wetten

Anmerkungen:

• Es gibt 5 Kamele. Sie beginnen zufällig an einer Position von 0-2.
• Wenn ein Kamel bewegt wird (siehe oben, was dies auslöst), bewegen sie 1-3 Felder. Wenn sie mit einem anderen Kamel auf ein Feld gelegt würden, würden sie "übereinander" gelegt, wodurch ein Kamelstapel entsteht. Wenn sich ein Kamel bewegen soll, bewegt es alle Kamele darüber auf dem Kamelstapel. Das Kamel oben auf dem Stapel wird an der Spitze betrachtet
• Wenn Sie auf einer + 1-Falle landen (siehe oben, was dies auslöst), bewegen Sie sich ein Feld weiter vorwärts. Es gelten die Standard-Stapelregeln.
• Wenn Sie jedoch eine -1-Falle treffen, bewegen Sie sich ein Feld zurück. Sie gehen unter den Stapel von Kamelen, die sich auf diesem Feld befinden, falls vorhanden.
• Das Spiel endet, wenn ein Kamel auf Feld 16 trifft. Dies ruft sofort das Auslösen des runden Endes und des Spielendes hervor
• Wetten für Gewinner / Verlierer von Spielen können nur einmal pro Kamel abgeschlossen werden. Das heißt, Sie können nicht auf ein Kamel wetten, um das Spiel zu gewinnen und zu verlieren

Herausforderung

In dieser Herausforderung schreibst du ein Python 3-Programm, um einen Vier-Spieler-Spieler zu spielen. Der Gewinner erhält alle Ruhm-Spiele von Camel Up

Ihr Programm erhält den Gamestate, der Folgendes enthält:

• camel_track : mit den Positionen der Kamele
• trap_track : mit dem Ort der Fallen (Eingabe des Formulars [trap_type (-1,1), Spieler])
• player_has_placed_trap : Ein Array, das Ihnen sagt, ob Spieler in dieser Runde eine Falle gestellt haben
• round_bets : Eine Reihe der Wetten, die in dieser Runde platziert wurden. Von der Form [Kamel, Spieler]
• game_winner_bets / game_loser_bets : Anordnungen der Wetten, die Spieler gemacht haben, damit Kamele das Spiel gewinnen oder verlieren. Sie können nur den Wert der Spieler sehen, die die Wetten abgeschlossen haben, nicht auf die, auf die sie gesetzt haben. Sie können wissen, auf wen Sie setzen. # der Form [Kamel, Spieler]
• player_game_bets : Eine weitere Darstellung der game_winner_bets / game_loser_bets. Schauen Sie sich auch hier nur die Wetten an, die Ihr Bot gemacht hat.
• player_money_values : Ein Array, das den Geldbetrag jedes Spielers anzeigt .
• camel_yet_to_move : Ein Array, das anzeigt , ob sich ein Kamel in dieser Runde bewegt hat.

Zusätzlich zum Spielstatus erhalten Sie außerdem:

• Spieler : Eine Ganzzahl, die angibt, welche Spielernummer Sie sind (0-3).

Die Syntax für das, was Spieler zurückgeben sollten, lautet:

• [0]: Bewege das Kamel
  
• [1, trap_type, trap_location]: Platziere die Falle
  
• [2, projizierter_Rundensieger]: Machen Sie eine Runde-Gewinner-Wette
  
• [3, projizierter_Spielgewinner]: Wette auf den Spielgewinner
  
• [4, projiziert_spiel_loser]: Spielverlierer-Wette abschließen
  

Dies sollte in eine Zugmethode (Spieler, Spielstaat) eingeschlossen werden

Hier ist zum Beispiel ein Spieler, der eine Runde gewinnt, wenn er auf dem letzten Platz liegt. Wenn dies nicht der Fall ist, platzieren sie eine Falle auf einem zufälligen Quadrat.

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

Das Spiel wurde aus mehreren Gründen ausgewählt: Es hat einen relativ kleinen Pool an Optionen zur Auswahl (ungefähr 20 Auswahlmöglichkeiten pro Runde, leicht eingegrenzt auf normalerweise 3-4), die Spiele sind kurz und es gibt ein Glückselement (macht es so können auch die "schlechten" Bots gewinnen).

Spielweise

Den Turnierläufer finden Sie hier: Camel-Up-Cup . Ausführen camelup.py, um ein Turnier auszuführen, oder die Funktion PlayGame, um Spiele auszuführen. Ich werde das Repository mit neuen Einsendungen auf dem neuesten Stand halten. Beispielprogramme finden Sie in players.py.

Ein Turnier besteht aus 100 Spielen pro 10 Spieler (aufgerundet, dh 14 Spieler bedeuten 200 Spiele). Jedes Spiel besteht aus vier zufälligen Spielern, die aus dem Pool der Spieler ausgewählt werden, um die vier Positionen zu besetzen. Spieler können nicht zweimal im Spiel sein.

Wertung

Der Gewinner jedes Spiels ist der Spieler mit dem meisten Geld am Ende des Spiels. Bei einem Unentschieden am Ende eines Spiels erhalten alle Spieler mit dem maximalen Geldbetrag einen Punkt. Der Spieler mit den meisten Punkten am Ende des Turniers gewinnt. Ich werde Punkte veröffentlichen, während ich die Spiele starte.

Die eingereichten Spieler werden dem Pool hinzugefügt. Ich habe drei wirklich dumme Bots hinzugefügt und einen, den ich gemacht habe, um zu beginnen.

Vorsichtsmaßnahmen

Ändern Sie nicht die Eingänge. Versuchen Sie nicht, die Ausführung eines anderen Programms zu beeinträchtigen, außer durch Zusammenarbeit oder Fehler. Machen Sie keine Opferunterwerfung, die versucht, eine andere Unterwerfung zu erkennen, und nutzen Sie diesen Gegner auf eigene Kosten. Standardlücken sind verboten.

Begrenzen Sie die Zeit, die Ihr Bot benötigt, auf ~ 10 Sekunden pro Runde.

Einsendungen dürfen frühere Einsendungen nicht duplizieren.

Bitte sehen Sie sich keine game_winner- oder game_loser-Wetten anderer Spieler an. Es ist ziemlich einfach zu machen, aber immer noch zu betrügen.

Wenn Sie Fragen haben, können Sie diese gerne stellen.

Gewinnen

Der Wettbewerb bleibt auf unbestimmte Zeit geöffnet, da neue Beiträge veröffentlicht werden. Ich werde jedoch einen Monat nach der Veröffentlichung dieser Frage (20. Juli) anhand der Ergebnisse einen Gewinner erklären (eine Antwort akzeptieren).

Ergebnisse

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

Sir_Humpfree_Bogart.py

Dies ist ein Bot, den ich für das Camel Up Cup Turnier gemacht habe .

Zunächst untersuchen sie alle möglichen Konfigurationen, die die Kamele am Ende der Runde haben könnten. Dann bestimmen sie den erwarteten Wert des Wettens auf ein Kamel, das die Runde gewinnt

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

Dann bewegen sie Kamele zufällig, bis ein Kamel gewinnt. Nachdem Sie dies einige tausend Mal getan haben, können Sie die Wahrscheinlichkeit abschätzen, mit der jedes Kamel gewinnt und verliert. Wieder erhalten wir den erwarteten Wert dieser mit

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

Die einzigen anderen Möglichkeiten sind das Bewegen eines Kamels (das immer eine Münze ergibt, der erwartete Wert ist eins) und das Platzieren einer Falle. Beide Teams waren der Meinung, dass das Platzieren einer Falle schwach genug war, um sie vollständig zu ignorieren. Mit diesen Informationen wählten die Bots die Option mit dem höchsten erwarteten Wert.

Da das Turnier einen zweiten Platz genauso wie einen letzten Platz ansah, ist es sinnvoll, wenn Sie im Rückstand sind, um das Risiko einzugehen, den ersten Platz zu erreichen. SBH verwendete distance_from_first_place und closeness_to_end, um zu bestimmen, wie riskant der Bot sein sollte. Wenn Sie weit vom ersten und nah am Ende entfernt sind, ist das Risiko hoch und wenn Sie am ersten oder weit vom Ende des Spiels entfernt sind, ist das Risiko gering . Mit einem geringen Risiko würde der Bot sich für eine Aktion mit einer Option mit hohem Erwartungswert und einem hohen Risiko entscheiden, was die Option mit einem hohen Ergebnis ergibt. Die genaue Gleichung war

Functional_EV = EV + (upshot-EV) * riskiness

Dabei ist das Ergebnis die höchste Auszahlung, die Sie aus einer Entscheidung ziehen können, und das Risiko reicht von 0 bis 1.

players.py

Dies sind unglaublich dumme Bots, um das Turnier in Gang zu bringen. Sie haben fast keine Logik, sondern dienen als Rahmen für die Nutzung durch die Menschen

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