/**
   * 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;
  }
Exemplo n.º 5
0
  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;
  }
Exemplo n.º 6
0
  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();
  }
Exemplo n.º 7
0
  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;
  }
Exemplo n.º 8
0
  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;
  }
Exemplo n.º 9
0
 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;
   }
 }
Exemplo n.º 10
0
  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);
  }
Exemplo n.º 11
0
  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.
  }
Exemplo n.º 12
0
 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;
 }
Exemplo n.º 13
0
  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();
  }