Plataforma de Juegos Dominó

Plataforma de Juegos ­ Dominó
Miguel Fonseca Martínez
Manuel Regidor Serrano
1. Introducción
Esta práctica consiste en la implementación de un jugador de Dominó, y tiene como objetivo, aparte de
conseguir una funcionalidad completa, conseguir que esté jugador juegue de manera lo más inteligente
posible, gracias a algoritmos de IA.
Además, juegan siempre cuatro jugadores, y por tanto se reparten todas las fichas, gracias a esto, se ha
simplificado mucho la programación.
Sin embargo, además de este jugador inteligente, se implementará un jugador aleatorio “dummy”, y por
este último se comenzará
2. Jugador Aleatorio
Este jugador es un jugador de dominó que juega eligiendo las fichas de manera completamente aleatoria.
En primer lugar, se empezará explicando como se crea este jugador, mediante su constructor y sus
atributos.
El jugador básico de dominó MyPlayer tiene como atributos el número de jugadores del juego (4 siempre),
el jugador actual ( Numerados del 0 al 3) y el estado inicial, por el que se pasarán las fichas de la mano de
dicho jugador.
Otros atributos que tiene cada jugador, es el tablero de juego, el número de fichas en la mano de cada
jugador y la ronda en la que se encuentre la partida.
En este constructor se inicializa el tablero de juego, se “traduce” a Fichas la mano del jugador y se
establecen a 7 las fichas de cada jugador
Una vez, explicado cómo se construye este jugador, el algoritmo de juego es muy simple:
1. NextMove: Se elige la ficha a colocar, se quita de la mano y se indica mediante un String del
tipo “343”. En el jugador aleatorio, esta ficha es aleatoria, siempre comprobando que se puede colocar en el
tablero (Es decir, los extremos de la mesa del dominó coincide con alguna de las fichas de la mano).
2. ValidMove: Se comprueba por los demás jugadores que la ficha es correcta, es el caso de este
jugador, simplemente comprueba que la longitud del String de la Ficha sea menor que 4 (En caso contrario,
movimiento inválido)
3. DoMove: Se realiza el movimiento, es decir, se coloca la ficha en el tablero, y además,
actualiza los valores de las fichas en la mano de ese jugador en todos los jugadores.
4. Draw: Se comprueba si ha habido un empate, en el caso del dominó, hay empate siempre que
se cierre el tablero (Los extremos del tablero son el mismo número)
5. Winner: Se comprueba si hay un ganador, para ello, se comprueban las fichas en la mano del
jugador actual, si es cero, ese jugador ha ganado y los demás lo confirman. En el caso de que no hay
ganador, se vuelve a 1.
3. Jugador MiniMax con Variante Poda Alfa­Beta
El algoritmo de juego en este jugador “inteligente” es el mismo que el jugador “dummy”, es más, en el
código, la clase MyPlayerMinimax hereda de MyPlayer y reutiliza todos los métodos salvo nextMove.
Este ultimo metodo es el encargado de seleccionar la ficha de juego que se va a poner en el tablero, y que
se seleccionará de manera inteligente.
Para esta selección se ha utilizado el algoritmo Minimax con la poda Alfa­Beta.
Este algoritmo es un algoritmo de decisión basado en árbol de la jugada óptima para minimizar la pérdida
máxima esperada contra un adversario, y con toda la información del juego. La variante Alfa­Beta consiste
en reducir las ramas que genera el algoritmo Minimax, de tal manera, que se mejora la eficiencia y la
velocidad del mismo, ya que poda la rama cuando se comprueba que no se puede mejorar el valor
heurístico actual.
Para la implementación de este algoritmo, se ha utilizado el Arbol nativo de Java (DefaultTreeModel),
que se encuentra en la librería javax.Swing. (Ya que se utiliza para implementar los menús extensibles en
Java), y en principio, con una profundidad de cuatro (Ya que una profundidad mayor de árbol, ralentiza
mucho el sistema).
Además, al contrario que otras implementaciones, en el caso de nuestra implementación, se genera en
primer lugar el árbol completo hasta la profundidad 4 y a continuación, se recorre podando y seleccionando.
Por último, señalar que el valor heurístico viene determinado por la siguiente función:
f(n) = 5*(valor_izdo_ficha + valor_dcho_ficha);
En el caso que la ficha sea de valor doble, se multiplica por 10, en lugar de multiplicar por 5 en la función
anterior.
El pseudocódigo de este algoritmo (Fuente Wikipedia), es el siguiente:
función alfabeta(nodo, profundidad, α, β, jugadorMaximizador)
si nodo es un nodo terminal o profundidad = 0
devolver el valor heurístico del nodo
si jugadorMaximizador
para cada hijo de nodo
α := max(α, -alfabeta(hijo, profundidad-1, -β, -α, FALSE))
si β≤α
break (* poda β *)
devolver α
si no
para cada hijo de nodo
β := min(α, -alfabeta(hijo, profundidad-1, -β, -α, TRUE))
si β≤α
break (* poda α *)
devolver β
(* Llamada inicial *)
alfabeta(origen, profundidad, -infinito, +infinito, TRUE)