Lugo Bots

Crear bot ( 3 min)

Cómo desarrollar tu bot

Experimental

Lugo Studio V2

Entorno de desarrollo en el navegador — sin instalación de escritorio, configuración más ligera, VS Code integrado.

Conoce Lugo Studio V2

Lugo Studio Recomendado

Lugo Studio es el IDE de escritorio oficial para el desarrollo de bots. Guarda posiciones, cambia de lado del campo, reinicia la partida, controla la velocidad del juego y mucho más.

screenshot of lugo studio
  1. Descarga Lugo Studio para ayudarte a programar tu bot.
  2. Usa tu IDE favorito en tu máquina para programar tu bot.
  3. ¡Cuando tu bot esté listo para competir, publícalo!

Descargar para

Descargar

Por favor otorga permiso de ejecución después de descargar el binario

  • 1

    Ve al archivo

    Lugo Studio in the folder
  • 2

    Haz clic derecho en el archivo AppImage, ve a propiedades y otorga el permiso

    Lugo Studio in the folder

    O, usando la línea de comandos:

    sudo chmod +x [ruta al archivo]

Descarga el código fuente de la plantilla

Elige una plantilla de bot

Configurando el entorno

  • 1

    Abre la terminal en un directorio vacío que alojará el código fuente de tu bot (usa PowerShell en Windows)

  • 2

    Ejecuta el siguiente comando para configurar el kit de inicio rápido del proyecto

    # on Lunix or Mac
    docker run -v $(pwd):/output --rm lugobots/bot-setup:latest js

    # on Windows
    docker run -v ${PWD}:/output --rm lugobots/bot-setup:latest js

  • 3

    (Solo Linux y Mac) Corrige los permisos del archivo ejecutando

    chown $USER -R .

  • O, puedes descargar el código directamente de este repositorio


Cómo usar este código fuente

  • 1

    (opcional para acelerar los siguientes pasos) Descarga las imágenes que necesitarás

    docker pull lugobots/server
    docker pull lugobots/the-dummies-go:latest
    docker pull node:18

  • 2

    Ejecuta el servicio que instalará las dependencias que necesitas (espera a que el servicio termine)

    docker compose up builder

  • 3

    Ejecutando el juego

    docker compose up

  • 4

    Ahora, mira el juego en un navegador http://localhost:8080/

Configurando el entorno

  • 1

    Abre la terminal en un directorio vacío que alojará el código fuente de tu bot (usa PowerShell en Windows)

  • 2

    Ejecuta el siguiente comando para configurar el kit de inicio rápido del proyecto

    # on Lunix or Mac
    docker run -v $(pwd):/output --rm lugobots/bot-setup:latest py

    # on Windows
    docker run -v ${PWD}:/output --rm lugobots/bot-setup:latest py

  • 3

    (Solo Linux y Mac) Corrige los permisos del archivo ejecutando

    chown $USER -R .

  • O, puedes descargar el código directamente de este repositorio


Cómo usar este código fuente

  • 1

    (opcional para acelerar los siguientes pasos) Descarga las imágenes que necesitarás

    docker pull lugobots/server
    docker pull lugobots/the-dummies-go:latest
    docker pull python:3.9-slim-buster

  • 2

    Ejecuta el servicio que instalará las dependencias que necesitas (espera a que el servicio termine)

    docker compose up builder

  • 3

    Ejecutando el juego

    docker compose up

  • 4

    Ahora, mira el juego en un navegador http://localhost:8080/

Configurando el entorno

  • 1

    Abre la terminal en un directorio vacío que alojará el código fuente de tu bot (usa PowerShell en Windows)

  • 2

    Ejecuta el siguiente comando para configurar el kit de inicio rápido del proyecto

    # on Lunix or Mac
    docker run -v $(pwd):/output --rm lugobots/bot-setup:latest go

    # on Windows
    docker run -v ${PWD}:/output --rm lugobots/bot-setup:latest go

  • 3

    (Solo Linux y Mac) Corrige los permisos del archivo ejecutando

    chown $USER -R .

  • O, puedes descargar el código directamente de este repositorio


Cómo usar este código fuente

  • 1

    (opcional para acelerar los siguientes pasos) Descarga las imágenes que necesitarás

    docker pull lugobots/server
    docker pull lugobots/the-dummies-go:latest

  • 2

    Ejecuta el servicio que instalará las dependencias que necesitas (espera a que el servicio termine)

    docker compose up builder

  • 3

    Ejecutando el juego

    docker compose up

  • 4

    Ahora, mira el juego en un navegador http://localhost:8080/

Esta es una plantilla de bot entrenable para agentes de entrenamiento. Usa la plantilla simple para construir el bot.

