tictac toe minimax

Instituto Politcnico Nacional

Escuela Superior de Cmputo

Alumno:

POSADAS MATIAS OMAR

Asignatura:

DESARROLLO

DE SISTEMAS DISTRIBUIDOS

Profesor:

Jos Enrique Zarate Asuncin

EXAMEN 01

Grupo:

4CM3

Tres en lnea El tres en lnea, tambin conocido como tres en raya, juego del gato, tatet, triqui, totito, triqui traka, tres en gallo, michi,ceritos, equis cero o la vieja, es un juego de lpiz y papel entre dos jugadores: O y X, que marcan los espacios de un tablero de 33 alternadamente. Un jugador gana si consigue tener una lnea de tres de sus smbolos: la lnea puede ser horizontal, vertical o diagonal.

Una partida ganada por el primer jugador, X:

Una partida que termina en empate:

Los jugadores no tardan en descubrir que el juego perfecto termina en empate sin importar con qu juega el primer jugador. Normalmente son los nios pequeos los que juegan al tres en raya: cuando ya han descubierto una estrategia imbatible se pasan a juegos ms sofisticados, como el de puntos y cajas.

Estrategia ptima para el jugador X. La X en rojo marca el movimiento ptimo a realizar. Se empieza por

la casilla superior izquierda. En el siguiente paso se examina la casilla donde haya marcado el jugador

O, que presenta una nueva jugada ptima y as sucesivamente.1

La misma simplicidad del juego de tres en raya lo hacen ideal como herramienta pedaggica para ensear los conceptos de teora de juegosy la rama de inteligencia artificial que se encarga de la bsqueda derboles de juego.

Variantes

http://es.wikipedia.org/wiki/Juego_de_l%C3%A1piz_y_papelhttp://es.wikipedia.org/wiki/Tablero_de_juegohttp://es.wikipedia.org/w/index.php?title=Empate&action=edit&redlink=1http://es.wikipedia.org/wiki/Timbiriche_(juego)http://es.wikipedia.org/wiki/Tres_en_l%C3%ADnea#cite_note-xkcd-1http://es.wikipedia.org/wiki/Teor%C3%ADa_de_juegoshttp://es.wikipedia.org/wiki/Inteligencia_artificialhttp://es.wikipedia.org/wiki/%C3%81rbol_de_juegohttp://commons.wikimedia.org/wiki/File:Tic-tac-toe-game-1.pnghttp://commons.wikimedia.org/wiki/File:Tic-tac-toe-game-2.pnghttp://commons.wikimedia.org/wiki/File:Tictactoe-X.svghttp://commons.wikimedia.org/wiki/File:Tic-tac-toe-game-1.pnghttp://commons.wikimedia.org/wiki/File:Tic-tac-toe-game-2.pnghttp://commons.wikimedia.org/wiki/File:Tictactoe-X.svghttp://commons.wikimedia.org/wiki/File:Tic-tac-toe-game-1.pnghttp://commons.wikimedia.org/wiki/File:Tic-tac-toe-game-2.pnghttp://commons.wikimedia.org/wiki/File:Tictactoe-X.svg

Animacin de una partida donde las X ganan en su cuarta movida al evitar que las O hagan una lnea de

tres en su tercer movimiento en la esquina inferior derecha.

Entre las variantes del tres en raya se encuentran:

Tres en lnea: Es una variante que se juega en un tablero con nueve puntos conectados

vertical y horizontalmente, adems de dos grandes diagonales. Cada jugador consta de

tres piezas. Por turnos, cada uno coloca sus piezas, cuando todas estn en el tablero,

empiezan a moverse una interseccin por turno. El primero que logra hacer una fila con

sus tres piezas, gana.

Juegos m,n,k: juego generalizado en que se juega en un tablero de mn y el objetivo es

conseguir k en raya.

k en raya tridimensional en un tablero de kkk. El tres en raya en un tablero de

333 no tiene mucho sentido: es fcil que el primer jugador gane, pues slo tiene que

empezar a poner su primera ficha en el centro del tablero. El cuatro en raya en un tablero

de 444 es ms interesante, aunque Patashnik demostr en 1980 yVictor

Allis en 1994 que el primer jugador puede forzar la victoria. Se puede generalizar a

dimensiones superiores, pero el juego puede hacerse muy largo y se tiene el riesgo de no

visualizar bien el tablero. Existe el video juego llamado "3-D Tic-Tac-Toe" de Atari 2600

que consiste en el juego 4 el raya.

Anti-k en raya: El jugador que hace k en raya pierde. Si k = 3, el juego termina en empate

si los dos jugadores juegan bien.

Cinco en lnea, un caso particular de juego m,n,k en el que m=n=10 y k=5. Este juego

adquiere cierta complejidad ya que deben formarse lneas de cinco en un tablero que

