Download - PFC Molino
-
ESCUELA TCNICA SUPERIOR DE
INGENIERA INFORMTICA
INGENIERA TCNICA EN INFORMTICA DE GESTIN
EL MOLINO
Realizado por
Emilio Cuenca Gmez
Dirigido por
Jos Ramn Portillo Fernndez
Departamento de Matemtica Aplicada 1
Sevilla, Junio 2012
-
Indice
Resumen ....................................................................................................................................................... 5
Agradecimientos ........................................................................................................................................... 7
1 Introduccin ............................................................................................................................................ 8
2 - Definicin de objetivos .......................................................................................................................... 11
3 - Anlisis de antecedentes y aporte realizado ......................................................................................... 13
4 - Anlisis temporal ................................................................................................................................... 17
5 Instalacin del entorno de trabajo........................................................................................................... 21
6 Anlisis de requisitos , diseo e implementacin .................................................................................... 25
7 - Pruebas .................................................................................................................................................. 43
8 Manual .................................................................................................................................................. 45
9 - Conclusiones y desarrollos futuros de futuro ........................................................................................ 49
-
Tanto los videojuegos como los juegos de mesa, desde hace ya unos aos, cubren las
necesidades de entretenimiento de casi cualquier miembro de una familia .Este
videojuego pretende unir tanto a jvenes como adultos gracias a que es un juego
clsico de mesa hecho para ordenador.
El molino es un videojuego de estrategia para PC. Es una idea que surge de mi aficin
al ajedrez, a los juegos de mesa y a los propios videojuegos.
El sistema creado abarcar todos los aspectos de la ingeniera del software, desde el
concepto del juego y los diseos del mismo hasta su implementacin final.
Es un titulo para cualquier edad, y un juego que lleva jugndose desde el Imperio
Romano. Espero que lo disfruten!
Resumen
Esta documentacin corresponde a un proyecto de final de carrera que consiste en la
creacin de un juego para pc basado en el juego de tablero Molino.
A lo largo de esta memoria se detallaremos su creacin partiendo desde cero de El
Molino , pues as llamaremos al juego , as como las clases que nos ayudarn tanto a
su lgica como a su presentacin.
-
Agradecimientos
En primer lugar quisiera agradecer a Jos Ramn Portillo la oportunidad que me ha
brindado de realizar este proyecto y a su departamento de matemtica aplicada I , al
poder realizarlo.
A mi familia, en especial a mis padres , mi esposa y mis hijos.
A todos los profesores que he tenido , que me han enseado muchas de las cosas que
se hasta ahora.
A todos esos amigos que me apoyaron durante la carrera.
Gracias a todos.
-
1 Introduccin
En este proyecto vamos a ver claramente como un juego de hace miles de aos puede
convertirse en un juego actual. Esto mismo se podra hacer con cualquier juego de
mesa. Y lo interesante de este juego es que lo haremos con uno tan clsico como es el
molino.
Qu es el Molino?
El juego del molino es un juego de estrategia abstracto de mesa para dos jugadores
originado en el Imperio
romano.
Historia
Segn R. C. Bell, el tablero de juego antes conocido inclua lneas diagonales y fue
"cortado en la cubierta de las losas en el templo Kurna en Egipto" c. 1400 a. C. Sin
embargo, Friedrich Berger dice que algunos de los diagramas en Kurna incluyen cruzas
coptas, por lo que los diagramas de la fecha de 1400 a. C. son "dudosos" y Berger
concluye, "ciertamente no pueden ser fechados".
Una de las ms antiguas menciones del juego se pueden encontrar en el Ars Amatoria
de Ovidio.En el libro III (c. 8 CE), despus de discutir sobre el Latrones, un juego de
tablero popular, Ovidio escribe:
Hay otro juego dividido en tantas partes como meses en el ao.
La tabla tiene tres piezas de cada lado, el ganador deber colocar
todas las piezas en una lnea recta. Es algo malo para una mujer
no saber cmo jugar, porque el amor a menudo aparece durante
el juego.
Berger cree que el juego era "probablemente bien conocido por los romanos", ya que
hay muchos tableros en edificios romanos, a pesar de que datarlos es imposible porque
los edificios "han sido fcilmente accesibles", desde que fueron construidos. Es posible
que los romanos se introdujeran en el juego a travs de las rutas comerciales, pero esta
hiptesis no puede ser probada.
Una ilustracin del siglo XIII en el Libro de los juegos del juego jugado con dados.
El juego lleg a su punto mximo de popularidad en la Inglaterra medieval. Tableros de
l se han encontrado grabados en los claustros en las catedrales inglesas de
Canterbury, Gloucester, Norwich, Salisbury y la Abada de Westminster. Estos tableros
usan agujeros, no lneas, para representar a los nueve espacios en el tablero -de ah el
nombre de "nueve hoyos"- y, formando una diagonal, no se gana el juego. Otro tablero
est tallado en la base de un pilar en la Catedral de Chester en Chester.
En la obra de Shakespeare del siglo XVI El sueo de una noche de verano, Titania
lamenta que ya no sea jugado: "The nine men's Morris is filled up with mud" ("El juego
del molino est lleno de barro") (A Midsummer Night's Dream, Acto II, Escena I).
-
Algunos autores dicen que el origen del juego es incierto. Se ha especulado que su
nombre puede estar relacionado con las danzas Morris, y por lo tanto a los moros, pero
de acuerdo a Daniel King, la palabra "morris" "no tiene nada que ver con la antigua
danza inglesa del mismo nombre. Proviene de la palabra latina merellus, lo que significa
una cuenta o una pieza del juego". King tambin toma nota de que el juego fue popular
entre los soldados romanos.
En algunos pases europeos, el diseo del tablero adquiri especial importancia como
smbolo de proteccin contra el mal, y "para los antiguos celtas, el tablero es sagrado:
en el centro colocan el Molino sagrado o Caldero, un smbolo de regeneracin, y
emanan de l, las cuatro direcciones cardinales, los cuatro elementos y los cuatro
vientos".
Porque Java?
Los motivos para programar para java son muy diversos, como por ejemplo, la
posibilidad de desarrollar aplicaciones que esten disponibles para millones de usuarios
en el mundo.
Por que es un lenguaje multiplataforma con el cual puede desarrollar programas
que se ejecuten sin problemas en sistemas operativos como Windows, Linux,
Mac , Unix , etc.
Por que permite crear programas que se ejecuten en los ms variados
dispositivos como computadoras, telfonos mviles, algunas consolas de juegos
y algunos electrodomsticos adems de en microcontroladores.
Por que es el nico lenguaje soportado por el 100% de los telfonos mviles y
handhelds.
Por que es uno de los lenguajes ms demandados por las empresas y mejor
remunerado.
Por que es el que presenta mejor perspectiva de crecimiento por su larga
trayectoria en comparacin con soluciones como .Net que adems de tener un
comportamiento errtico es una solucin propietaria.
Por que para programar en Java no debe comprar ningn programa o entorno
de desarrollo a diferencia de entornos propietarios como .Net. Java no es cdigo
libre pero permite que cualquiera utilice su JRE (maquina virtual) para que
desarrolle programas.
-
Por que Java implementa funciones se seguridad que son usadas por la
mayoras de las grandes empresas que realizan transacciones a travs de
Internet.
Por que java lleva ms de 20 aos en el mercado con lo cual hay cientos de
miles de programadores con los cuales puede comunicarse a travs de Internet
y consultar.
Por qu Jigloo SWT?
Jigloo es una librera de software libre para generar GUI en Java. Es un editor
WYSIWYG (What You See Is What You Get) lo cual nos ha facilitado bastante el
trabajo. Seguramente lo usaremos en futuros proyectos, ya que crear una interfaz
grafica con esta herramienta es verdaderamente fcil .
Porque esta integrado en Eclipse
Porque es de fcil uso , y hay abundante documentacin en su web oficial. Desde
una API a ejemplos de uso.
Porque es gratuito.
Porque es altamente customizable.
En conclusin, vamos a actualizar a las ltimas tecnologas un juego que data del imperio
romano, es algo que seguro que resulta apasionante!
-
2 - Definicin de objetivos
Este proyecto tiene como objetivo desarrollar desde cero el juego , para plataforma PC.
Como sus objetivos podramos definir dos grupos, los referentes a PC y los referentes al juego
en s.
El mundo de los videojuegos es cambiante. El objetivo es desarrollar un videojuego basado en
un juego de tablero es que aporte una aplicacin entretenida, gil, ligera y con un apartado
visual decente.
Como es un proyecto de fin de carrera, el apartado grfico ser lo menos cuidado( aunque
tambin lo estar) mientras que se le dar especial importancia al apartado lgico y de
desarrollo.
Procedemos con los primeros :
Usar el java para la generacin del tablero y sus grficos animados. Al ser un dispositivo
PC, todo lo que el usuario quiera hacer lo har de una manera grafica. La respuesta
ser inmediata y exacta. Para aportar agilidad a un sistema que depende de turnos y
puede llegar a ser esttico para el jugador. Esto se llevara a cabo usando Jigloo SWT
Programacin con una relativa eficiencia. Y digo relativa porque depende del PC y la
versin de Java en la que sean ejecutados. Lo importante del desarrollo es aportar
ideas nuevas e innovar, pero no se debe olvidar que la estructura y el cdigo deben ser
reutilizables, escalables y de fcil mantenimiento. Se debe buscar un equilibrio entre los
componentes del mismo para fomentar estos atributos. As pues debe ser una
programacin eficiente.
Y con los referentes al propio juego:
Implementar la lgica del juego, la cual definiremos ms adelante. De esta lgica , que
sern las reglas propiamente dichas del juego de tablero, que debern verse reflejadas
en el sistema de juego y en la programacin , para as poder jugar de una manera agil.
Implementar una buena IA, que pueda por ejemplo jugar la CPU contra si misma. Como
es un juego que va turno a turno, las acciones de la mquina dependern de cmo
estn dispuestas las fichas,de las fichas que tenga el oponente,de las fichas que uno
mismo tenga, entre otras.
Responder a la interactuacin del usuario y el tablero. Esto es algo muy importante ya
que se debe cuidar para que no hayan lags o comportamiento inapropiado.
-
Aplicar el algoritmo de alfabeta minimax. La necesidad de esto se debe a que la
computadora debe saber cul sera su siguiente movimiento optimo y cual ser el peor y
mejor movimiento del oponente.
Cuidar el aspecto del tablero. Que tenga un minimo de renderizacion o al menos que no
sea molesto a la vista o de difcil manejo.
Posibilidad de que se pudiera escalar para juego online. Esto es algo que podremos
hacer en un futuro, ya que seria interesante que por intranet o internet se jugaran
partidas online a este divertido juego de mesa.
En conclusin , hay que cuidar tanto la lgica como el aspecto del juego, para que asi
sea atractivo al usuario y no sea un impedimento a la hora de jugar, ya que al ser un
juego de mesa , de ser asi, podra elegir la versin real en lugar de esta alternativa
virtual .
-
3 - Anlisis de antecedentes y aporte realizado
Para Gnu/Linux :
Este es el que consideraremos mas importante, ya que ha implementado todos los modos del
molino, las versiones ms fciles y las ms difciles .
Aqu tenemos una imagen del mismo.
-
Para dispositivos mviles:
En este apartado cabe mencionar que no ha sido implementado nunca la variante del molino
caracol , aunque si del molino . Estos antecedentes podemos encontrarlos en el market , desde
mill, doublemill o juego del molino. Tambin se encuentra implementado en juegos reunidos. A
continuacin pondr una lista de estas aplicaciones :
https://play.google.com/store/apps/details?id=org.doublemill.client
https://play.google.com/store/apps/details?id=dalmax.games.turnBasedGames.nineMenSMorris
https://play.google.com/store/apps/details?id=johannes.reinhart
https://play.google.com/store/apps/details?id=cn.bluesky.mills
https://play.google.com/store/apps/details?id=com.appspot.zqt.zgzq
Como puede observarse , al ser un juego popular tiene antecedentes, y nuestra aportacin ser
una variante ms, que seguramente en un futuro ser aadida como una opcin de juego de
otra aplicacin. Esta variante mantiene la lgica , lo que cambia es el tablero sobre el que se
juega.
De estas aplicaciones solo analizaremos las gratuitas, por ser a las que ms acceso ha tenido
la gente.
Doublemill :
Tras analizar este juego lo primero que vemos como un pro es su men principal
, que nos da opcin a jugar contra otro jugador online .
Tambin observamos un tablero cuidado , es interesante seguir esta lnea en el
diseo, aunque yo apostar por un diseo mucho ms difano, inspirado en los
juegos de los aos 80 e inspirado en Tron, usando colores tipo Neon.
-
Por ultimo observamos que tiene unas opciones bastante amplias ,desde sonido
hasta dificultad , conectividad, etc.
Dalmax
Esta aplicacin parece menos profesional que la anterior, pero tambin tiene sus
pros.
Comencemos con su pantalla de inicio, para mi bastante austera y perfecta para
la aplicacin que busco.
-
Esta a mi entender es la pantalla mas interesante, ya que incorpora un
controlador de porcentaje de dificultad.
Nuestro aporte ser un juego multiplataforma, ya que se podr jugar tanto en Linux como en
Windows, al estar programado en Java .
Tambin que se trata simplemente del juego del molino , sin variantes, lo cual nos facilitara
como jugar, al no estar eligiendo entre muchas opciones como pasa en algunas de las
alternativas aqu descritas.
-
4 - Anlisis temporal
En los apartados anteriores hemos descrito todo el proceso que ha dado como
resultado la creacin de la aplicacin. Una vez cubierta la descripcin del proceso,
pasaremos a tratar en detalle la planificacin seguida para la realizacion de este
proyecto, as como un desglose de las labores mas importantes. Dicha tarea la
desarrollar a lo largo del captulo que nos ocupa en este instante.
Para comenzar con el analisis temporal, hemos de distinguir todas las etapas que me
han ocupado durante la elaboracin de este proyecto. Un desglose de estas etapas
ser:
1. Aprendizaje y documentacion sobre Java (Sobre todo parte grafica) y sobre los
algoritmos de IA.
Debemos ver como dibujar con java y adems documentarnos sobre la parte
matemtica del proyecto .
2. Creacin de la app.
Una vez adquiridos los conocimientos creamos la aplicacin.
3. Pruebas y testeo
Durante el desarrollo al ir incluyendo los requisitos que tenia, iba realizando
pruebas para ver si los alcanzaba.
Esta fase es una de las mas importantes y la que ms tiempo he dedicado
realmente.
4. Elaboracion de esta memoria
Durante esta etapa he escrito esta memoria.
-
Tarea Numero de horas
Planificacin 50 horas
Documentacin 100 horas
Implementacin 90 horas
Pruebas 40 horas
Memoria 64 horas
Total 344 horas
Planificacion :
Dado que el proyecto es bastante extenso , era necesario planificar.
En ella nos hemos armado de rotulador y pizarra y hemos estudiado de forma
cuidadosa como realizarlo, los objetivos que debamos alcanzar y las posibles
dificultades que nos encontraramos (sobre todo con el entorno grafico y la inteligencia
artificial)
Documentacion:
Al comienzo desconoca por completo tanto como implementar una IA y como modelar
algo grafico. Desconoca Jigloo SWT , asi que tras una larga etapa de formacin
realizando pequeos ejemplos con el mismo , aprendimos sobre la funcionalidad de
Jigloo SWT.
Implementacion:
Tras este periodo de formacin fuimos a lo realmente duro, largo y tedioso, la
implementacin . Y fue larga , tediosa y dura ya que la misma era probada en cada
funcionalidad aadida y cada hito dentro del desarrollo.
Pruebas :
Estas se realizaron durante la implementacin , para testear el correcto funcionamiento
y si saltaban ciertas excepciones.
Tambien se testeo la eficiencia de los algoritmos con la herramienta log4j.
Memoria :
Durante y tras el desarrollo de la aplicacin realizamos este documento que ahora
leemos.
-
4.1 Costes de desarrollo
En esta seccin estudiaremos detalladamente los costes que han supuesto
la creacin de la aplicacin . Comenzare diciendo que
no ha sido necesaria inversin alguna destinada a la adquisicin de dispositivos
especificos, hardware o software. Este hecho ha supuesto una gran
ventaja a la hora de elaborar el proyecto que nos ocupa, ya que los costes
se centraran nicamente en los campos de costes de personal y costes
indirectos. Los costes software han sido gratuitos, ya que he usado en la medida de lo posible
software libre, y las licencias de windows son educacionales.
En costes hardware he usado un Acer Aspire ----, con un coste de 650 .
Inversiones 0
Costes Software 0
Costes Hardware 650
Costes personal 2016
Costes indirectos 300
Total 2966
4.2 - Analisis de mercado
Llevo ya bastante tiempo viendo como los juegos de mesa resurgen y como estos tienen un
limitado sitio en los videojuegos. Nuestro objetivo ser por tanto brindar un juego para ese
publico amante de los juegos de mesa y de los videojuegos pausados y con un corte grafico
que no maree.
Nuestra idea de negocio tendra varias lneas , algunas de ellas en mi opinin innovadoras:
1 Venta del juego. Esta es la opcin clsica, vender el juego por un precio no abusivo,
aunque tal y como funciona la piratera a dia de hoy es la menos recomendada.
2 Sistema de donaciones . Esta es una opcin que se va dando cada vez mas.
Descargariamos el juego y si lo deseamos , hacemos una donacin . Con este sistema
podramos poner un sistema de recopensa que si se llega por ejemplo a un numero de
donaciones se aade funcionalidad.
3 Organizacin de torneos. Organizariamos un torneo del videojuego en una ciudad con una
inscripcin por un precio.
-
4 Publicidad : Integrada en el programa y pagando para quitarla y sus variantes.
Esto son slo algunas de las opciones que podemos tener en cuenta, realmente el xito o
fracaso de un juego depende en gran medida de la viralidad que se consiga mediante Intenet y
las redes sociales, que cada vez ms representan un medio de distribucin de publicidad para
las empresas que no pueden permitirse grandes anuncios o que no tengan un legado que se
remonte a tantos aos atrs.
4.3 Software Utilizado
En esta seccin vemos de las herramientas utilizadas durante el desarrollo
de El Molino. Para cada herramienta se ofrece una pequea descripcin de sus
funcionalidades y se adjuntan las razones por las cuales ha sido elegida para el desarrollo
frente a sus competidoras.
Eclipse:
Es un Entorno Integrado de Desarrollo, del ingls Integrated Development Environment (ide), para todo tipo de aplicaciones libres, inicialmente desarrollado por IBM, y actualmente gestionado por la Fundacin Eclipse. Herramienta para el programador desarrollada principalmente para el desarrollo de aplicaciones Java, es posible aadirle nuevas funcionalidades al editor, a travs de nuevos mdulos (plugins), para programar en otros lenguajes de programacin adems de Java como C/C++, PHP, Python, Ruby, Cobol, etc. Es adems el entorno ms utilizado por los desarrolladores de aplicaciones Java, por esto ha sido elegido para la realizacin de este proyecto.
-
5 Instalacin del entorno de trabajo
En este manual vamos a tratar de explicar como instalar eclipse e integrarle el modulo
de Jigloo SWT.
5.1 Requisitos del sistema
Para desarrollar aplicaciones en Java usando las herramientas que aporta eclipse , es
necesario disponer del siguiente software en nuestro pc .
Sistema operativo
Windows XP (32-bit), Vista (32 o 64-bit), o Windows 7 (32 o
64-bit)
Mac OS X 10.5.8 or superior (x86 s_olo)
Linux (probado en Ubuntu Linux, Lucid Lynx)
En Ubuntu Linux, version 8.04 o superior.
Entorno de desarrollo: Eclipse ide
Eclipse 3.5 (Galileo) o superior.
Eclipse JDT plugin.
Jigloo SWT
JDK 5 or JDK 6 (JRE no es su_ciente).
No compatible con Gnu Compiler para Java (gcj).
Nosotros trabajaremos con Windows 7 y el entorno de desarrollo Eclipse Galileo.
-
5.2 Instalacin del entorno de desarrollo
Aunque la instalacin del IDE no forma parte del proyecto vamos a proceder a su instalacin, que es fcilmente abordable desde su propia web. En la seccin \Download", se elige la versin deseada, que en nuestro caso ser Eclipse IDE for Java Developers para Windows 32 bits, con un tamao de 128mb. Una vez descargado, basta descomprimir y ejecutar \eclipse.exe"para comenzar a usar la aplicacin.
5.3 Instalacin de Jigloo usando el Eclipses Update Manager Tendrs que usar el Update Manager en Eclipse para descargar e instalar Jigloo, brelo (Help -> Software Updates -> Find and Install).
-
Entonces elige la opcin "Search for new features to install" y damos a "Next".
En la siguiente pagina le damos a "New Remote site" y un dialogo aparecer.
Introducimos "Jigloo" por "Name" y "http://cloudgarden.com/update-site" por "Url".
-
Aceptamos la licencia y listo.
-
6 Anlisis de requisitos , diseo e implementacin
Una vez que ya tenemos preparado nuestro entorno de trabajo y nos hemos familiarizado con
Jigloo SWT, podemos empezar con el desarrollo de nuestra aplicacin. Adems del estudio de
Jigloo SWT, tambin se han desarrollado algunas aplicaciones de prueba para irnos
familiarizando con el entorno de programacin que este ofrece y entender el funcionamiento de
diversas funcionalidades de Jigloo SWT que necesitamos para poder realizar nuestra
aplicacin.
Ahora pasaremos a explicar la realizacin de nuestra aplicacin dividindola en tres apartados.
Primeramente pasaremos a desglosar el anlisis de requisitos necesarios que hemos necesitado para llevar a cabo la realizacin del proyecto. Desde cuales son las tecnologas necesarias que hemos utilizado durante la etapa de desarrollo hasta los conocimientos que hemos tenido que ampliar para combinar estas tecnologas y llegar al buen funcionamiento de la aplicacin. Seguidamente describiremos el diseo de nuestra aplicacin, en el se analizara la estructura elegida para nuestro sistema, justificndola y explicando la relacin de cada clase con los mdulos anteriormente expuestos. Tras una fase terica y otra terico-prctica, pasaremos a la prctica, propiamente dicha: el desarrollo de la aplicacin. Sera entonces cuando se comentara con ms detalle el cdigo de la aplicacin, ahondando en las caractersticas propias de Java y Jigloo SWT, pudiendo afianzar los conocimientos anteriormente expuestos. 6.1 Anlisis de requisitos
En esta seccin analizaremos todos los requisitos del sistema que vamos a construir.
Definiremos las reglas del juego.
Los objetivos sern :
Describir los elementos del sistema con un lenguaje mas tcnico para entender la
aplicacin .
Modelado mediante UML 2.0
Modelado de los casos de uso para ver la funcionalidad.
Problemas y errores cometidos.
6.1.1 Estudio de elementos que componen el sistema
Aqu veremos las caractersticas del tablero, el juego , las reglas , los mtodos
matemticos utilizados .
Al ser un juego de mesa todos los elementos matemticos son muy importantes, sobre
todo para la IA.
Todos los elementos sern descritos en esta seccin .
-
6.1.1.1 Reglas de juego
Reglas
Cada jugador dispone de nueve piezas, u "hombres", que se mueven en el
tablero entre veinticuatro intersecciones.
El objetivo del juego es dejar al oponente con menos de tres piezas o sin
movimiento posible.
Colocando las piezas
El juego comienza con un tablero vaco. Los jugadores se turnan para
colocar sus piezas en las intersecciones vacas. Si un jugador es capaz
de formar una fila de tres piezas a lo largo de una de las lneas del
tablero, tiene un "molino" y puede eliminar una de las piezas de su
oponente en el tablero; las piezas quitadas no podrn ser colocadas de
nuevo. Los jugadores deben eliminar cualquier otra pieza antes de
eliminar una pieza de un molino formado. Una vez que todas las
dieciocho piezas se han colocado, los jugadores se turnan moviendo.
Movimiento de las piezas
Para moverse, el jugador desliza una de sus piezas a lo largo de una
lnea en el tablero a una interseccin vaca adyacente. Si no puede
hacerlo, ha perdido el juego.
Al igual que en la etapa de colocacin, un jugador que coloca tres de sus piezas
en lnea en el tablero tiene una lnea
de molino y puede eliminar una de las piezas de su oponente, evitando la
extraccin de piezas en los molinos si es
posible.
Cualquier jugador que es reducido a dos piezas no es capaz de eliminar ms
piezas del oponente y, por tanto, pierde
la partida.
6.1.1.2 Sistemas de bsqueda y base matemtica para resolver el problema y la IA
Nuestro proyecto se basa en varias referencias matemticas, que explicaremos
a continuacin :
Minimax
En teora de juegos, Minimax es un mtodo de decisin para minimizar la
prdida mxima esperada en juegos con adversario y con informacin perfecta.
Minimax es un algoritmo recursivo.
-
El funcionamiento de Minimax puede resumirse como elegir el mejor movimiento
para ti mismo suponiendo que tu contrincante escoger el peor para ti.
Teorema :
John von Neumann es el creador del teorema minimax, quien dio la siguiente
nocin de lo que era un juego:
"Un juego es una situacin conflictiva en la que uno debe tomar una decisin
sabiendo que los dems tambin toman decisiones, y que el resultado del
conflicto se determina, de algn modo, a partir de todas las decisiones
realizadas."
Tambin afirm que:
"Siempre existe una forma racional de actuar en juegos de dos participantes, si
los intereses que los gobiernan son completamente opuestos."
La demostracin a esa afirmacin se llama Teora Minimax y surge en 1926.
Este teorema establece que en los juegos bipersonales de suma cero, donde
cada jugador conoce de antemano la estrategia de su oponente y sus
consecuencias, existe una estrategia que permite a ambos jugadores minimizar
la prdida mxima esperada. En particular, cuando se examina cada posible
estrategia, un jugador debe considerar todas las respuestas posibles del jugador
adversario y la prdida mxima que puede acarrear. El jugador juega, entonces,
con la estrategia que resulta en la minimizacin de su mxima prdida. Tal
estrategia es llamada ptima para ambos jugadores slo en caso de que sus
minimaxes sean iguales (en valor absoluto) y contrarios (en signo). Si el valor
comn es cero el juego se convierte en un sinsentido.
En los juegos de suma no nula, existe tanto la estrategia Minimax como la
Maximin. La primera intenta minimizar la ganancia el rival, o sea busca que el
rival tenga el peor resultado. La segunda intenta maximizar la ganancia propia, o
sea busca que el jugador obtenga el mejor resultado.
Algoritmo :
Pasos del algoritmo Minimax:
Generacin del rbol de juego. Se generarn todos los nodos hasta llegar a un
estado terminal.
Clculo de los valores de la funcin de utilidad para cada nodo terminal.
Calcular el valor de los nodos superiores a partir del valor de los inferiores.
Segn nivel si es MAX o MIN se elegirn los valores mnimos y mximos
representando los movimientos del jugador y del oponente, de ah el nombre de
Minimax.
Elegir la jugada valorando los valores que han llegado al nivel superior.
El algoritmo explorar los nodos del rbol asignndoles un valor numrico
mediante una funcin de evaluacin, empezando por los nodos terminales y
-
subiendo hacia la raz. La funcin de utilidad definir lo buena que es la posicin
para un jugador cuando la alcanza. En el caso del ajedrez los posibles valores
son (+1,0,-1) que se corresponden con ganar, empatar y perder
respectivamente. En el caso del backgammon los posibles valores tendrn un
rango de [+192,-192], correspondindose con el valor de las fichas. Para cada
juego pueden ser diferentes.
Si Minimax se enfrenta con el dilema del prisionero escoger siempre la opcin
con la cual maximiza su resultado suponiendo que el contrincante intenta
minimizarlo y hacernos perder.
Minimax en teora de decisiones estticas
Donde la funcin de riesgo es R() y las otras dos variables son estimadores.
Poda alfa-beta
La poda alfa beta es una tcnica de bsqueda que reduce el nmero de nodos
evaluados en un rbol de juego por el algoritmo Minimax. Se trata de una tcnica
muy utilizada en programas de juegos entre adversarios como el ajedrez, el tres
en raya o el Go.
Entre los pioneros en el uso de esta tcnica encontramos a Arthur Samuel, D.J
Edwards y T.P. Hart, Alan Kotok, Alexander Brudno , Donald Knuth y Ronald W.
Moore
El problema de la bsqueda Minimax es que el nmero de estados a explorar es
exponencial al nmero de movimientos. Partiendo de este hecho, la tcnica de
-
poda alfa-beta trata de eliminar partes grandes del rbol, aplicndolo a un rbol
Minimax estndar, de forma que se devuelva el mismo movimiento que
devolvera este, gracias a que la poda de dichas ramas no influye en la decisin
final.
Algoritmo
La bsqueda minimax es primero en profundidad, por ello en cualquier momento
slo se deben considerar los nodos a lo largo de un camino en el rbol.
La poda alfa-beta toma dicho nombre de la utilizacin de dos parmetros que
describen los lmites sobre los valores hacia atrs que aparecen a lo largo de
cada camino.
es el valor de la mejor opcin hasta el momento a lo largo del camino para
MAX, esto implicar por lo tanto la eleccin del valor ms alto
es el valor de la mejor opcin hasta el momento a lo largo del camino para
MIN, esto implicar por lo tanto la eleccin del valor ms bajo.
Esta bsqueda alfa-beta va actualizando el valor de los parmetros segn se
recorre el rbol. El mtodo realizar la poda de las ramas restantes cuando el
valor actual que se est examinando sea peor que el valor actual de o para
MAX o MIN, respectivamente.
El desarrollo del algoritmo en pseudocdigo ser el siguiente:
funcin alfabeta(nodo, profundidad, , )
si nodo es un nodo terminal o profundidad = 0
devolver el valor heurstico del nodo
para cada hijo de nodo
:= max(, -alfabeta(hijo, profundidad-1, -, -))
si
break
devolver
(* Llamada inicial *)
alfabeta(origen, profundidad, -infinito, +infinito)
Eficacia
La eficacia de la poda alfabeta depende del orden en el que se examinan los
sucesores, es decir, el algoritmo se comportar de forma ms eficiente si
examinamos primero los sucesores que probablemente sern los mejores.
Si esto pudiera hacerse, implicara que alfa-beta slo tendra que
examinar en lugar de los de Minimax. Esto implica que
el factor de ramificacin eficaz ser de en lugar de . En otras palabras,
-
alfa-beta podra mirar hacia delante aproximadamente dos veces ms que
Minimax en la misma cantidad de tiempo.
Si se recurre a una ordenacin aleatoria en lugar de primero el mejor en los
sucesores, el nmero aproximado de nodos examinados sera
de para un valor moderado de . En ajedrez se puede realizar una
funcin de ordenacin sencilla teniendo en cuenta primero capturas de fichas,
despus amenazas, movimientos hacia delante y por ltimo movimientos hacia
detrs, esto conseguira aproximadamente un factor de dos del
resultado del mejor caso. La inclusin de esquemas dinmicos para
ordenar movimientos, basados en experiencia podran acercarse al lmite
terico.
Ejemplo:
Tablas LRU (Least Receintly Used)
Este algoritmo difiere del de 'No usada recientemente' en el hecho de que aquel
slo se fija en el intervalo de tiempo desde que se pusieron en 0 los bits de
referencia de las pginas, mientras que el algoritmo de 'Menos usada
recientemente' intenta proveer un comportamiento casi ptimo mediante la
observacin de las pginas que menos fueron usadas recientemente. Este tipo
de pginas, estadsticamente son las que tienen menor probabilidad de ser
usadas nuevamente.
Aunque este algoritmo provee un buen comportamiento en teora, es caro de
implementar, en cuanto a recursos consumidos. Hay varias implementaciones
que intentan mantener bajo el costo y lograr un rendimiento considerable. Un
mtodo consiste en tener una lista enlazada y ordenada de todas las pginas en
memoria. En el final de la lista est la pgina menos usada recientemente, y al
principio la ms usada recientemente. El costo alto de este mtodo es porque
-
cada vez que se referencia una pgina debe ser movida en la lista, algo que
consume mucho tiempo. Otra forma, que requiere soporte de hardware, consiste
en tener un contador que es incrementado en cada instruccin del CPU. Cada
vez que una pgina es accedida, gana el nmero del contador en ese momento.
Cuando una pgina debe ser retirada de memoria, simplemente hay que buscar
cul es la que tiene el menor nmero, que es la que fue usada hace ms tiempo.
En el presente no existen contadores tan grandes para permitir esto. Debido al
alto costo del LRU, se proponen algoritmos similares, pero que permiten
implementaciones menos costosas, como los que siguen.
6.2 Diseo
Tras el Anlisis de Requisitos, ya podemos realizar el diseo de nuestro sistema, distribuyendo las funcionalidades previstas de la forma ms eficiente que hemos encontrado. Eficiente en el sentido que facilitara el entendimiento y su mantenimiento. Nuestro proyecto esta organizado en 9 paquetes. El primer paquete es el destinado a la Inteligencia Artificial , este paquete esta en com.molino.ai. En este paquete incluiremos la implementacin de la bsqueda MinMax, el algoritmo de poda, la tabla de transposicin LRU. Adems deberemos incluir otras clases que nos servirn de apoyo sobre las implementaciones anteriormente citadas. El segundo paquete es el destinado a almacenar caches de la tabla LRU , se llama com.molino.cache. Es importante ya que sin ella no se podra utilizar la tabla LRU, ya que esta implementacin usa esta misma cache. El tercer paquete es com.molino.mills , denominado asi para no repetir molino.molino y tambin para hacer referencia a otro de los nombres de este juego. En el se iniciara todo el juego, desde el tablero, a el entorno grafico , al motor, etc etc. Es por decirlo asi nuestra funcin main. El cuarto paquete es com.molino.mills.agent. En esta clase se analizara el tablero, se implementara el jugador de la computadora y se implementera la bsqueda de los posibles molinos. El quinto paquete es com.molino.mills.gui . Aqu como su nombre indica se implementara la GUI (del ingls Graphic User Interface) , que lleva desde el tablero, a la lista de movimientos, las piezas , etc. El sexto paquete es com.molino.mills.model. Aqu lo que iremos haciendo es montar la estructura de juego, los listener , las utilidades del tablero, etc. Es decir, en este paquete montaremos el esqueleto de funcionalidad sobre la GUI del juego de mesa. Es importante resear que no hay solapamiento entre esta y los siguientes paquetes , ya que al separar en paquetes el esqueleto y las implementaciones de funcionalidad aumentamos su eficiencia y podramos si quisiramos ampliarlo a otro tipo de tableros.
-
El sptimo paquete es com.molino.mills.model.event . Aqu implementaremos los eventos del juego, como el nuevo juego, el juego terminado , errores de movimiento, etc Este paquete da soporte a algo tan importante como son los eventos dentro del juego, asi podremos capturar cuando se inicia, cuando termina, cuando hay un movimiento, un error. El octavo paquete es com.molino.mills.model.move . Aqu implementaremos los movimientos dentro del juego. Bsicamente capturaremos el movimiento , definiremos como se hace un movimiento de un lugar a otro , el movimiento de posicionamiento , ya sea de colocar una ficha o que venga de otro lugar. El noveno paquete es com.molino.mills.model.pos . Este paquete est estrechamente relacionado con los tres anteriores. Este paquete contendr las clases encargadas de controlar los movimientos de las fichas, de colocarlas en el tablero, de decir si una posicin es ilegal, etc. Hasta aqu todos los paquetes , en los que queda definida toda la estructura del juego desde el tablero ,pasando por la inteligencia artificial hasta las excepciones de movimiento. A continuacin y gracias a una herramienta online, mostraremos como seria nuestro caso de uso.
-
6.3 Como lo hemos implementado?
Lo primero que hemos creado ha sido un paquete con todo lo referente a la Inteligencia
Artificial. Este se llama com.molino.ai.
Esta es su estructura :
Veremos el cdigo de algunas de estas clases, el que creo que nos ser mas
aclaratorio.
No pondremos todo el cdigo , ya que para eso adjuntamos el mismo, pero si parte de
el.
-
Tambien os dire que el cdigo lo he escrito en ingls , en parte porque jigloo genera
clases y procedimientos en ingls y en parte por costumbre como programador.
Este es el cdigo para elegir el mximo, para elegir el mnimo es casi idntico.
protected SearchNode chooseMax(Iterable successors, int
depth, int mybest, int herbest)
{
SearchNode best = new SearchNode(mybest);
if ( interruptRequested ) return best;
Iterable opponentSuccessors;
SearchNode attempt;
for (SearchNode successor : successors)
{
attempt = transpositionTable.get(successor);
if (attempt == null)
{
opponentSuccessors = generateSuccessors(successor);
if ( depth > 1 )
attempt = chooseMin(opponentSuccessors, depth-1, mybest,
herbest);
else
attempt = chooseMax(opponentSuccessors, mybest, herbest);
if (attempt.state != null)
transpositionTable.put(attempt);
}
if ( attempt.score > best.score )
{
best = successor;
best.score = attempt.score;
}
if ( best.score > herbest )
break;
}
return best;
Y este es el de la tabla LRU :
public class LRUTranspositionTable implements
TranspositionTable
{
/**
* @uml.property name="cache"
* @uml.associationEnd
*/
-
private LRUCache cache;
public LRUTranspositionTable()
{
reset();
}
public void reset()
{
cache = new LRUCache(30000);
}
public void put(SearchNode node)
{
if ( cache.get(node)==null )
cache.put(node, node);
}
public SearchNode get(SearchNode node)
{
return cache.get(node);
}
}
6.3.1 Estructura del programa
Aqui tenemos todos los paquetes modelados con UML
Vamos a verlo uno a uno por dentro y a mostrar el cdigo mas reseable de cada uno.
-
Cache
De esta clase poco cdigo pondremos, pero resear que es la que implementa la tabla
LRU , algo indispensable para nuestro juego, ya que mediante ella se mueve casi toda
la IA.
-
Molino
Esta es la clase central , una de las mas importantes , en esta esta lo que se podra
llamar el proceso de juego, lo que comnmente se define en los casos de uso.
Su diagrama UML es simple.
En esta clase hemos usado parte de Jigloo, para generar toda la parte grafica. Tambien
se iniciara el juego y sus opciones.
-
Agent
Esta clase es la encargada de evaluar el tablero y ver que opciones tiene la
computadora.
-
GUI
Aunque parezca una de las clases ms complicada, realmente esta clase no lo es, se encarga
de pintar y dar parte de la funcionalidad al tablero.
-
Model
Esta clase es la encargada de validar los movimientos sobre el tablero.
Event
Esta clase es la encargada de capturar los eventos propios del juego.
-
Move
Esta clase es la encargada de validar y capturar los movimientos de la ficha sobre el tablero.
-
Pos
Se encarga de validar si una posicin es correcta.
6.3.1 Problemas encontrados
A la hora de desarrollar esta aplicacin , nos encontramos con una serie de problemas:
No conseguamos mostrar el tablero adecuadamente, esto lo solucionamos
redimensionando el mismo.
Hubo un problema con XYBoardposition por lo que implementamos tambin
ColRowBoardPosition y asi solventamos este problema. (Era referente a posicionar las
fichas)
En un principio no sabamos bien como implementar la IA , pero buscando encontramos
el proyecto antes reseado para GNU/Linux y nos aclaro bastante.
-
7 - Pruebas
Una vez terminamos el desarrollo de la aplicacin, fue necesario llevar a cabo una serie de
pruebas que aunque no garantizan que funcione al cien por cien , si nos indican que tal y como
las supervisamos tuvo un anlisis positivo.
Era imposible desarrollar todas las pruebas posibles para ver absolutamente todo sobre el
programa, adems que esto hara demasiado largo el periodo de pruebas y seria algo
excesivamente costoso.
No solo comprobamos que la aplicacin funciona, si no que adems miramos si funciona cada
parte del mismo.
7.1 Pruebas unitarias
Tanto para estas como para las pruebas de integracin usamos el software log4j.
En las pruebas unitarias hemos evaluado si hay errores en Game ,en ComputerPlayer y en
BoardAnalyser.
Para ello primero hemos modificado el archivo log4j.properties primero en nivel ERROR ,
despus en WARN y por ultimo en DEBUG e INFO
Estas pruebas han sido satisfactorias tanto en que no hay errores en cuanto a eficiencia del
mismo.
Consultando varias fuentes es lgico que a veces el programa tarde bastante en encontrar un
movimiento debido a la complejidad computacional de la decisin.
7.2 Pruebas de integracin
Para estas hemos probado entre dos versiones y entornos diferentes.
Primero hemos probado en Windows 7 nuestra aplicacin, usando tambin las anteriores
propiedades de log4j , obteniendo resultados satisfactorios.
Tras esto hemos comprobado sobre Linux Ubuntu 9.10, usando tambin las pruebas de log4j ,
obteniendo unos resultados similares a Windows.
Esto nos da como conclusin que hemos conseguido algo que pretendamos, que era la
multiplataforma
-
Sobre que versiones de java soporta , hemos comprobado que cualquiera a partir de la 1.3, ya
que Jigloo funciona sobre las mismas.
Sobre conclusin de las pruebas, aunque tediosas, son necesarias y Log4j ha sido un
descubrimiento y algo que ha agilizado bastante las mismas.
-
8 Manual
8.1 Requisitos
Tras revisar la web de Java, cualquier equipo actual permite ejecutar Java, y por tanto
nuestro software.
8.2 Ejecucion
Primero veamos como ejecutar nuestro juego.
Para ello vamos a la consola de Windows y escribimos :
java jar molino.jar
Con esto arrancara el juego.
Tras esto aperecera esto
Seleccionamos lo que deseamos , seleccionando ahora el color
Seleccionamos de nuevo para el jugador 2
-
Ahora seleccionamos el limite de tiempo
Y tras esto y con las reglas descritas en este documento, podremos jugar!
-
Resumen de reglas :
El juego Molino de Nueve se juega con dos participantes, usando un tablero para jugar. Cada
jugador dispone de nueve piezas, que se mueven en el tablero entre veinticuatro
intersecciones. El objetivo del juego es dejar al oponente con menos de tres piezas o sin
movimiento posible.
Jugadores - 2
Piezas - 18 piezas siendo 9 blancas y 9 negras.
Tablero - tablero con 24 casillas interligadas horizontal y verticalmente.
Objetivo - Dejar el adversario con 2 piezas en el tablero o dejarlo sin movimientos.
El Juego
El juego consiste en tres partes principales:
Colocando las piezas: Esta es la fase inicial del juego donde cada jugador coloca una
pieza de cada vez alternando entre jugadores, si uno de los jugadores consigue formar
una fila horizontal o vertical con tres piezas tendr un "molino", y podr eliminar una
pieza de su oponente en el tablero.
Moviendo las piezas: Esta fase se inicia cuando ambos jugadores hayan colocado sus
nueve piezas en juego. Consiste en mover tus piezas a lo largo de una de las lneas del
tablero para otra casilla adyacente. Caso uno de los jugadores tenga slo 3 piezas en
juego, puede "volar" con sus piezas, pudiendo mover para cualquier casilla que no est
ocupada por una pieza del adversario.
Eliminar piezas adversarias: Las piezas quitadas no podrn ser colocadas de nuevo.
Los jugadores deben eliminar cualquier otra pieza antes de eliminar una pieza de un
molino formado, es decir no se puede retirar una pieza del adversario que forma parte
de su molino, a menos que no exista otra pieza para retirar.
Final de la Partida
El juego termina cuando surge uma de las siguientes situaciones posibles:
Si un jugador reduce las piezas de su adversario a 2.
Si un jugador deja a su adversario sin ninguna jugada vlida. Si tu adversario tiene
solamente 3 piezas en juego, l no podr ser "trancado".
Cuando ambos jugadores estuvieran con 3 piezas en juego y a partir de este momento,
si en 10 jugadas no hubiera vencedor, el juego finalizar y ser declarado empate.
-
9 - Conclusiones y desarrollos futuros de futuro
9.1 Conclusiones
Tras terminar este proyecto de fin de carrera , espero que al igual que yo, nos encontremos con
una valoracin muy positiva del mismo.
Nuestro objetivo principal, que era aprender todo lo posible sobre el desarrollo de un
videojuego basado en un juego de mesa clsico , y por extensin, aprender ms sobre Java, en
especial sobre el tratamiento de hilos y Jigloo SWT.
Todo lo anterior ha sido posible y la aceptacin del pblico ha sido positiva, sobre todo al ver
que puede ejecutarse en casi cualquier pc.
Este desarrollo me ha aclarado las ideas en cuanto a una base para , de cara al futuro , poder
hacer unos desarrollos mas rpidos y agiles .
Como ya saba , podemos desarrollar una aplicacin o videojuego desde cero con aplicaciones
libres, abaratando por tanto un coste que en otras ramas no es posible.
Algo muy interesante ha sido observar que desarrollar inteligencia artificial puede no ser tan
complicado para un videojuego tal y como pensaba antes de empezar el proyecto, para mi esto
antes era como un imposible, crea que deba ser mucho mas complicado. Pero como todo
tiene sus niveles.
En definitiva, he disfrutado , he aprendido e investigado sobre dos temas que me apasionan
pero que desconoca en esta profundidad. Adems he encontrado un sector en el que
seguramente me gustara trabajar.
9.2 Desarrollos futuros
Este proyecto podra ser distribuido digitalmente, podran desarrollarse torneos sobre el mismo.
En un futuro podra implementarse una capa para el juego online, ya que su arquitectura as lo
permite. Tambin me gustara portarlo a Android con algunas variantes para que pueda jugarse
a todos los tipos y similares al molino.
Y paralelamente a esto, sera interesante crear un motor para juegos de mesa basado en
Jigloo. Y tambin para las reglas. En un principio tengo pensado que sea solo para los juegos
similares al molino.
En conclusin, es un abanico de posibilidades bastante amplio en el que me gustara
profundizar.