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.