usualmente es de 10x10.

Gato Polar, el tablero cambia por una distribucin polar formada por cinco crculos

concntricos, subdividos por 4 dimetros, formando un total de 40 casillas. Con la misma

mecnica del juego tradicional, los jugadores deben colocar, alternadamente, cculos y

cruces en las casillas. Gana el primero que consiga una "lnea" de 5. Las lneas pueden

ser radiales, axiales o diagonales (unidas por un vrtice).

http://es.wikipedia.org/w/index.php?title=Juego_m,n,k&action=edit&redlink=1http://es.wikipedia.org/w/index.php?title=Patashnik&action=edit&redlink=1http://es.wikipedia.org/w/index.php?title=Juegos_de_tablero_resueltos&action=edit&redlink=1http://es.wikipedia.org/wiki/1980http://es.wikipedia.org/w/index.php?title=Victor_Allis&action=edit&redlink=1http://es.wikipedia.org/w/index.php?title=Victor_Allis&action=edit&redlink=1http://es.wikipedia.org/wiki/1994http://es.wikipedia.org/wiki/Atarihttp://commons.wikimedia.org/wiki/File:Tictactoe1.gif

Multijugador: se puede jugar entre varios jugadores (de preferencia un nmero par), en

que alternadamente van colocando crculos y cruces.

Gato con Gravedad: se juega en un tablero "vertical" y los crculos y cruces slo se

pueden colocar sobre otros, de tal forma que van apareciendo columnas de crculos y

cruces. Se gana cuando un jugador completa cuatro en lnea.

Juego del Molino: Un juego antiguo del cual parece derivar el Tres en lnea. Por cada fila

de tres formada, se le quita una ficha al oponente.

Reglas

Cada jugador solo debe de colocar su smbolo una vez por turno y no debe ser sobre una casilla ya jugada. En caso de que el jugador haga trampa el ganador ser el otro. Se debe conseguir realizar una linea recta o diagonal por smbolo.

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.

Algoritmo Minimax con movimientos alternativos

Pasos del algoritmo Minimax:

1. Generacin del rbol de juego. Se generarn todos los nodos hasta llegar a un estado

terminal.

2. Clculo de los valores de la funcin de utilidad para cada nodo terminal.

3. 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.

4. Elegir la jugada valorando los valores que han llegado al nivel superior.

http://es.wikipedia.org/wiki/Juego_del_Molinohttp://es.wikipedia.org/wiki/Teor%C3%ADa_de_juegoshttp://es.wikipedia.org/wiki/%C3%81rbol_de_juegohttp://commons.wikimedia.org/wiki/File:Minimax.svg

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.

Desarrollo.

Se muestra la parte del algoritmo minimax

package gato_minimax;

import java.rmi.RemoteException;

import java.rmi.server.UnicastRemoteObject;

/**

*

* @author Omar

*/

