1. Generalidades
Esta es la página web oficial del reto titulado “Introducción a la inteligencia artificial (IA) orientada al diseño y programación de juegos de estrategia” de la semana-i 2016 del Tecnológico de Monterrey, Campus Estado de México.
1.1. Responsables
-
Profesor Ariel Ortiz Ramírez
ariel.ortiz@itesm.mx -
Profesor Roberto Martínez Roman
rmroman@itesm.mx
1.2. Objetivo
Los alumnos del primer tercio de las carreras de ISC e ISDR aplicarán sus conocimientos de resolución de problemas y pensamiento algorítmico para diseñar e implementar programas en el lenguaje Python que utilicen técnicas sencillas de inteligencia artificial con el fin de competir en un torneo de juegos de estrategia.
1.3. Descripción
Durante este reto:
-
Los alumnos participarán en una competencia de programación por equipos para afinar sus habilidades de resolución de problemas.
-
Los alumnos recibirán una capacitación sobre teoría de juegos y técnicas sencillas de inteligencia artificial para juegos de estrategia.
-
Los alumnos, en equipos de dos o tres personas, implementarán en Python programas que jugarán de manera autónoma contra los elaborados por los otros equipos.
-
Se organizará un torneo para determinar cuáles son los programas con las mejores estrategias.
-
Los alumnos recibirán una plática sobre el impacto que tienen los sistemas con algoritmos inteligentes en un proyecto de la vida real.
-
Los alumnos verán una película de ciencia ficción que toque el tema de la inteligencia artificial y además contenga un dilema de tipo moral. Esto permitirá abrir un espacio para discutir y reflexionar sobre la ética del impacto que pueden llegar a tener los sistemas inteligentes en nuestro mundo.
-
Los alumnos documentarán los logros y experiencias obtenidas en el reto utilizando un blog.
1.4. Agenda
A continuación se presenta la agenda para el reto durante la semana del 26 al 30 de septiembre de 2016. Esta agenda está sujeta a cambios. Favor de revisar el grupo de facebook para conocer cualquier cambio de último momento.
| Lunes 26 |
Martes 27 |
Miércoles 28 |
Jueves 29 |
Viernes 30 |
|
|---|---|---|---|---|---|
9:00-10:00 |
Inauguración del reto ¶ |
Taller: Framework Dagor para juegos de estrategia § |
Revisión de avance de proyecto § |
Torneo de estrategias § |
Conferencia magistral ¶ |
10:00-11:00 |
Taller: Preparación para el concurso de programación § |
Película de ciencia ficción y reflexión ética ¶ |
|||
11:00-12:00 |
Concurso de programación § |
Desarrollo de proyecto y asesoría § |
|||
12:00-13:00 |
Desarrollo de proyecto y asesoría § |
Presentación de resultados del torneo ¶ |
|||
13:00-14:00 |
Revisiones y aclaraciones post-torneo § |
Clausura del reto¶ |
Lugares de reunión:
-
¶: Salón de congresos, sala A
-
§: Salones 5301 y 5302
1.5. Evaluación
Te recordamos que el 5% de la calificación final de cada materia que tienes inscrita durante este semestre está ligada a los resultados que obtengas en la evaluación de tu semana-i.
Nuestro reto será evaluado de la siguiente manera:
| Concepto | Porcentaje | Notas |
|---|---|---|
Concurso de programación |
15% |
Los puntos porcentuales otorgados dependerán del percentil en el que se coloque cada equipo como resultado de su participación en el concurso de programación:
|
Torneo de estrategias |
60% |
Los puntos porcentuales otorgados dependerán del percentil en el que se coloque cada equipo como resultado de su participación en el torneo de estrategias:
|
Blog |
25% |
Durante la semana cada equipo irá documentando en un blog las experiencias y logros obtenidos. |
Total |
100% |
1.6. Publicación de calificaciones
Cada alumno puede consultar su calificación final del reto en la siguiente liga:
1.7. Grupo de facebook
Durante todo el reto estaremos usando un grupo de facebook para dar anuncios, publicar fotos, etc. Si aún no lo has hecho, es indispensable que solicites cuanto antes unirte a dicho grupo:
2. Blog
Tal como ya se mencionó anteriormente, durante la semana cada equipo irá documentando en un blog las experiencias y logros obtenidos. Esta actividad constituye la cuarta parte de la calificación de este reto.
2.1. Consideraciones generales
Estos son los puntos que deben consider como equipo:
-
El blog se debe crear en el sitio de blogger.com y debe ser exclusivo para el reto. Para esto se requiere que todos los miembros del equipo cuenten con una cuenta de Google. En la configuración básica del blog deben darse de alta como autores todos los integrantes del equipo.
-
En cuanto hayan creado su blog deberán compartir el URL correspondiente en el grupo de facebook del reto.
-
Cada entrada del blog debe tener al menos 300 palabras.
-
Algunas entradas serán individuales y otras serán en equipo.
-
Los temas de las entradas se irán detallando en la siguiente sección conforme avance la semana.
2.2. Fechas de publicación
| Entrada # | Fecha límite de publicación | Tema | Entrada individual o en equipo | Descripción |
|---|---|---|---|---|
1 |
Lunes 26 de septiembre |
Presentación personal |
Individual |
Cada integrante del equipo se presentará ante el resto de sus compañeros de este reto de la semana-i. Algunas de las cosas de las que pueden escribir incluyen:
|
2 |
Lunes 26 de septiembre |
Concurso de programación |
Equipo |
El equipo comentará sobre su experiencia durante el concurso de programación del día lunes. Los elementos que pueden tratar en su entrada son:
|
3 |
Martes 27 de septiembre |
Teoría de juegos |
Equipo |
Investiguen brevemente sobre el concepto de teoría de juegos y su relevancia en la ciencia de la computación. Relacionen sus hallazgos con lo que aprendieron el día de hoy en el taller “Framework Dagor para juegos de estrategia”. Comenten también sobre algunos de los siguientes aspectos:
No olviden citar correctamente todos los recursos consultados. |
4 |
Miércoles 28 de septiembre |
Programando un jugador estratégico |
Equipo |
En este entrada el equipo comentará sus reflexiones sobre el proceso de diseño e implementación de su proyecto de jugador estratégico para el juego de Orugas. Pueden comentar sobre:
|
5 |
Jueves 29 de septiembre |
El torneo de estrategias |
Equipo |
Cada equipo comentará sus experiencias y aprendizajes sobre la fase final de implementación de su jugador estratégico, así como también los resultados que obtuvieron en el torneo. ¿Qué hubieran hecho diferente si hubieran tenido más tiempo para desarrollar su proyecto? Pueden también comentar sobre lo que les gustó y/o disgustó del torneo en sí. |
6 |
Viernes 30 de septiembre |
Ex Machina |
Equipo |
Por equipo, coloquen sus conclusiones sobre las preguntas en la hoja de discusión ética de la película “Ex Machina”. Reproducimos aquí las preguntas:
Estas pregunas fueron tomadas del sitio Just:Words de RameyLady. |
7 |
Viernes 30 de septiembre |
Cierre del reto |
Individual |
De manera individual, cada integrante del equipo realizará su conclusión personal sobre el este reto. Pueden incluir en su entrada:
|
3. Concurso de programación
3.1. Reglas del concurso
-
El concurso tiene una duración de tres horas y se efectuará el lunes 26 de septiembre de 11:00 a 14:00 hrs. en los salones designados.
-
El concurso es por equipos. Cada equipo estará conformado por dos o tres integrantes.
-
Los equipos recibirán oportunamente un login y password para acceder al sitio del concurso (omegaup.com). No se podrá utilizar ninguna otra cuenta de este sitio para ingresar a la competencia.
-
Cada equipo, sin importar el número de integrantes, podrá utilizar hasta dos computadoras: una para programar y enviar las soluciones, y la otra para revisar la documentación.
-
El concurso consiste de siete problemas. Cada problema, por su nivel de dificultad, tiene un cierto valor en puntos: 100 o 200.
-
Los problemas deberán resolverse usando exclusivamente Python 2.7. No tendrán valor los problemas que sean resueltos usando algún otro lenguaje de programación.
-
Al enviar un problema al sitio del concurso, el juez en línea lo revisará inmediatamente e indicará su dictamen en la columna de status:
-
AC – Accepted. Su envío resolvió correctamente todos los casos de prueba y obtuvieron la máxima cantidad de puntos. ¡Felicidades!
-
PA – Partially Accepted. Su envío resolvió al menos un caso de prueba, pero hay al menos un caso que no resolvieron correctamente. Intenten arreglar su programa y vuélvanlo a intentar.
-
WA – Wrong Answer. Su programa no resolvió ningún caso correctamente.
-
TLE – Time Limit Exceeded. Al menos en uno de los casos, su programa excedió el límite de tiempo. Intenten pensar en una solución más eficiente o busquen en su código si hay algún ciclo infinito.
-
MLE – Memory Limit Exceeded. Al menos en uno de los casos, su programa excedió el límite de memoria. Intenten pensar en una solución que utilice menos memoria.
-
RTE – Runtime error. En al menos uno de los casos, su programa tuvo un error fatal: puede ser una excepción, divisiones entre cero, desbordaron el stack, se salieron de los límites de un arreglo, etc. Vuelvan a leer el problema y piensen qué casos se les olvidó considerar y qué entrada puede hacer que su programa se comporte de esta manera.
-
RFE – Restricted function. En al menos uno de los casos, su programa intentó realizar una operación prohibida. En general, no pueden abrir ningún archivo, no pueden conectarse a internet, no pueden ejecutar otros programas y no pueden comunicarse con nada del sistema fuera del problema. Limítense a resolver el problema usando algoritmos.
-
-
Cuando envíen una solución que resulte rechazada, deberán esperar al menos un minuto antes de poder enviar una versión corregida.
-
El lugar que cada equipo obtendrá en el concurso se determinará por la suma de los puntos de los problemas que resuelvan correctamente. La máxima puntuación que puede obtener un equipo es 1,000.
-
Si al final del concurso dos o más equipos tienen la misma puntuación, se usa como criterio de desempate la suma del tiempo de resolución de los problemas aceptados. Por ejemplo, supongamos que el equipo A ha enviado sus soluciones para dos problemas en los minutos 60 y 120 desde el inicio del concurso, y otro equipo B ha resuelto los mismos problemas en los minutos 80 y 90. El desempate entre ambos equipos se haría viendo los tiempos, para el equipo A: 60 + 120 = 180 minutos; para el equipo B: 80 + 90 = 170 minutos. En este caso el equipo B ganaría.
El tiempo que se toma para los desempates es el tiempo que ha pasado desde el inicio del concurso más 20 minutos por cada solución incorrecta enviada. En el ejemplo anterior, si el equipo A hubiera enviado 2 soluciones incorrectas para su primer problema, su tiempo final sería: 20 + 20 + 60 + 120 = 220. La penalización de 20 minutos solo aplica si el problema en cuestión es finalmente aceptado. No hay penalización por soluciones incorrectas de problemas que nunca fueron aceptados.
-
Estos son los únicos sitios de Internet que se tiene permitido acceder durante el concurso:
El acceso a cualquier otro sitio, incluyendo Google y Stack Overflow, está estrictamente prohibido.
-
Durante el concurso no está permitido hablar con personas de otros equipos ni utilizar teléfonos celulares u otros dispositivos.
-
Cualquier falta a este reglamento puede provocar desde una amonestación verbal hasta la descalificación del equipo involucrado.
-
Cualquier aspecto no tratado aquí será resuelto a criterio de los profesores responsables de este reto.
3.2. Problema de entrenamiento
Utilicen el login y password de la cuenta provista para su equipo e ingresen a la siguiente liga:
-
Problema: El mayor de dos
Escriban su solución en Python 2.7 usando el editor de su preferencia (IDLE, Komodo Edit, etc.):
a = int(raw_input())
b = int(raw_input())
if a > b:
print a
else:
print bCreen en su editor los archivos para sus casos de prueba:
3 5
5 5
10 1
Abran una terminal (cmd.exe en Windows) y cámbiense al directorio donde están todos sus archivos.
Los símbolos $ y c:\> en los siguientes ejemplos son el prompt de la terminal y no deben teclearlos.
|
$ cd /directorio/donde/estan/los/archivos
c:\> cd \directorio\donde\estan\los\archivos
Ahora corran su programa usando los casos de prueba, verificando que se obtenga la salida esperada.
|
Si al correr el comando
Si el problema persiste, probablemente no se instaló correctamente Python 2.7 en la computadora en cuestión. |
$ python mayor_de_dos.py < 1.in 5
$ python mayor_de_dos.py < 2.in 5
$ python mayor_de_dos.py < 3.in 10
|
El operador menor que ( |
Si consideran que su programa ya funciona de manera correcta, súbanlo al sitio de omegaUp usando la liga que dice “Nuevo envío” en la sección inferior de la página del problema. El juez en línea responderá su veredicto de forma casi inmediata.
3.3. Liga del concurso
Para iniciar el concurso, vayan a la siguiente liga:
3.4. Resultados del concurso de programación
El siguiente documento PDF tiene los resultados del concurso de programación celebrado el 26 de septiembre:
4. Framework Dagor
Dagor es un framework de Python que permite programar diversos tipos de jugadores que compiten entre sí para ganar un juego combinacional.
| La palabra Dagor significa “batalla” en el idioma sindarin (conocido también como élfico gris), creado por el escritor británico J. R. R. Tolkien, autor del “Señor de los anillos”. |
En teoría de juegos, un juego combinacional tiene las siguientes características:
-
Siempre hay dos jugadores que toman turnos para tirar de manera alternada.
-
No hay elementos aleatorios como dados o cartas barajadas.
-
Ambos jugadores tienen información perfecta (no hay información oculta).
-
El juego es finito — debe terminar eventualmente.
-
Usualmente el último jugador en tirar gana.
Muchas de las ideas de este framework fueron tomadas del sitio Gamesman elaborado por Dan Garcia de UC Berkeley.
4.1. Descarga
El módulo de dagor se puede descargar de la siguiente liga:
-
dagor.zip versión 1.0.2, 28 de septiembre, 2016.
Solo se requiere descomprimir el ZIP y copiar el archivo dagor.py al directorio de trabajo.
4.2. D10 (destino 10)
4.2.1. Reglas
Piezas y tablero: Este juego se juega en un tablero de 1 por 10. La posición inicial es un tablero vacío.
Para tirar: Los jugadores se alternan colocando una o dos piezas en las localidades desocupadas de más a la izquierda del tablero. En este juego no hay distinción respecto a las piezas de cada jugador. Nos referiremos al primer jugador en tirar como izquierda, y al otro jugador como derecha.
Para ganar: El primer jugador en colocar la décima pieza en el tablero gana.
4.2.2. Ejemplo
Tablero inicial: _ _ _ _ _ _ _ _ _ _ | | | | | | | | | | | | | | | | | | | | | | |_|_|_|_|_|_|_|_|_|_| 1 2 3 4 5 6 7 8 9 10 Izquierda tira 2 _ _ _ _ _ _ _ _ _ _ | | | | | | | | | | | |*|*| | | | | | | | | |_|_|_|_|_|_|_|_|_|_| 1 2 3 4 5 6 7 8 9 10 Derecha tira 2 _ _ _ _ _ _ _ _ _ _ | | | | | | | | | | | |*|*|*|*| | | | | | | |_|_|_|_|_|_|_|_|_|_| 1 2 3 4 5 6 7 8 9 10 Izquierda tira 2 _ _ _ _ _ _ _ _ _ _ | | | | | | | | | | | |*|*|*|*|*|*| | | | | |_|_|_|_|_|_|_|_|_|_| 1 2 3 4 5 6 7 8 9 10 Derecha tira 1 _ _ _ _ _ _ _ _ _ _ | | | | | | | | | | | |*|*|*|*|*|*|*| | | | |_|_|_|_|_|_|_|_|_|_| 1 2 3 4 5 6 7 8 9 10 Izquierda tira 2 _ _ _ _ _ _ _ _ _ _ | | | | | | | | | | | |*|*|*|*|*|*|*|*|*| | |_|_|_|_|_|_|_|_|_|_| 1 2 3 4 5 6 7 8 9 10 Derecha tira 1 _ _ _ _ _ _ _ _ _ _ | | | | | | | | | | | |*|*|*|*|*|*|*|*|*|*| |_|_|_|_|_|_|_|_|_|_| 1 2 3 4 5 6 7 8 9 10 Derecha resulta ganador
4.2.3. Utilizando Dagor
El siguiente programa permite a un jugador humano jugar contra un jugador estratégico autónomo:
# coding: utf-8
from dagor import JuegoD10, JugadorD10Interactivo, JugadorD10Estrategico (1)
jugador1 = JugadorD10Interactivo('Humano') (2)
jugador2 = JugadorD10Estrategico('Máquina') (3)
juego = JuegoD10(jugador1, jugador2) (4)
juego.inicia() (5)| 1 | Importamos del módulo dagor las clases que estaremos utilizando en nuestro programa. |
| 2 | Creamos un jugador de D10 interactivo. |
| 3 | Creamos un jugador de D10 estratégico autónomo. |
| 4 | Creamos un juego de D10 y le enviamos los dos jugadores previamente creados. |
| 5 | Comenzamos el juego. |
Para correrlo, desde la terminal teclear:
$ python ejemplo1.py
4.2.4. Clases disponibles
| Clase | Descripción |
|---|---|
|
Clase que representa un juego de D10 (Destino 10). |
|
Toda clase que represente un jugador del juego D10 debe heredar de esta clase. |
|
Jugador de D10 que tira de manera aleatoria. |
|
Jugador de D10 que tira con una estrategia. |
|
Jugador de D10 controlado a partir de una interfaz de usuario en modo texto. |
4.2.5. Programando un nuevo jugador
Para escribir el código de un nuevo jugador solo se requiere:
-
Definir una clase que herede del tipo de jugador deseado (
JugadorD10en nuestro caso). -
Proporcionar la implementación de los siguientes dos métodos abstractos:
-
heuristica(self, posicion): Función heurística que puede utilizar un jugador para rankear la posición enviada como argumento. -
tira(self, posicion): Invocada automáticamente por el objeto controlador del juego para determinar el tiro de este jugador. Debe devolver un tiro válido a partir de la posición enviada como argumento.
-
El siguiente código muestra un jugador de D10 cuya estrategia es tirar un 1 siempre, excepto si existe un tiro ganador con un 2:
from dagor import JuegoD10, JugadorD10, JugadorD10Aleatorio
class JugadorD10SiempreTiraUno(JugadorD10): (1)
def heuristica(self, posicion):
return self.triunfo(posicion) == self.simbolo (2)
def tira(self, posicion):
posibles = self.posiciones_siguientes(posicion) (3)
for p in posibles: (4)
if self.heuristica(p):
return p
return posibles[0] (5)
jugador1 = JugadorD10SiempreTiraUno('OnlyOne')
jugador2 = JugadorD10Aleatorio('RandomBoy')
juego = JuegoD10(jugador1, jugador2)
juego.inicia()| 1 | Esta es la manera correcta en Python de definir una clase JugadorD10SiempreTiraUno que hereda de otra JugadorD10. |
| 2 | Esta función heurística devuelve True si posicion resulta en un tiro ganador para este jugador. De otra forma regresa False. |
| 3 | Obtenemos todas todas las posiciones posibles que puede haber en un juego posteriores a posicion. |
| 4 | Busca si en esas posibles posiciones existe un tiro ganador. |
| 5 | De lo contrario, tira siempre la primera posición, la cual siempre es el tiro con un 1. |
4.2.6. Sobre posicion
La documentación en línea indica la estructura interna que tiene el parámetro posicion para los métodos definidos en el ejemplo anterior. Para consultarla, hay que correr el interprete de Python. Desde la línea de comando teclear:
python
En el shell de Python, debemos hacer lo siguiente:
>>> from dagor import JugadorD10 (1)
>>> help(JugadorD10) (2)| 1 | Importamos la clase de la cual heredamos en el ejemplo de arriba. |
| 2 | Solicitamos la ayuda en línea. |
La salida debe ser algo así:
Help on class JugadorD10 in module dagor:
class JugadorD10(Jugador)
| Toda clase que represente un jugador del juego D10
| debe heredar de esta clase.
|
| La posición que maneja un juego de D10 es una tupla
| de la siguiente forma:
|
| (J, S)
|
| En donde:
|
| J: turno actual (nombre del jugador que se indicó al
| momento de crearlo)
| S: suma hasta el momento (0 al 10)
|
| Por ejemplo:
|
| ('Alfa', 5)
|
| Esta posición indica que el jugador actual es Alfa y que
| la suma actual es 5.
4.2.7. Opciones de inicia
El método inicia de la clase Juego (y sus subclases, como JuegoD10) comienza un encuentro entre los dos jugadores provistos al momento en el que se creó el juego. El encuentro tendrá un cierto número de juegos determinado por el valor del parámetro opcional veces. Cada jugador tira primero de manera alternada en todos los juegos del encuentro. Si el parámetro opcional delta_max tiene un valor mayor a cero arroja la excepción de TiemploLimiteExcedido si el tiempo que tarda el tiro de algún jugador excede delta_max segundos. Al final despliega un resumen del encuentro si veces es mayor a 1.
En el siguiente ejemplo se inicia un encuentro de 10 juegos en donde el tiro de cada jugador debe durar 2 segundos o menos.
juego.inicia(veces=10, delta_max=2)4.2.8. Propiedades y funciones de un jugador
Cualquier instancia de las subclases de la clase Jugador (incluyendo JugadorD10 y sus subclases) tienen los siguientes métodos y propiedades:
| Nombre | Descripción |
|---|---|
|
Constructor que inicializa un jugador con |
|
Método que convierte este jugador a una cadena de caracteres. El formato usado es: |
|
Método que devuelve todas todas las posiciones posibles que puede haber en un juego posteriores a |
|
Método que devuelve el símbolo del jugador que resulta ganador a partir de |
|
Propiedad con el nombre de este jugador. |
|
Propiedad con el símbolo (o nombre si el símbolo no existe) de este jugador. |
|
Propiedad con la referencia al oponente de este jugador. Útil para obtener el nombre y símbolo del jugador contrario, por ejemplo: |
4.3. SuperGato
4.3.1. Reglas
Piezas y tablero: Este juego se juega en un tablero rectangular de n renglones por m columnas, donde 3 ≤ n ≤ 10, 3 ≤ m ≤ 10.
Para tirar: De manera similar al juego de gato, los jugadores alternan su turno colocando su símbolo (X o O) en cualquier localidad vacía del tablero.
Para ganar: El jugador que logre colocar su símbolo en tres localidades consecutivas (horizontal o verticalmente) gana. Si nadie ha ganado y el tablero está completamente lleno, entonces es un empate.
4.3.2. Clases disponibles
| Clase | Descripción |
|---|---|
|
Clase que representa un juego de SuperGato. Al crear una instancia de esta clase, es necesario indicar el número de renglones y columnas del tablero como tercer y cuarto argumento. |
|
Toda clase que represente un jugador del juego SuperGato debe heredar de esta clase. |
|
Jugador de SuperGato que tira de manera aleatoria. |
|
Jugador de SuperGato que tira con una estrategia. |
|
Jugador de SuperGato controlado a partir de una interfaz de usuario en modo texto. |
4.4. Orugas
4.4.1. Reglas
Piezas y tablero: Este juego se juega en un tablero rectangular de n renglones por m columnas, donde 4 ≤ n ≤ 10, 4 ≤ m ≤ 10. Inicialmente cada jugador ocupa una localidad del tablero (la cabeza de la oruga), determinada de manera aleatoria.
Para tirar: Cada jugador controla una oruga que crece rápidamente a partir de su cabeza. Durante el turno de un jugador, éste debe seleccionar una localidad contigua vacía en la que pueda crecer la cabeza de su oruga. La oruga puede crecer hacia la localidad de arriba, abajo, izquierda o derecha, mas no en diagonal. Es posible crecer saliéndose de una orilla del tablero y llegar a su correspondiente localidad opuesta.
Para ganar: Un jugador gana cuando su oponente ya no tenga una localidad donde crecer.
En el tablero, el primer jugador usa el símbolo B (blanco) como cabeza y b para el resto del cuerpo. El segundo jugador usa el símbolo N (negro) como cabeza y n para el resto del cuerpo.
4.4.2. Clases disponibles
| Clase | Descripción |
|---|---|
|
Clase que representa un juego de Orugas. Al crear una instancia de esta clase, es necesario indicar el número de renglones y columnas del tablero como tercer y cuarto argumento. |
|
Toda clase que represente un jugador del juego Orugas debe heredar de esta clase. |
|
Jugador de Orugas que tira de manera aleatoria. |
|
Jugador de Orugas controlado a partir de una interfaz de usuario en modo texto. |
5. Proyecto: Jugador estratégico para Orugas
Usando el framework Dagor, diseñen e implementen en Python 2.7 un jugador para el juego de Orugas que produzca tiros usando una o varias estrategias “inteligentes”.
El proyecto se entregará el día jueves 29 de septiembre antes de las 11:00 hrs. Cada equipo debe enviar el archivo con su proyecto a la cuenta del profesor Ariel Ortiz ariel.ortiz@itesm.mx con copia para el profesor Roberto Martínez rmroman@itesm.mx. El subject del correo debe ser: “Reto IA xxxxx”, donde xxxxx es el nombre de su equipo, todo en minúsculas.
La implementación de cada equipo competirá contra las implementaciones de los demás equipos en un torneo de estrategias cuyas reglas se describen a continuación.
5.1. Reglas del torneo de estrategias
-
Cada equipo entregará su implementación completa contenida en un solo archivo. El nombre del archivo debe ser el mismo que el nombre del equipo, todo con letras minúsculas, y con extensión
.py. Así mismo, el nombre de la clase que implementa el jugador estratégico debe tener de prefijoJugadorOrugasy de sufijo el nombre del equipo con su primer carácter en mayúscula. Por ejemplo, si el equipo se llamaanswer42, la clase correspondiente se debe llamarJugadorOrugasAnswer42y debe estar contenida en un archivo llamadoanswer42.py.La definición de la clase en cuestión debe ser el único código contenido en el archivo a entregar. Además de los métodos
heuristicaytira, se permite añadir a la clase métodos y variables de instancia auxiliares. -
El siguiente código muestra la manera en la que se debe poder utilizar el código elaborado por cada equipo:
Archivo: answer42_vs_aleatorio.pyfrom dagor import JuegoOrugas, JugadorOrugasAleatorio from answer42 import JugadorOrugasAnswer42 juego = JuegoOrugas( JugadorOrugasAnswer42('answer42'), JugadorOrugasAleatorio('RandomBoy'), 5, 8) juego.inicia(veces=100, delta_max=2) -
La clase desarrollada por cada equipo se enfrentará en un encuentro contra cada una de las clases de los otros equipos.
-
Cada encuentro consistirá de 100 juegos. Un equipo recibirá una cierta cantidad de puntos dependiendo del resultado:
-
3 puntos si ganó 51 juegos o más.
-
1 punto si ganó exactamente 50 juegos.
-
0 puntos si ganó 49 juegos o menos.
El equipo que junte más puntos obtiene el primer lugar del torneo, el siguiente equipo con más puntos obtiene el segundo lugar, y así sucesivamente. Existe la posibilidad de que ocurran empates.
-
-
El tamaño del tablero del juego será seleccionado por los profesores responsables del reto de manera arbitraria. Dicho tamaño será el mismo para todos los encuentros y se dará a conocer hasta el inicio del torneo.
-
Todos los encuentros se correrán desde la línea de comando. Las salidas de dichos encuentros serán almacenadas como archivos de texto y podrán ser consultadas por las partes interesadas.
-
Un equipo perderá automáticamente un encuentro en los siguientes casos:
-
Alguno de sus tiros tarda más de 2 segundos en completarse (tiempo medido por la computadora en la que se llevan a cabo los encuentros del torneo).
-
Si su código produce cualquier tipo de error a tiempo de ejecución, por ejemplo: intentar hacer un tiro en una posición inválida, realizar una división entre cero, usar un índice de arreglo fuera de rango, acceder a un atributo inexistente, etc.
-
-
Un equipo quedará descalificado de todo el torneo en los siguientes casos:
-
Si su código intenta hacer uso de recursos externos al programa: crear/borrar/leer/escribir archivos, crear procesos del sistema operativo, conectarse a Internet, etc.
-
Si su código contiene lógica mal intencionada que intente interferir con el flujo normal del juego, como por ejemplo: alterar propiedades privadas de cualquier objeto del juego, modificar la semilla del generador de números aleatorios, alterar el comportamiento de los métodos de cualquier clase distinta a la desarrollada por el equipo, etc.
Por favor pregunten a su profesor si tienen alguna duda sobre qué operaciones en su código pudieran provocar que su equipo quede descalificado del torneo.
-
-
Cualquier aspecto no tratado aquí será resuelto a criterio de los profesores responsables de este reto.
5.2. Resultados del torneo de estrategias
Los siguientes archivos tienen los resultados del torneo de estrategias celebrado el 29 de septiembre: