Implementación del Algoritmo Genético en Unity

En la creación de juegos, el uso de técnicas de inteligencia artificial (IA) como los algoritmos
genéticos y las redes neuronales ofrece oportunidades emocionantes para desarrollar
personajes y comportamientos autónomos en el juego. En este contexto, implementar el
famoso juego Flappy Bird utilizando algoritmos genéticos y redes neuronales no solo
representa un desafío técnico, sino también una oportunidad para explorar las capacidades
de la IA en el desarrollo de juegos.

El proceso de desarrollo implica una serie de pasos clave, comenzando por la preparación
del escenario del juego, donde se configuran los elementos visuales, las físicas del juego y
los obstáculos que el jugador y los personajes autónomos, en este caso pájaros,
enfrentarán. Este paso es esencial para establecer el entorno en el que los algoritmos
genéticos y las redes neuronales pueden operar y tomar decisiones inteligentes.

Además de la preparación del escenario, se requiere la creación de clases y sistemas que

gestionen la evolución de los personajes autónomos, como el EvolutionManager, que se
encarga de supervisar la reproducción y mutación de los pájaros utilizando algoritmos
genéticos. Asimismo, se deben implementar las redes neuronales que guiarán el
comportamiento de los pájaros, permitiéndoles tomar decisiones basadas en su entorno y
experiencia.

A lo largo del proceso de desarrollo, se realizan ajustes y pruebas continuas para mejorar el
rendimiento y la jugabilidad del juego. Esto incluirá la optimización de los parámetros de los
algoritmos genéticos y las redes neuronales, así como la evaluación del rendimiento de los
pájaros en el juego para identificar áreas de mejora.

En este documento, explicaremos en detalle cada uno de estos pasos, desde la preparación
del escenario hasta la integración de los algoritmos genéticos y las redes neuronales en el
juego Flappy Bird, con el objetivo de proporcionar una guía completa para el desarrollo de
juegos utilizando técnicas de IA avanzadas.

Código

En esta implementación, se importan los espacios de nombres necesarios, como

System.Collections.Generic, System.Linq y UnityEngine. La clase EvolutionManager se
encarga de gestionar la evolución de las criaturas en el juego. A continuación se muestra el
código del algoritmo, con comentarios aclaratorios:

using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public class EvolutionManager : MonoBehaviour

{
 // Variables públicas accesibles desde el Editor de Unity
public GameObject creaturePrefab; // Prefab del objeto de la criatura
public int populationSize = 10; // Tamaño inicial de la población
public int eliteCount = 2; // Número de élites que se seleccionarán para reproducirse
public float topScore = 0; // Puntaje máximo de la población

// Lista de criaturas en la población

private List<GameObject> population = new List<GameObject>();

// Referencia al controlador del juego

private GameController gameController;

// Método que se llama cuando el objeto se inicializa

private void Awake()
{
// Busca y almacena una referencia al controlador del juego en la escena
gameController = FindObjectOfType<GameController>();
}

// Método que se llama al inicio del juego

void Start()
{
// Genera la población inicial
GenerateInitialPopulation();
// Inicia el juego
gameController.StartGame();
}

// Método que se llama en cada frame fijo (fijo para mantener la simulación física
constante)
void FixedUpdate()
{
// Si toda la población está extinta (muerta)
if (IsPopulationExtinct())
{
// Detiene el juego
gameController.StopGame();
// Selecciona las élites
SelectElites();
// Genera una nueva generación
GenerateNewGeneration();
// Reinicia el juego
gameController.StartGame();
}
else // Si hay al menos una criatura viva
{
// Ejecuta el pensamiento de cada criatura en la población
foreach (var creature in population)
 {
creature.GetComponent<NeuralNetwork>().Think();
}
}

// Calcula el puntaje máximo de la población

topScore = population.Max(go => go.GetComponent<Creature>().score);
}

// Genera la población inicial

void GenerateInitialPopulation()
{
for (int i = 0; i < populationSize; i++)
{
// Instancia una nueva criatura y la agrega a la lista de población
GameObject newCreature = Instantiate(creaturePrefab, Vector3.zero,
Quaternion.identity);
newCreature.name = "Creature" + i; // Asigna un nombre único a la criatura
population.Add(newCreature);
}
}

// Genera una nueva generación de criaturas

void GenerateNewGeneration()
{
for (int i = eliteCount; i < populationSize; i++)
{
// Selecciona dos padres al azar de las élites y los utiliza para criar una nueva
criatura
GameObject parent1 = population[Random.Range(0, eliteCount)];
GameObject parent2 = population[Random.Range(0, eliteCount)];
GameObject childCreature = BreedCreature(parent1, parent2);
childCreature.name = "Creature" + i; // Asigna un nombre único a la nueva criatura
population[i] = childCreature; // Reemplaza la criatura anterior con la nueva criatura
en la lista de población
}

// Reinicia las criaturas élite

for (int i = 0; i < eliteCount; i++)
{
population[i].GetComponent<Creature>().Reset();
}
}

// Verifica si toda la población está extinta (muerta)

bool IsPopulationExtinct()
{
// Verifica si todas las criaturas están muertas
 return population.All(creature => !creature.GetComponent<Creature>().isAlive);
}

// Método para seleccionar las élites

void SelectElites()
{
// No es necesario hacer nada aquí, las élites ya están al principio de la lista
}

// Método para criar una nueva criatura a partir de dos padres

public GameObject BreedCreature(GameObject motherCreature, GameObject
fatherCreature)
{
// Instancia una nueva criatura
GameObject childCreature = Instantiate(creaturePrefab, Vector3.zero,
Quaternion.identity);
// Realiza el cruce de los genes de los padres en la nueva criatura

childCreature.GetComponent<NeuralNetwork>().Breed(motherCreature.GetComponent<Ne
uralNetwork>(), fatherCreature.GetComponent<NeuralNetwork>(),
childCreature.GetComponent<Creature>());
// Devuelve la nueva criatura
return childCreature;
}
}

A continuación, se detallan las variables y métodos clave de esta clase:

Variables:

creaturePrefab: Almacena el prefab de la criatura.

populationSize: Define el tamaño inicial de la población de criaturas.
eliteCount: Especifica cuántas criaturas de élite se seleccionan en cada generación.
topScore: Almacena la puntuación más alta de la población actual.
population: Lista que contiene todas las criaturas en la población actual.
gameController: Referencia al GameController para iniciar y detener el juego.

Métodos:

Awake(): Se busca el GameController en la escena y se guarda la referencia.

Start(): Genera la población inicial y luego inicia el juego.
FixedUpdate(): Este método se llama en intervalos de tiempo fijos. Verifica si la población
se ha extinguido. Si es así, detiene el juego, selecciona las élites, genera una nueva
generación y reinicia el juego. Si la población no se ha extinguido, hace que cada criatura
piense.
GenerateInitialPopulation(): Crea criaturas iniciales y las agrega a la lista de población.
GenerateNewGeneration(): Crea una nueva generación de criaturas. Se seleccionan
padres de la población actual (incluyendo élites) al azar y se reproducen para crear nuevos
hijos. Los hijos reemplazan a las criaturas menos aptas de la generación anterior.
IsPopulationExtinct(): Comprueba si todas las criaturas en la población están muertas.
SelectElites(): No hace nada en este código, ya que las élites se seleccionan al principio de
la lista.
BreedCreature(): Crea un nuevo GameObject para una criatura hija y llama al método de
reproducción en la red neuronal de la criatura hija, pasando las redes neuronales de los
padres.

Preparación del Juego

Preparar el escenario para el juego Flappy Bird es un paso fundamental en la

implementación del algoritmo genético y la red neuronal. Comienza diseñando el entorno
del juego utilizando un editor de escenas, como el Editor de Escenas de Unity, donde
puedes crear fondos, suelos y obstáculos como tuberías. Es esencial que este diseño sea
coherente con el estilo visual y la mecánica de juego de Flappy Bird, incluyendo elementos
como fondos coloridos y tuberías verdes.

Una vez que hayas diseñado el escenario, configura la cámara del juego para seguir al
pájaro mientras vuela. Ajusta su posición y ángulo para ofrecer una vista clara del entorno
del juego, permitiendo que el jugador pueda ver al pájaro y los obstáculos a medida que
avanza por el nivel. Esto facilitará la toma de decisiones rápidas por parte del jugador.

Después, coloca los obstáculos, como tuberías, de manera estratégica en el escenario para
crear un desafío para los pájaros. Ajusta la altura y el espacio entre las tuberías para
controlar la dificultad del juego, y considera aumentar la velocidad del movimiento de las
tuberías a medida que el jugador avanza para aumentar el desafío.

Configura las físicas del juego para que el pájaro y los obstáculos interactúen de manera
realista. Esto implica configurar la gravedad, la detección de colisiones y las fuerzas
aplicadas al pájaro. Asegúrate de que el pájaro responda adecuadamente a las fuerzas
aplicadas, como la gravedad y las fuerzas de impulso al saltar.

Además, coloca puntos de referencia en el escenario para determinar la posición y la altura

del pájaro, así como la distancia entre él y los obstáculos. Estos puntos de referencia se
utilizarán como entradas para la red neuronal de los pájaros, permitiéndoles tomar
decisiones basadas en la información del entorno del juego.

Implementa elementos visuales, como efectos de partículas o animaciones, para

proporcionar retroalimentación visual al jugador cuando el pájaro interactúa con el entorno.
Añade efectos de sonido para mejorar la experiencia del jugador y proporcionar
retroalimentación auditiva cuando el pájaro interactúa con el entorno. Utiliza sonidos para
representar acciones como el vuelo del pájaro, las colisiones con las tuberías y los eventos
de juego, como la pérdida o la victoria.
Creación de la Red Neuronal

Las redes neuronales son un modelo computacional inspirado en la estructura y

funcionamiento del cerebro humano. Consisten en una red de nodos interconectados,
llamados neuronas artificiales, que trabajan en conjunto para realizar tareas específicas,
como reconocimiento de patrones, clasificación de datos o predicción de resultados.

Cada neurona artificial está asociada con una función de activación que determina su salida
en función de las entradas recibidas y los pesos asociados a esas conexiones. Durante el
entrenamiento, los pesos de las conexiones se ajustan iterativamente utilizando algoritmos
de aprendizaje, como el descenso de gradiente, para minimizar una función de pérdida y
mejorar el rendimiento de la red en la tarea específica.

Las redes neuronales se utilizan en una amplia variedad de aplicaciones, incluyendo

reconocimiento de imágenes, procesamiento del lenguaje natural, control de procesos
industriales, entre otros, debido a su capacidad para modelar relaciones complejas entre
datos y realizar predicciones precisas una vez entrenadas adecuadamente.

Para implementar una red neuronal en Unity, utilizaremos scripts C# para definir la
estructura de la red y su comportamiento. La red neuronal tomará entradas del entorno del
juego, como la distancia al suelo y a las tuberías, y generará una salida que controlará la
acción del pájaro, es decir, el momento en que salta. Es importante diseñar una red
neuronal que sea lo suficientemente compleja para capturar la información relevante del
entorno del juego y tomar decisiones efectivas.

La implementación de la red neuronal se puede realizar utilizando varias bibliotecas de

redes neuronales disponibles en Unity, como TensorFlowSharp o Unity 's on ML-Agents.
Estas bibliotecas proporcionan herramientas y funciones para crear y entrenar redes
neuronales dentro del entorno de Unity.

Para diseñar la red neuronal, primero necesitamos definir la estructura de la red, incluyendo
el número de neuronas en cada capa y las conexiones entre ellas. Una arquitectura común
para el juego Flappy Bird podría incluir una capa de entrada con neuronas que representan
las diferentes entradas del juego, como la distancia al suelo y a las tuberías, una o varias
capas ocultas para procesar esta información y una capa de salida que determina la acción
del pájaro, es decir, si debe saltar o no.

La función de activación de cada neurona en la red también debe ser seleccionada

cuidadosamente para proporcionar no linealidad y permitir que la red capture patrones
complejos en los datos de entrada. Funciones de activación comunes incluyen la función
sigmoide, la función ReLU (Rectified Linear Unit) y la función tangente hiperbólica.

Una vez que la estructura de la red neuronal esté definida, podemos proceder a
implementar la lógica para propagar hacia adelante los datos de entrada a través de la red y
obtener la salida correspondiente. Esto implica multiplicar las entradas por los pesos de las
conexiones entre las neuronas, sumar los resultados y aplicar la función de activación a
cada neurona en cada capa de la red. Este proceso se repetirá para cada capa de la red,
propagando los datos desde la capa de entrada hasta la capa de salida y generando la
salida final que determina la acción del pájaro.