Windows

  • 1

    Download The Learners Py project

  • 2

    Descomprime el contenido del archivo

  • 3

    Abre PowerShell en el directorio del proyecto ( mantén pulsada la tecla Shift y haz clic derecho, y luego haz clic en 'Abrir ventana de PowerShell aquí')


Instala las dependencias

virtualenv venv --python=python3.9
source venv/bin/activate
pip install -r requirements.txt


Ejecutando el juego

  • 1

    docker run -p 8080:8080 -p 5000:5000 lugobots/server:latest play --dev-mode --timer-mode=remote

  • 2

    Abre otra terminal e inicia el servidor de juego.

    python3 main.py

  • 3

    Ahora, mira el juego en un navegador http://localhost:8080/

Esta es una plantilla de bot entrenable para agentes de entrenamiento. Usa la plantilla simple para construir el bot.

Windows

  • 1

    Download The Learners JS project

  • 2

    Descomprime el contenido del archivo

  • 3

    Abre PowerShell en el directorio del proyecto ( mantén pulsada la tecla Shift y haz clic derecho, y luego haz clic en 'Abrir ventana de PowerShell aquí')


Instala las dependencias

npm install


Ejecutando el juego

  • 2

    Si editaste algún archivo, inicia el watcher para compilar el código fuente de TypeScript.

    npm run watch

  • 3

    Abre otra terminal e inicia el juego.

    docker run -p 8080:8080 -p 5000:5000 lugobots/server:v1.0.0-beta.6-rc.2 play --dev-mode --timer-mode=remote

  • 4

    Abre otra terminal e inicia el entrenamiento.

    npm run start

  • 5

    Ahora, mira el juego en un navegador http://localhost:8080/


Cómo editar el bot

Si deseas cambiar el comportamiento del bot, sigue las instrucciones del proyecto aquí

Tutoriales cortos

Ve todos nuestros tutoriales

Dependencias externas

Necesitarás estas dependencias para ejecutar el juego. Son bastante populares y ampliamente usadas, así que si eres desarrollador, probablemente ya las tengas.

Preguntas frecuentes

Independientemente del lenguaje de programación que elijas, tu bot debe implementar los siguientes métodos.

Todos los métodos reciben 2 parámetros, y el método del portero recibe un parámetro adicional.

El primer parámetro es el OrderSet. Este es el objeto donde tu bot debe definir las órdenes que desea enviar al servidor en el turno actual.

El segundo parámetro es el GameSnapshot. Trae el estado actual del juego y sus elementos: posiciones de los jugadores, velocidad, dirección, posición del balón, marcador, etc...

El portero recibe un tercer parámetro que indica el estado del portero (sosteniendo el balón, defendiendo, disputando o apoyando).

class Bot:
        def on_disputing(self, inspector: GameSnapshotInspector) -> List[Order]:
            """
            This is called when no one has the ball possession
            """
            pass

        def on_defending(self, inspector: GameSnapshotInspector) -> List[Order]:
            """
            This is called when an opponent player has the ball possession
            """
            pass

        def on_holding(self, inspector: GameSnapshotInspector) -> List[Order]:
            """
            This is called when this bot has the ball possession
            """
            pass

        def on_supporting(self, inspector: GameSnapshotInspector) -> List[Order]:
            """
            This is called when a teammate player has the ball possession
            """
            pass

        def as_goalkeeper(self, inspector: GameSnapshotInspector, state: PLAYER_STATE) -> List[Order]:
            """
            This is only called when this bot is the goalkeeper (number 1). This method is called on every turn, and the player state is passed at the last parameter.
            """
            pass
    
export interface Bot {
{

    /**
     * OnDisputing is called when no one has the ball possession
     */
    onDisputing: (inspector: GameSnapshotInspector) => Order[]

    /**
     * OnDefending is called when an opponent player has the ball possession
     */
    onDefending: (inspector: GameSnapshotInspector) => Order[]

    /**
     * OnHolding is called when this bot has the ball possession
     */
    onHolding: (inspector: GameSnapshotInspector) => Order[]
    /**
     * OnSupporting is called when a teammate player has the ball possession
     */
    onSupporting: (inspector: GameSnapshotInspector) => Order[]