public class Minimax extends UnicastRemoteObject implements I_Minimax {

public static int tiradas = 0;

NodoGato arbol = new NodoGato();

int[] tablero;

//obtiene las jugadas que faltan, de acuerdo a las casillas vacias

@Override

public int movDisponibles( int[] tablero ) throws RemoteException{

int mov = 0;

for ( int i = 0; i < 9; i ++ )

if ( tablero[i] == 0 )

mov++;

return mov;

}

http://es.wikipedia.org/wiki/Funci%C3%B3n_de_evaluaci%C3%B3nhttp://es.wikipedia.org/wiki/Ajedrezhttp://es.wikipedia.org/wiki/Backgammonhttp://es.wikipedia.org/wiki/Dilema_del_prisionero

//recupera los cuadros vacios del tablero

@Override

public int[] posVacias( int[] tablero ) throws RemoteException{

int[] indices = new int[movDisponibles(tablero)];

int indice = 0;

//recorrer y guardarlos indices

for ( int i = 0; i < 9; i ++ ){

if ( tablero[i] == 0 ){

indices[indice] = i;

indice++;

}

}

return indices;

}

//gestiona cada movimiento hecho, ya se del usuario o la computadora

@Override

public int movimiento( int[] tablero ) throws RemoteException{

this.tablero = tablero;

tiradas ++;

//copiamos el tablero al arbol

for ( int i = 0; i < 9; i ++ )

this.arbol.tablero[i] = this.tablero[i];

//movimiento que hara la computadora

movComputadora( arbol );

return arbol.mejorMovimiento;

}

//se crean los nodos del arbol

@Override

public void movComputadora( NodoGato raiz ) throws RemoteException{

int movimientos = movDisponibles(raiz.tablero);

int indices[] = posVacias(raiz.tablero);

int Max, Min;

//se inicia el nodo

raiz.nodos = new NodoGato[movimientos];

//comprueba si ya existe un ganador

int ganador = terminado(raiz.tablero);

if ( ganador == 1 ) ganador = -1;

else if ( ganador == 2 ) ganador = 1;

if ( ganador!= 0 || movimientos == 0){

raiz.ganador = ganador;

}else{

//datos de los nodos hijos

for( int i = 0; i < movimientos; i ++ ){

/*Inicializamos los nodos hijos del arbol.*/

raiz.nodos[i] = new NodoGato();

/*Les pasamos su tablero.*/

for ( int j = 0; j < 9; j ++ )

raiz.nodos[i].tablero[j] = raiz.tablero[j];

/*Creamos los diferentes movimientos posibles.*/

if ( raiz.miTurno )

raiz.nodos[i].tablero[indices[i]] = 1;

else

raiz.nodos[i].tablero[indices[i]] = 2;

/*Cambiamos el turno de los hijos*/

raiz.nodos[i].miTurno = !raiz.miTurno;

/*Guardamos el indice de su movimiento.*/

raiz.nodos[i].indice = indices[i];

movComputadora(raiz.nodos[i]);

}

/*Minimax*/

if (!raiz.miTurno)

raiz.ganador = max(raiz);

else

raiz.ganador = min(raiz);

}

}

//se calcula el maximo de los nodos hijos de min*/

@Override

public int max( NodoGato raiz ) throws RemoteException{

int Max = -111;

//maximo para la computadora, buscamos el valor donde gane.

for (int i = 0; i < raiz.nodos.length; i++){

/*Preguntamos por un nodo con un valor alto MAX*/

if (raiz.nodos[i].ganador > Max){

/*Lo asignamos y pasamos el mejor movimiento a la raiz.*/

Max = raiz.nodos[i].ganador;

raiz.mejorMovimiento = raiz.nodos[i].indice;

/*Terminamos de buscar.*/

if (Max == 1) break;

}

}

/*Borramos los nodos.*/

raiz.nodos = null;

return Max;

}

//se calcula el minimo de los nodos hijos de MAX.*/

@Override

public int min( NodoGato raiz ) throws RemoteException{

int Min = 111;

//minimo para el jugador

for (int i = 0; i < raiz.nodos.length; i++)

if (raiz.nodos[i].ganador < Min ){

Min = raiz.nodos[i].ganador;

raiz.mejorMovimiento = raiz.nodos[i].indice;

if (Min == -1) break;

}

/*Borramos los nodos.*/

raiz.nodos = null;

return Min;

}

//Regresa 0 si nadie gana, 1 si gana jugador 1 y 2 si gana la computadora

@Override

public int terminado( int[] tablero ) throws RemoteException{

//linea en las filas

if ( tablero[0] == tablero[1] && tablero[0] == tablero[2] && tablero[0] != 0 )

return tablero[0];

else if ( tablero[3] == tablero[4] && tablero[3] == tablero[5] && tablero[3] != 0 )

return tablero[3];

else if ( tablero[6] == tablero[7] && tablero[6]== tablero[8] && tablero[6] != 0 )

return tablero[6];

//linea en las columnas

else if( tablero[0] == tablero[3] && tablero[0] == tablero[6] && tablero[0] != 0 )

return tablero[0];


return tablero[1];


return tablero[2];

//lineas diagonales

else if ( tablero[0] == tablero[4] && tablero[0] == tablero[8] && tablero[0] !=0 )

return tablero[0];


return tablero[2];

return 0;

}

public Minimax() throws RemoteException{

super();

}

}

Se muestra la parte de los nodos:


/**

*

* @author Omar

*/

//arbol de movimientos

public class NodoGato {

int mejorMovimiento;

//Nodos hijos.

NodoGato nodos[];

//Tablero del juego

public int tablero[];

//turno de la computadora

boolean miTurno = false;

//indice de la pocision

int indice;

int ganador = 0;

NodoGato() {

//incializar variables

tablero = new int[9];

}

}

Se muestra la parte del servidor RMI:


import java.net.MalformedURLException;

import java.rmi.AlreadyBoundException;

import java.rmi.Naming;

import java.rmi.Remote;

import java.rmi.RemoteException;

import java.rmi.registry.LocateRegistry;

import java.util.logging.Level;

import java.util.logging.Logger;

/**

*

* @author Omar

*/

public class ServidorRMI {

public static void main(String[] args) {

try {

I_Minimax minmax;

LocateRegistry.createRegistry(1099);

minmax = new Minimax();

Naming.bind("ServidorGato", minmax);

System.out.println("Servidor funcionando...");

} catch (RemoteException ex) {

Logger.getLogger(ServidorRMI.class.getName()).log(Level.SEVERE, null, ex);

} catch (MalformedURLException ex) {


} catch (AlreadyBoundException ex) {


}

}

}

Pruebas:

tictac toe minimax

Documents