Creación de la Clase Creature

La clase Creature representará a cada pájaro en el juego. Esta clase contendrá

componentes para la física del pájaro, como su posición y velocidad, así como la lógica de
la red neuronal que controla su comportamiento. Además, implementaremos un método
para evaluar el desempeño de cada pájaro en el juego y asignarle una puntuación en
función de su rendimiento.

La clase Creature también será responsable de actualizar el estado del pájaro en el juego
en cada fotograma. Esto incluirá la obtención de las entradas del entorno del juego, como la
distancia al suelo y a las tuberías, y pasar estas entradas a la red neuronal para obtener la
salida que determina la acción del pájaro. Dependiendo de la salida de la red neuronal, el
pájaro saltará o no, lo que afectará su posición y velocidad en el juego.

Además, la clase Creature implementará un método para evaluar el desempeño del pájaro
en el juego y asignarle una puntuación en función de su rendimiento. Esto puede implicar
factores como la distancia recorrida, el número de tuberías pasadas con éxito y el tiempo de
supervivencia en el juego. La puntuación asignada a cada pájaro se utilizará más tarde en el
algoritmo genético para determinar su aptitud y su probabilidad de ser seleccionado como
padre para la siguiente generación.

Implementación del EvolutionManager

Los algoritmos genéticos son una técnica de optimización y búsqueda inspirada en los
procesos de evolución natural y selección artificial. Utilizan una población de soluciones
candidatas, representadas típicamente como cromosomas o individuos, y aplican
operadores genéticos como selección, cruce y mutación para generar nuevas soluciones y
mejorar progresivamente la calidad de las mismas. Estos algoritmos imitan el proceso de
selección natural, donde las soluciones más aptas tienen una mayor probabilidad de
sobrevivir y reproducirse, mientras que las menos aptas tienden a desaparecer con el
tiempo. Los algoritmos genéticos se utilizan ampliamente en problemas de optimización,
búsqueda y aprendizaje automático, entre otros campos.

El EvolutionManager será responsable de gestionar la evolución de los pájaros a lo largo de

las generaciones. Este script definirá parámetros como el tamaño de la población, el
número de élites y la tasa de mutación. Generará una población inicial de pájaros con redes
neuronales aleatorias y luego utilizará un algoritmo genético para evolucionar esta población
a lo largo del tiempo. Esto implica la selección de élites, la reproducción de pájaros
seleccionados y la introducción de mutaciones en las redes neuronales para explorar
nuevas soluciones.

El algoritmo genético se ejecutará en ciclos de generaciones, donde cada generación

representará una iteración del proceso de evolución. En cada generación, el
EvolutionManager evaluará el desempeño de cada pájaro en la población actual utilizando
las puntuaciones asignadas por la clase Creature. Basándose en estas puntuaciones,
seleccionará los pájaros de élite que tendrán una mayor probabilidad de ser seleccionados
como padres para la siguiente generación.

La selección de los padres se realizará utilizando un método de selección basado en la

aptitud, donde los pájaros con puntuaciones más altas tendrán una mayor probabilidad de
ser seleccionados. Esto garantizará que los mejores pájaros de cada generación tengan la
oportunidad de transmitir sus genes a la siguiente generación y que las soluciones de alta
calidad se conserven a lo largo del tiempo.

Una vez seleccionados los padres, el EvolutionManager utilizará operadores genéticos

como la recombinación y la mutación para generar una nueva población de pájaros para la
siguiente generación. La recombinación implica combinar los genes de los padres
seleccionados para producir descendencia con una combinación de características
heredadas de ambos padres. La mutación introducirá cambios aleatorios en los genes de la
descendencia para explorar nuevas soluciones y evitar la convergencia prematura hacia
óptimos locales.

Integración con el Juego Flappy Bird

Para integrar el algoritmo genético con el juego Flappy Bird, conectaremos la salida de la
red neuronal de cada pájaro con su capacidad de volar y evitar las tuberías. Esto permitirá
que los pájaros jueguen de manera autónoma utilizando la información de su entorno y las
decisiones tomadas por su red neuronal. Además, implementaremos la lógica para evaluar
continuamente el rendimiento de los pájaros y actualizar la escena del juego en
consecuencia.

