/**
* Este método está encargado de buscar movimientos válidos (que flanquean fichas contrarias) en
* un tablero y turno determinados. Hace un recorrido del tablero, casilla por casilla, buscando
* la posibilidad de realizar "un reversi" desde cada una de ellas. Actualiza el flag
* "hayMovimientosValidos" y guarda dichos movimientos (si existen) en el array
* "movimientosValidos" del tablero.
*/
private void buscaMovimientosValidos(Ficha turno, Tablero tab) {
hayMovimientosValidos = false;
MovimientoReversi mov;
// Se vacia el array de movimientos validos del
// tablero,
// ya que pertenecen al turno anterior:
tab.vaciaMovimientosValidos();
for (int i = 1; i <= tab.getAncho(); i++)
for (int j = 1; j <= tab.getAlto(); j++) {
// Se crea un movimiento con las coordenadas del tablero
// en las que nos encontramos:
mov = new MovimientoReversi(i, j, turno);
// Se comprueba si "hay reversi" desde esa posicion:
if (tab.getCasilla(i, j) == Ficha.VACIA && mov.buscaReversi(tab)) {
// Se añade este movimiento (por ser válido) al array de
// movimientos validos del tablero:
tab.addMovimientoValido(mov);
hayMovimientosValidos = true;
}
}
}
@Override
public void handle(ActionEvent evento) {
juego.limpiarTablero();
if (!tablero.debugModeHabilitado()) {
tablero.botonLimpiarDeshabilitar(true);
}
tablero.dibujar();
}
/**
* Recorre el tablero y actualiza los contadores que indican el número de fichas/casillas de cada
* tipo que hay en el tablero, siendo estas: negras, blancas o vacías (en las que se incluyen las
* casillas sombreadas)
*/
private void cuentaFichas(Tablero t) {
resetNumFichas();
for (int i = 1; i <= t.getAncho(); i++) {
for (int j = 1; j <= t.getAlto(); j++) {
if (t.getCasilla(i, j) == Ficha.BLANCA) numFichasBlancas++;
else if (t.getCasilla(i, j) == Ficha.NEGRA) numFichasNegras++;
else numCasillasVacias++;
}
}
}
/**
* Crea el tablero inicial por defecto del Reversi. Consiste en un tablero de 8 x 8 casillas con
* cuatro fichas centrales (2 blancas y 2 negras)
*
* @return tablero
*/
private Tablero creaTableroInicial() {
// Se crea el tablero con las dimensiones por defecto:
Tablero tab = new Tablero(8, 8);
tab.reset();
// Se colocan las cuatro fichas centrales:
tab.setCasilla(tab.getAncho() / 2, tab.getAlto() / 2, Ficha.BLANCA);
tab.setCasilla(tab.getAncho() / 2 + 1, tab.getAlto() / 2 + 1, Ficha.BLANCA);
tab.setCasilla(tab.getAncho() / 2 + 1, tab.getAlto() / 2, Ficha.NEGRA);
tab.setCasilla(tab.getAncho() / 2, tab.getAlto() / 2 + 1, Ficha.NEGRA);
return tab;
}
public boolean comprobarRestriccion(Tablero tablero, int coordX, int coordY, int numero) {
for (int columna = 0; columna < 9; columna++)
if (tablero.getCasilla(coordX, columna) == numero) return false;
for (int fila = 0; fila < 9; fila++)
if (tablero.getCasilla(fila, coordY) == numero) return false;
int cuadranteX = coordX / 3;
int cuadranteY = coordY / 3;
for (int i = cuadranteX * 3; i < (cuadranteX + 1) * 3; i++)
for (int j = cuadranteY * 3; j < (cuadranteY + 1) * 3; j++)
if (tablero.getCasilla(i, j) == numero) return false;
return true;
}
public Movimiento run() {
// Obtenemos el movimiento a partir de la posici�n sobre la que el jugador hizo click
// en el canvas que representa el tablero
canvas.esperandoClick();
while (canvas.obtenerMovimiento() == null
|| !tablero.movimientoCorrecto(canvas.obtenerMovimiento(), 1)) {
while (canvas.estaEsperandoClick()) ;
if (!tablero.movimientoCorrecto(canvas.obtenerMovimiento(), 1)) canvas.esperandoClick();
}
return canvas.obtenerMovimiento();
}
public boolean ejecutarBC(Tablero tablero) {
int fila, columna;
if (!siguiente(tablero)) return true;
fila = x;
columna = y;
for (int numero = 1; numero <= 9; numero++) {
if (comprobarRestriccion(tablero, fila, columna, numero)) {
tablero.setCasilla(numero, fila, columna);
if (ejecutarBC(tablero)) return true;
tablero.setCasilla(0, fila, columna);
}
}
return false;
}
public boolean validarMovimiento(CuadroPieza Destino, Tablero tbl) {
if (Destino.getPieza() != null) { // Si el cuadro destino esta ocupado entonces:
if (Destino.getPieza().getColor() == getCuadroPieza().getPieza().getColor()) {
// Si la pieza destino tiene el mismo color que la pieza que voy a mover
return false; // El movimiento es invalido, no puedo comer una pieza de mi mismo equipo.
}
}
// ---Valido que no su rey no entre en jacke despues de que se mueva.
Pieza tmpDestino =
Destino.getPieza(); // Guardo las piezas en temporales, para deshacer los cambios
Pieza tmpActual =
getCuadroPieza().getPieza(); // Guardo las piezas en temporales, para deshacer los cambios
CuadroPieza Actual =
getCuadroPieza(); // El cuadro dode actualmente esta la pieza, tambien lo guardo.
Actual.setPieza(null); // simulo un movimiento, dejo el cuadro actual en vacio
Destino.setPieza(this); // Muevo esta pieza al cuadro destino
// Valido si despues de que mueva, el rey esta en jacke.
boolean b =
tbl.getRey(getColor())
.isInJacke(
tbl); // Para lo cual obtengo el rey del mismo color de la pieza y le pregunto si
// esta en jacke
Actual.setPieza(tmpActual); // Deshago los cambios, porque SOLO valido, NO muevo piezas
Destino.setPieza(tmpDestino); // Deshago los cambios, porque solo valido, NO muevo piezas
/*
* Si retorna que esta en jacke(b=true), entonces el movimiento es invalido,
* Si retorna que no esta en jacke(b=false), el mov. es valido.
*/
return !b;
}
public boolean MoverPieza(CuadroPieza Destino, Tablero tbl) {
/*
* Valido el movimiento, antes de mover, tener en cuenta que en las clases hijas este metodo debe haber sido sobreescrito
* Por lo que no solo va a validar lo que hay en el metodo validarMovimiento de Pieza, si no va a usar el metodo sobreescrito en la clase hija
*/
if (validarMovimiento(Destino, tbl)) {
getCuadroPieza()
.setPieza(
null); // Le paso al cuadro donde actualmente esta la pieza el valor de null, que
// quiere decir que ya no tiene pieza
if (Destino.getPieza() != null) { // Si hay una pieza en el destino
tbl.getPiezasComidas()
.add(
Destino
.getPieza()); // Agrego la pieza que estoy comiento a un arraylist de piezas
// comidas.
setCantMovimientosSinCambios(
0); // Si come a alguna pieza, reseteo el contador de movimientos sin cambios.
} else {
setCantMovimientosSinCambios(
getCantMovimientosSinCambios()
+ 1); // Si no come alguna pieza, el contador aumenta en uno.
}
Destino.setPieza(this); // Muevo la pieza al cuadro destino
setFirstmov(false); // El siguiente movimiento, ya no sería el primero.
return true;
} else {
return false;
}
}
public void run() {
inicializar();
boolean turno_rojo = true;
int color;
Movimiento m;
// La partida se desarrolla hasta que el tablero esté lleno o ya no se puedan tirar más veces
// (por ejemplo porque alguno de los jugadores se haya quedado sin fichas)
while (!t.estaLleno() && (t.puedeTirar(1) || t.puedeTirar(2))) {
m = null;
color = 0;
// Lo que se hace realmente es esperar el movimiento devuelto por el método run tanto
// del humano como de la máquina
if (turno_rojo) {
if (t.puedeTirar(1)) {
jugador1.setTablero(t);
jugador1.setCanvas(C);
m = jugador1.run();
color = 1;
} else {
System.out.println("El jugador rojo no puede tirar");
}
} else {
if (t.puedeTirar(2)) {
jugador2.setTablero(t);
m = jugador2.run();
color = 2;
} else {
System.out.println("El jugador amarillo no puede tirar");
}
}
turno_rojo = !turno_rojo;
if (m != null) {
t.ponerFicha(m.columna, m.fila, color);
C.setTablero(t);
C.repaint();
}
}
switch (t.ganador()) {
case 0:
System.out.println("Ha habido un empate");
break;
case 1:
System.out.println("Ha ganado el jugador rojo");
break;
case 2:
System.out.println("Ha ganado el jugador amarillo");
break;
}
// Con esto la partida termina y se activa el botón de comenzar una nueva partida.
b1.setEnabled(true);
b2.setEnabled(false);
}
public static boolean isJugadorAhogado(int turno, Tablero tbl) {
CuadroPieza cuadroDestino = null;
CuadroPieza cuadroActual = null;
/*
* En sintesis, lo que se hace aqui es recorrer todas las piezas, y comparar si tienen algun movimiento posible, a alguna posicion del tablero.
* Para recorrer todas las piezas uso los dos primeros for.
* Para recorrer los cuadros posibles a los que se puede mover, uso los 2 siguientes for.
*/
for (int x = 0;
x < 8;
x++) { // Busco todas las piezas del jugador del que quiero saber si esta ahogado.
for (int y = 0; y < 8; y++) {
cuadroActual = tbl.getTablero()[y][x];
if (cuadroActual.getPieza()
!= null) { // Si hay una pieza en el cuadro selecciondo actualmente por el for.
if (cuadroActual.getPieza().getColor()
== turno) { // Reviso que sea del color de pieza, que del jugador que quiero averiguar
// si esta ahogado.
for (int x1 = 0;
x1 < 8;
x1++) { // Recorro todos los cuadros a del tablero preguntandole si puede moverse a
// ese cuadro
for (int y1 = 0; y1 < 8; y1++) {
cuadroDestino = tbl.getTablero()[y1][x1];
if (cuadroActual
.getPieza()
.validarMovimiento(
cuadroDestino,
tbl)) { // Si hay un movimiento posible, entonces no esta ahogado
return false;
}
}
}
}
}
}
}
return true; // Si no encontro algun movimiento posible, pues el usuario esta ahogado, y retorno
// true.
}
public boolean siguiente(Tablero tablero) {
for (int i = 0; i < 9; i++) {
for (int j = 0; j < 9; j++) {
if (tablero.getCasilla(i, j) == 0) {
x = i;
y = j;
return true;
}
}
}
return false;
}
public static void mostrarTablero(Tablero tablero) {
Pieza[][] tab = tablero.getTablero();
clearConsole();
System.out.println();
System.out.println(" 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 ");
for (int f = 0; f < tablero.getFilas(); f++) {
System.out.print(f + 1);
for (int c = 0; c < tablero.getColumnas(); c++) {
if (tab[f][c] == null) {
System.out.print(" - ");
} else {
System.out.print(" " + tab[f][c].getRepresentacion() + " ");
}
}
System.out.println();
}
System.out.println();
}