Camel Up Cup: un torneo de juegos de mesa de IA

Copa Camel Up 2k18

En este desafío, jugaremos el semi-popular juego de mesa Camel Up.

Camel Up! es un juego de mesa que hace que los jugadores apuesten a los camellos para ganar rondas, ganar o perder el juego, establecer trampas para influir en el movimiento o mover un camello. Cada una de estas decisiones lo recompensa con la posibilidad de obtener algo de dinero, que es lo que determina el ganador. Los jugadores deben usar la probabilidad, las consideraciones del estado del juego y la tenencia del oponente para tomar sus decisiones. Aquí hay un breve video que muestra a los jugadores cómo jugar .

Cómo jugar

Aquí hay una idea aproximada de cómo jugar. Mirar uno de los videos puede ser más útil porque tienen imágenes :)

En tu turno tienes 4 opciones.

1. Mueve un camello. Esto elige un camello de aquellos que no se han movido y lo mueve entre 1-3 espacios. Obtienes 1 moneda. Las rondas terminan cuando los cinco camellos se han movido, entonces todos pueden moverse
2. Coloca una trampa. Esto va en el tablero hasta el final de la ronda. Eliges + 1 / -1 trampa. Si un camello o una pila de camellos caen sobre él, se mueven + 1 / -1 y obtienes una moneda. No puedes colocar una trampa en el cuadrado 0. Puedes colocar una trampa donde están los camellos, aunque solo afectará a los camellos que caen en ella después.
3. Apuesta al ganador de la ronda. Apuesta a un ganador de la ronda. Ganan y obtienes 5/3/2/1 dependiendo de si fuiste el primero / segundo / tercero en apostar en ese camello.
4. Ganador / perdedor del juego. Apuesta a quién será el primero o el último al final del juego. obtienes 8/5/3/1/1 (creo) en función de si estabas 1º / 2º / 3º / etc. para apostar en ese camello

Notas:

• Hay 5 camellos. Comienzan en una posición al azar de 0-2.
• Cuando se mueve un camello (ver arriba lo que desencadena esto) se mueven 1-3 casillas. Si se colocan en un cuadrado con otro camello, se colocan "encima" del otro, creando una pila de camellos. Si un camello se va a mover, mueve todos los camellos sobre él en la pila de camellos. El camello en la parte superior de la pila se considera a la cabeza
• Si aterrizas en una trampa +1 (ver arriba lo que desencadena esto), avanzas un cuadrado más hacia adelante. Se aplican las reglas estándar de apilamiento.
• Sin embargo, si golpeas una trampa -1, mueves un cuadrado hacia atrás. Vas debajo de la pila de camellos que están en ese cuadrado, si hay alguno.
• El juego termina cuando un camello llega al cuadrado 16. Esto invoca inmediatamente los disparos de final de ronda y final de juego.
• Las apuestas de ganador / perdedor del juego solo se pueden hacer una vez por camello. Es decir, no puedes apostar a un camello para ganar y perder el juego.

Desafío

En este desafío, escribirás un programa de Python 3 para jugar con cuatro jugadores, el ganador se lleva todo el juego de gloria de Camel Up

Su programa recibirá el estado del juego, que contiene:

• camel_track : con las ubicaciones de los camellos
• trap_track : con la ubicación de las trampas (entrada del formulario [trap_type (-1,1), jugador])
• player_has_placed_trap : una matriz que te dice si los jugadores han colocado una trampa esta ronda
• round_bets : una serie de apuestas realizadas en esta ronda. De la forma [camello, jugador]
• game_winner_bets / game_loser_bets : conjuntos de las apuestas que los jugadores hicieron para que los camellos ganen o pierdan el juego. Solo podrá ver el valor de los jugadores que hicieron las apuestas, no a quién apostaron. Puedes saber a quién apostas. # del formulario [camello, jugador]
• player_game_bets : otra representación de game_winner_bets / game_loser_bets. Nuevamente, solo mira las apuestas que hizo tu bot.
• player_money_values : una matriz que muestra la cantidad de dinero que tiene cada jugador.
• camel_yet_to_move : una matriz que muestra si un camello se ha movido esta ronda.

Además del estado del juego también obtienes:

• jugador : un número entero que te dice qué número de jugador eres (0-3).

La sintaxis de lo que los jugadores deberían devolver es:

• [0]: mover camello
  
• [1, trap_type, trap_location]: colocar trampa
  