    /**
     * AsGoalkeeper is only called when this bot is the goalkeeper (number 1). This method is called on every turn, and the player state is passed at the last parameter.
     */
    asGoalkeeper: (inspector: GameSnapshotInspector, state: PLAYER_STATE) => Order[]
}
type Bot interface {

    // OnDisputing is called when no one has the ball possession
    OnDisputing(ctx context.Context, inspector SnapshotInspector) ([]proto.PlayerOrder, string, error)

    // OnDefending is called when an opponent player has the ball possession
    OnDefending(ctx context.Context, inspector SnapshotInspector) ([]proto.PlayerOrder, string, error)

    // OnHolding is called when this bot has the ball possession
    OnHolding(ctx context.Context, inspector SnapshotInspector) ([]proto.PlayerOrder, string, error)

    // OnSupporting is called when a teammate player has the ball possession
    OnSupporting(ctx context.Context, inspector SnapshotInspector) ([]proto.PlayerOrder, string, error)

    // AsGoalkeeper is only called when this bot is the goalkeeper (number 1). This method is called on every turn, and the player state is passed at the last parameter.
    AsGoalkeeper(ctx context.Context, inspector SnapshotInspector, state PlayerState) ([]proto.PlayerOrder, string, error)
}

Mira abajo un ejemplo en formato JSON de un objeto GameSnapshot.

Sin embargo, todos los métodos del bot recibirán el GameSnapshot como un objeto según el lenguaje de programación que estés usando.

Recomendamos fuertemente que no lo conviertas a JSON, ya que el objeto es una representación de una respuesta gRPC.

Independientemente del lenguaje de programación que uses, habrá una clase GameSnapshot reader que implementará la mayoría de las operaciones comunes que necesitarás (por ejemplo, obtener a tus compañeros de equipo, obtener un jugador específico, etc.).

Ten en cuenta que los vectores están normalizados y multiplicados por 100 (consulta la documentación para más detalles).

{
"state": "LISTENING",
"turn": 47,
"home_team": {
"players": [
{
"number": 1,
"position": {
"x": 9048,
"y": 3245
},
velocity": {
"direction": {
"x": -99.95606441193794,
"y": -2.963981659273956
},
"speed": 100
},
"init_position": {
"x": 7000,
"y": 1875
}
},
{
"number": 2 ...
},
{
"number": 3 ...
}
],
"name": "Team A", "side": "AWAY"
},
"away_team": {
"players": [
...
],
"name": "VS Code",
"side": "AWAY"
},
"ball": {
"position": {
"x": 9740,
"y": 5223
},
"velocity": {
"direction": {
"x": -99.79061148317571,
"y": -6.467910003539166
},
"speed": 100
},
"holder": {
"number": 8,
"position": {
"x": 9940,
"y": 5236
},
"velocity": {
"direction": {
"x": -99.79061148317571,
"y": -6.467910003539166
},
"speed": 100
},
"init_position": {
"x": 7000,
"y": 4375
}
}
},
"shot_clock": {
"remaining_turns": 300
}
}

No necesitas estudiar la documentación. Todas las implementaciones del cliente incluyen las especificaciones.

Como ejemplo, en el cliente Python, el entorno de desarrollo integrado (IDE) listará todas las especificaciones del juego a partir de los paquetes lugo4py:

¡Solo depende de tu creatividad!

A diferencia de las preguntas de la ACM International Collegiate Programming Contest, en un juego como Lugo no hay una salida esperada, sino un resultado esperado.

Eso significa que puedes optar por obtener un resultado (por ejemplo, pasar el balón al compañero más seguro) que requiere conocimiento de un algoritmo específico, mientras que otro programador puede querer un resultado diferente (por ejemplo, pasar el balón al compañero más adelantado). Y el nuevo resultado puede exigir un algoritmo totalmente diferente.

Por lo tanto, si eres un buen programador de ICPC, ciertamente tendrás buenos resultados para lograr el resultado deseado. Pero si no estás obteniendo buenos resultados en las competencias ICPC, aún tendrás buenas oportunidades de encontrar en Lugo un buen lugar para destacar.

Es un juego de inteligencia artificial que no requiere experiencia en IA. Si no estás familiarizado con la IA, no te preocupes.

Lugo es un gran lugar para practicar tus técnicas si tienes experiencia en IA, aprendizaje automático o aprendizaje por refuerzo.

Pero si aún no tienes experiencia, Lugo es una excelente forma de empezar desde cero en el campo de la IA.

De hecho, los mejores bots hasta ahora (2023) fueron desarrollados por desarrolladores junior que aún no tienen experiencia con algoritmos de IA.

¡Ya empezó!

Puedes enviar tu bot cuando quieras. Luego, puedes inscribir tu bot en los torneos y esperar a que se jueguen las partidas oficiales.

Lugo no es un juego como carreras, minería, búsqueda, etc., donde hay una métrica de rendimiento/eficiencia que superar. No, todo se trata de estrategia.

Siempre habrá una forma de derrotar a un bot, pero no de derrotar a todos los bots. Si no estás de acuerdo con esta afirmación, demuéstrame lo contrario. :-)

Sin embargo, podemos llegar a un punto en el que los bots se vuelvan muy maduros y las estrategias más comunes sean bien conocidas. Cuando eso ocurra, las partidas pueden terminar en empate con mucha frecuencia, si no constantemente. Entonces, como hacen la mayoría de los deportes reales, podremos cambiar las reglas para hacerlo más competitivo.