La integración con el juego Flappy Bird implica configurar el entorno del juego para
proporcionar las entradas necesarias a la red neuronal de cada pájaro, como la distancia al
suelo y a las tuberías. Estas entradas se utilizarán luego para calcular la salida de la red
neuronal, que determinará si el pájaro debe saltar o no. Dependiendo de la salida de la red
neuronal, el pájaro actualizará su posición y velocidad en el juego, lo que afectará su
interacción con las tuberías y su capacidad para evitar colisiones.

Además, implementaremos la lógica para evaluar continuamente el rendimiento de los

pájaros en el juego. Esto puede implicar el seguimiento de métricas como la distancia
recorrida, el número de tuberías pasadas con éxito y el tiempo de supervivencia en el juego.
Estas métricas se utilizarán para evaluar el desempeño de cada pájaro y determinar su
aptitud en el contexto del algoritmo genético. La integración del algoritmo genético y la red
neuronal con el juego Flappy Bird implica configurar el entorno del juego para proporcionar
las entradas necesarias a la red neuronal de cada pájaro y permitir que los pájaros jueguen
de manera autónoma.

Esto puede implicar la implementación de métodos en la clase Creature para obtener las
entradas del entorno del juego, como la distancia al suelo y a las tuberías, y pasar estas
entradas a la red neuronal para calcular la salida que determinará la acción del pájaro.
Además, se pueden implementar métodos en la clase Creature para actualizar
continuamente el estado del pájaro en el juego en cada fotograma, en función de la salida
de la red neuronal. Esto puede incluir el movimiento del pájaro hacia arriba o hacia abajo y
la detección de colisiones con las tuberías para determinar si el pájaro debe continuar
volando o si ha perdido el juego.

La integración con el juego Flappy Bird también puede implicar la implementación de lógica
para evaluar continuamente el rendimiento de los pájaros en el juego y ajustar la
configuración del algoritmo genético y la red neuronal en consecuencia. Esto puede incluir
el seguimiento de métricas como la distancia recorrida, el número de tuberías pasadas con
éxito y el tiempo de supervivencia en el juego para determinar la aptitud de cada pájaro en
el contexto del algoritmo genético.

Entrenamiento y Ajuste de Parámetros

Una vez que el juego esté configurado y funcionando, comenzaremos el proceso de

entrenamiento. Esto implica ejecutar el juego y observar cómo los pájaros evolucionan a lo
largo de las generaciones. A medida que los pájaros jueguen y acumulen experiencia,
ajustaremos los parámetros del algoritmo genético, como la tasa de mutación y el tamaño
de la población, para mejorar el rendimiento general de los pájaros.

El entrenamiento de los pájaros se realizará en ciclos de generaciones, donde cada

generación representará una iteración del proceso de evolución. Durante cada generación,
los pájaros jugarán el juego de Flappy Bird utilizando sus redes neuronales y acumularán
experiencia en función de su desempeño en el juego. Al final de cada generación,
evaluaremos el rendimiento de los pájaros y utilizaremos esta información para ajustar los
parámetros del algoritmo genético y mejorar el rendimiento de los pájaros en la siguiente
generación.

El ajuste de los parámetros del algoritmo genético se realizará de manera experimental,

donde probaremos diferentes valores para la tasa de mutación, el tamaño de la población y
otros parámetros clave y observaremos cómo afectan el rendimiento de los pájaros en el
juego. Utilizaremos técnicas como la búsqueda de hiper parámetros y el análisis de
sensibilidad para identificar los valores óptimos de los parámetros que maximicen el
rendimiento de los pájaros.

Evaluación del Rendimiento

Finalmente, evaluaremos el rendimiento de los pájaros entrenados en términos de cuánto

tiempo sobreviven en promedio o cuántas tuberías pasan con éxito. Utilizaremos esta
información para realizar ajustes adicionales en la red neuronal o en el algoritmo genético
según sea necesario para mejorar el rendimiento general de los pájaros.

La evaluación del rendimiento de los pájaros se realizará utilizando métricas objetivas que
reflejen su habilidad para jugar el juego de Flappy Bird de manera efectiva. Esto puede
incluir métricas como la distancia media recorrida, el número de tuberías pasadas con éxito
y el tiempo medio de supervivencia en el juego. Estas métricas se utilizarán para comparar
diferentes configuraciones de la red neuronal y del algoritmo genético y determinar cuál
produce los mejores resultados en términos de rendimiento de los pájaros.

Además, realizaremos análisis cualitativos del comportamiento de los pájaros entrenados

para identificar posibles áreas de mejora y ajustar la configuración del algoritmo genético en
consecuencia. Esto puede implicar observar la estrategia de juego de los pájaros y buscar
patrones comunes que indiquen áreas donde se puede mejorar el rendimiento.

Después de evaluar el rendimiento de los pájaros entrenados en el juego Flappy Bird, se

tomarán medidas específicas para mejorar su desempeño y eficacia en la navegación del
entorno del juego. Esta evaluación se realizará mediante métricas objetivas que
proporcionen una visión clara de la capacidad de los pájaros para enfrentar los desafíos del
juego de manera efectiva.

Una de las métricas clave que utilizaremos es el tiempo medio de supervivencia de los
pájaros en el juego. Este indicador nos brindará información sobre la resistencia y la
habilidad de los pájaros para evitar obstáculos durante períodos prolongados. Cuanto mayor
sea el tiempo medio de supervivencia, mayor será la capacidad de los pájaros para navegar
con éxito por el entorno del juego.

Otra métrica importante será el número de tuberías pasadas con éxito por cada pájaro
durante su tiempo de juego. Esta métrica nos permitirá evaluar la precisión y la consistencia
de las decisiones tomadas por los pájaros al enfrentarse a los obstáculos. Un alto número
de tuberías pasadas con éxito indicará una mayor capacidad de los pájaros para evitar
colisiones y avanzar en el juego.

Además, analizaremos la distancia media recorrida por los pájaros en cada partida. Esta
métrica nos dará una idea de la eficiencia de los pájaros para avanzar en el juego antes de
encontrar obstáculos o perder la partida. Una mayor distancia recorrida sugerirá una
estrategia de juego más efectiva y una mejor capacidad para adaptarse a las condiciones
cambiantes del entorno.

Al realizar un análisis cualitativo del comportamiento de los pájaros entrenados, buscaremos

patrones comunes que indiquen áreas específicas donde se puede mejorar su rendimiento.
Esto puede implicar observar cómo los pájaros responden a ciertos tipos de obstáculos o
situaciones de juego y identificar posibles deficiencias en su estrategia. Basándonos en
estos hallazgos, ajustaremos la configuración del algoritmo genético y de la red neuronal
para abordar estas áreas de mejora y optimizar el rendimiento general de los pájaros.

En resumen, la evaluación del rendimiento de los pájaros entrenados en el juego Flappy

Bird no solo se centrará en métricas cuantitativas como el tiempo de supervivencia y el
número de tuberías pasadas, sino también en un análisis cualitativo del comportamiento
para identificar oportunidades de mejora. Estas evaluaciones nos permitirán ajustar de
manera efectiva la configuración de la IA y optimizar el rendimiento de los pájaros en el
juego.
Conclusiónes

La implementación de un algoritmo genético con redes neuronales en Unity para entrenar a

los pájaros en el juego Flappy Bird es un proceso complejo pero gratificante. A través de la
iteración y el ajuste constante, podemos crear pájaros que sean capaces de jugar el juego
de manera autónoma y mejorar su rendimiento a lo largo del tiempo. Este enfoque puede
aplicarse a una amplia variedad de juegos y problemas, lo que lo convierte en una
herramienta poderosa para la inteligencia artificial en el desarrollo de juegos. Con una
planificación cuidadosa y una ejecución diligente, puedes crear un juego de Flappy Bird que
desafíe e intriga a los jugadores mientras exploran el potencial de la inteligencia artificial y el
aprendizaje automático en el desarrollo de juegos.

La aplicación de este enfoque no se limita solo al juego de Flappy Bird. Se puede adaptar
este método para entrenar agentes inteligentes en una amplia variedad de juegos y
problemas, lo que lo convierte en una herramienta poderosa para explorar el potencial de la
inteligencia artificial y el aprendizaje automático en el desarrollo de juegos. Con suficiente
perseverancia y creatividad, puedes crear experiencias de juego desafiantes e interesantes
que cautivan a los jugadores y exploren los límites de la tecnología de inteligencia artificial
en el desarrollo de juegos.