• [2, projected_round_winner]: Hacer apuesta de ganador de ronda
  
• [3, projected_game_winner]: Hacer apuesta de ganador del juego
  
• [4, projected_game_loser]: Hacer apuesta de juego perdedor
  

Esto debe estar envuelto en un método de movimiento (jugador, estado del juego)

Por ejemplo, aquí hay un jugador que hará una apuesta de ganador de ronda si está en el último lugar. Si no lo están, colocarán una trampa en un cuadrado al azar.

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

El juego se eligió por varias razones: tiene un grupo relativamente pequeño de opciones para elegir (aproximadamente 20 opciones por turno, se reducen fácilmente a generalmente alrededor de 3-4), los juegos son cortos y hay un elemento de suerte (lo hace entonces incluso los bots "malos" pueden ganar)

Como se Juega

El corredor del torneo se puede encontrar aquí: camel-up-cup . Ejecutar camelup.pypara ejecutar un torneo o la función PlayGame para ejecutar juegos. Mantendré ese repositorio actualizado con nuevos envíos. Se pueden encontrar programas de ejemplo en players.py.

Un torneo consta de 100 juegos por 10 jugadores (redondeado, por lo que 14 jugadores significa 200 juegos). Cada juego tendrá cuatro jugadores aleatorios seleccionados del grupo de jugadores para llenar las cuatro posiciones. Los jugadores no podrán estar en el juego dos veces.

Puntuación

El ganador de cada juego es el jugador con más dinero al final del juego. En caso de empate al final de un juego, todos los jugadores con la cantidad máxima de dinero reciben un punto. El jugador con más puntos al final del torneo gana. Publicaré puntuaciones mientras corro los juegos.

Los jugadores enviados se agregarán al grupo. Agregué tres bots realmente tontos y uno que hice para comenzar.

Advertencias

No modifique las entradas. No intente afectar la ejecución de ningún otro programa, excepto a través de la cooperación o defectos. No haga una presentación de sacrificio que intente reconocer otra presentación y beneficiar a ese oponente a su propio costo. Las lagunas estándar están prohibidas.

Limite el tiempo que tarda su bot en ~ 10 segundos por turno.

Los envíos no pueden duplicar los envíos anteriores.

No vea las apuestas de game_winner o game_loser de otros jugadores. Es bastante fácil de hacer pero sigue haciendo trampa.

Si tiene alguna pregunta, sientase con libertad de preguntar.

Victorioso

La competencia permanecerá abierta indefinidamente a medida que se publiquen nuevas presentaciones. Sin embargo, declararé un ganador (aceptar una respuesta) basado en los resultados un mes después de que se publicó esta pregunta (20 de julio).

Resultados

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

Sir_Humpfree_Bogart.py

Este es un bot que hice para el Torneo Camel Up Cup .

Primero, observan todas las configuraciones posibles que los camellos podrían terminar al final de la ronda. Luego determinan el valor esperado de apostar en un camello que gana la ronda usando

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

Luego mueven camellos al azar hasta que gana un camello. Después de hacer esto miles de veces, puede estimar la probabilidad de que cada camello gane y pierda. Nuevamente, obtenemos el valor esperado de estos utilizando

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

Las únicas otras opciones son mover un camello (que siempre produce una moneda, por lo que su valor esperado es uno) y colocar una trampa. Ambos equipos consideraron que colocar una trampa era una opción lo suficientemente débil como para ignorarla por completo. Con esta información, los bots eligieron la opción con el valor más alto esperado.

Dado que el torneo vio que el segundo lugar termina igual que el último lugar, tiene sentido si estás retrasado para arriesgarte a llegar al primer lugar. SBH utilizó distance_from_first_place y nearness_to_end para determinar qué tan riesgoso debería ser el bot, donde si estás lejos del primero y cerca del final, entonces el riesgo sería alto y si estás en el primero o lejos del final del juego, el riesgo sería bajo . Con un bajo riesgo, el bot decidirá una acción con una opción de alto valor esperado y un alto riesgo que dará la opción con un alto resultado. La ecuación exacta fue

Functional_EV = EV + (upshot-EV) * riskiness

donde el resultado final es el pago más alto que puede obtener de una decisión y el riesgo varía de 0 a 1.

players.py

Estos son bots increíblemente tontos para poner en marcha el torneo. Casi no tienen lógica, pero actúan como marcos para que la gente use

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