API tools faq
paste
AgusSaavedra

ReversiViejo

AgusSaavedra
Nov 13th, 2018
48
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 11.58 KB | None | 0 0
raw download clone embed print report
  1. package juego;
  2.  
  3. /**
  4.  * Juego Reversi
  5.  *
  6.  * Reglas:
  7.  *
  8.  * https://es.wikipedia.org/wiki/Reversi https://es.wikihow.com/jugar-a-Othello
  9.  *
  10.  */
  11. public class Reversi {
  12.  
  13.     private Casillero tablero[][];
  14.     private String jugadorConFichasNegras;
  15.     private String jugadorConFichasBlancas;
  16.     private boolean turnoDeFichasNegras = true;
  17.     private int fichasTotales = 0;
  18.     private int tamanio;
  19.  
  20.     /**
  21.      * pre : 'dimension' es un número par, mayor o igual a 4. post: empieza el
  22.      * juego entre el jugador que tiene fichas negras, identificado como
  23.      * 'fichasNegras' y el jugador que tiene fichas blancas, identificado como
  24.      * 'fichasBlancas'. El tablero tiene 4 fichas: 2 negras y 2 blancas. Estas
  25.      * fichas están intercaladas en el centro del tablero.
  26.      *
  27.      * @param dimensionTablero
  28.      *            : cantidad de filas y columnas que tiene el tablero.
  29.      * @param fichasNegras
  30.      *            : nombre del jugador con fichas negras.
  31.      * @param fichasBlancas
  32.      *            : nombre del jugador con fichas blancas.
  33.      */
  34.     public Reversi(int dimensionTablero, String fichasNegras,
  35.             String fichasBlancas) {
  36.  
  37.         if ((dimensionTablero >= 4 && dimensionTablero <= 10)
  38.                 && dimensionTablero % 2 == 0) {
  39.  
  40.             tablero = new Casillero[dimensionTablero + 2][dimensionTablero + 2];
  41.  
  42.             for (int i = 0; i < tablero.length; i++) {
  43.                 for (int j = 0; j < tablero[i].length; j++) {
  44.  
  45.                     tablero[i][j] = Casillero.LIBRE;
  46.                 }
  47.             }
  48.  
  49.             tablero[(dimensionTablero / 2)][(dimensionTablero / 2) - 1] = Casillero.NEGRAS;
  50.             tablero[(dimensionTablero / 2) - 1][(dimensionTablero / 2) - 1] = Casillero.BLANCAS;
  51.             tablero[dimensionTablero / 2][dimensionTablero / 2] = Casillero.BLANCAS;
  52.             tablero[(dimensionTablero / 2) - 1][(dimensionTablero / 2)] = Casillero.NEGRAS;
  53.  
  54.             fichasTotales = dimensionTablero * dimensionTablero;
  55.             jugadorConFichasBlancas = fichasBlancas;
  56.             jugadorConFichasNegras = fichasNegras;
  57.             tamanio = tablero.length - 2;
  58.  
  59.         } else {
  60.  
  61.             Error cantidadDeFilasYColumnasErronea = new Error(
  62.                     "La dimensión del tablero es incorrecta");
  63.             throw cantidadDeFilasYColumnasErronea;
  64.  
  65.         }
  66.     }
  67.  
  68.     /**
  69.      * post: devuelve la cantidad de filas que tiene el tablero.
  70.      */
  71.     public int contarFilas() {
  72.  
  73.         return tamanio;
  74.     }
  75.  
  76.     /**
  77.      * post: devuelve la cantidad de columnas que tiene el tablero.
  78.      */
  79.     public int contarColumnas() {
  80.  
  81.         return tamanio;
  82.     }
  83.  
  84.     /**
  85.      * post: devuelve el nombre del jugador que debe colocar una ficha o null si
  86.      * terminó el juego.
  87.      */
  88.     public String obtenerJugadorActual() {
  89.  
  90.         String jugadorActual = null;
  91.  
  92.         if (turnoDeFichasNegras) {
  93.  
  94.             jugadorActual = jugadorConFichasNegras;
  95.  
  96.         } else if (!turnoDeFichasNegras) {
  97.  
  98.             jugadorActual = jugadorConFichasBlancas;
  99.         }
  100.  
  101.         return jugadorActual;
  102.     }
  103.  
  104.     /**
  105.      * pre : fila está en el intervalo [1, contarFilas()], columnas está en el
  106.      * intervalo [1, contarColumnas()]. post: indica quién tiene la posesión del
  107.      * casillero dado por fila y columna.
  108.      *
  109.      * @param fila
  110.      * @param columna
  111.      */
  112.     public Casillero obtenerCasillero(int fila, int columna) {
  113.  
  114.         int columnaCorregida = columna - 1;
  115.         int filaCorregida = fila - 1;
  116.         return tablero[filaCorregida][columnaCorregida];
  117.     }
  118.  
  119.     /**
  120.      *
  121.      * @param fila
  122.      * @param columna
  123.      * @return
  124.      */
  125.     public boolean puedeColocarFicha(int fila, int columna) {
  126.  
  127.         int filaCorregida = fila - 1;
  128.         int columnaCorregida = columna - 1;
  129.         boolean pusoFicha = false;
  130.  
  131.         if (tablero[filaCorregida][columnaCorregida] == Casillero.LIBRE) {
  132.  
  133.             if (sePuedeColocarFichaAlOeste(filaCorregida, columnaCorregida)) {
  134.  
  135.                 pusoFicha = true;
  136.  
  137.             }
  138.             if (sePuedeColocarFichaAlNorte(filaCorregida, columnaCorregida)) {
  139.  
  140.                 pusoFicha = true;
  141.  
  142.             }
  143.             if (sePuedeColocarFichaAlNoroeste(filaCorregida, columnaCorregida)) {
  144.  
  145.                 pusoFicha = true;
  146.             }
  147.         }
  148.         return pusoFicha;
  149.     }
  150.  
  151.     /**
  152.      * pre : la posición indicada por (fila, columna) puede ser ocupada por una
  153.      * ficha. 'fila' está en el intervalo [1, contarFilas()]. 'columna' está en
  154.      * el intervalor [1, contarColumnas()]. y aún queda un Casillero.VACIO en la
  155.      * columna indicada. post: coloca una ficha en la posición indicada.
  156.      *
  157.      * @param fila
  158.      * @param columna
  159.      */
  160.  
  161.     public void colocarFicha(int fila, int columna) {
  162.  
  163.         int columnaCorregida = columna - 1;
  164.         int filaCorregida = fila - 1;
  165.  
  166.         if (puedeColocarFicha(fila, columna)) {
  167.  
  168.             if (turnoDeFichasNegras) {
  169.  
  170.                 tablero[filaCorregida][columnaCorregida] = Casillero.NEGRAS;
  171.                 if (sePuedeColocarFichaAlOeste(filaCorregida, columnaCorregida)) {
  172.  
  173.                     colocarFichaAlOeste(fila, columna);
  174.  
  175.                 }
  176.                 if (sePuedeColocarFichaAlNorte(filaCorregida, columnaCorregida)) {
  177.  
  178.                     colocarFichaAlNorte(fila, columna);
  179.  
  180.                 }
  181.                 if (sePuedeColocarFichaAlNoroeste(filaCorregida,
  182.                         columnaCorregida)) {
  183.  
  184.                     colocarFichaAlNoroeste(fila, columna);
  185.                 }
  186.                 turnoDeFichasNegras = !turnoDeFichasNegras;
  187.  
  188.             } else if (!turnoDeFichasNegras) {
  189.  
  190.                 tablero[filaCorregida][columnaCorregida] = Casillero.BLANCAS;
  191.                 if (sePuedeColocarFichaAlOeste(filaCorregida, columnaCorregida)) {
  192.  
  193.                     colocarFichaAlOeste(fila, columna);
  194.  
  195.                 }
  196.                 if (sePuedeColocarFichaAlNorte(filaCorregida, columnaCorregida)) {
  197.  
  198.                     colocarFichaAlNorte(fila, columna);
  199.  
  200.                 }
  201.                 if (sePuedeColocarFichaAlNoroeste(filaCorregida,
  202.                         columnaCorregida)) {
  203.  
  204.                     colocarFichaAlNoroeste(fila, columna);
  205.                 }
  206.  
  207.                 turnoDeFichasNegras = !turnoDeFichasNegras;
  208.             }
  209.         }
  210.     }
  211.  
  212.     /**
  213.      * post: devuelve la cantidad de fichas negras en el tablero.
  214.      */
  215.     public int contarFichasNegras() {
  216.  
  217.         int cantidadDeFichasNegras = 0;
  218.         for (int i = 0; i < tablero.length; i++) {
  219.             for (int j = 0; j < tablero[i].length; j++) {
  220.                 if (tablero[i][j] == Casillero.NEGRAS) {
  221.  
  222.                     cantidadDeFichasNegras++;
  223.  
  224.                 }
  225.             }
  226.         }
  227.         return cantidadDeFichasNegras;
  228.     }
  229.  
  230.     /**
  231.      * post: devuelve la cantidad de fichas blancas en el tablero.
  232.      */
  233.     public int contarFichasBlancas() {
  234.  
  235.         int cantidadDeFichasBlancas = 0;
  236.         for (int i = 0; i < tablero.length; i++) {
  237.             for (int j = 0; j < tablero[i].length; j++) {
  238.                 if (tablero[i][j] == Casillero.BLANCAS) {
  239.  
  240.                     cantidadDeFichasBlancas++;
  241.  
  242.                 }
  243.             }
  244.         }
  245.         return cantidadDeFichasBlancas;
  246.     }
  247.  
  248.     /**
  249.      * post: indica si el juego terminó porque no existen casilleros vacíos o
  250.      * ninguno de los jugadores puede colocar una ficha.
  251.      */
  252.     public boolean termino() {
  253.  
  254.         boolean terminoElJuego = false;
  255.  
  256.         if (fichasTotales == (contarFichasBlancas() + contarFichasNegras())
  257.                 || (contarFichasBlancas() == 0 || contarFichasNegras() == 0)) {
  258.  
  259.             terminoElJuego = true;
  260.         }
  261.  
  262.         return terminoElJuego;
  263.     }
  264.  
  265.     /**
  266.      * post: indica si el juego terminó y tiene un ganador.
  267.      */
  268.     public boolean hayGanador() {
  269.  
  270.         boolean hayUnGanador;
  271.  
  272.         if (ganoElJugadorDeLasFichasBlancas()
  273.                 || ganoElJugadorDeLasFichasNegras() && termino() == true) {
  274.  
  275.             hayUnGanador = true;
  276.  
  277.         } else {
  278.  
  279.             hayUnGanador = false;
  280.         }
  281.  
  282.         return hayUnGanador;
  283.     }
  284.  
  285.     /**
  286.      * pre : el juego terminó. post: devuelve el nombre del jugador que ganó el
  287.      * juego.
  288.      */
  289.     public String obtenerGanador() {
  290.  
  291.         String ganador = null;
  292.         if (termino() == true && hayGanador() == true) {
  293.  
  294.             if (ganoElJugadorDeLasFichasNegras()) {
  295.  
  296.                 ganador = jugadorConFichasNegras;
  297.  
  298.             } else if (ganoElJugadorDeLasFichasBlancas()) {
  299.  
  300.                 ganador = jugadorConFichasBlancas;
  301.             }
  302.         }
  303.         return ganador;
  304.     }
  305.  
  306.     /**
  307.      * post: Devuelve si gano el jugador de las fichas negras.
  308.      */
  309.  
  310.     private boolean ganoElJugadorDeLasFichasNegras() {
  311.  
  312.         boolean ganoLasFichasNegras = false;
  313.  
  314.         if ((contarFichasBlancas() < contarFichasNegras() || contarFichasBlancas() == 0)
  315.                 && termino() == true) {
  316.  
  317.             ganoLasFichasNegras = true;
  318.         }
  319.  
  320.         return ganoLasFichasNegras;
  321.     }
  322.  
  323.     /**
  324.      * post: Devuelve si gano el jugador de las fichas blancas.
  325.      */
  326.  
  327.     private boolean ganoElJugadorDeLasFichasBlancas() {
  328.  
  329.         boolean ganoLasFichasBlancas = false;
  330.  
  331.         if ((contarFichasNegras() < contarFichasBlancas() || contarFichasNegras() == 0)
  332.                 && termino() == true) {
  333.  
  334.             ganoLasFichasBlancas = true;
  335.         }
  336.  
  337.         return ganoLasFichasBlancas;
  338.     }
  339.  
  340.     private Casillero colorDeLaFichaActual() {
  341.  
  342.         Casillero colorActual = Casillero.NEGRAS;
  343.         if (!turnoDeFichasNegras) {
  344.  
  345.             colorActual = Casillero.BLANCAS;
  346.         }
  347.         return colorActual;
  348.     }
  349.  
  350.     private boolean sePuedeColocarFichaAlOeste(int fila, int columna) {
  351.  
  352.         boolean puedeColocar = false;
  353.  
  354.         if (columna < contarColumnas() - 1
  355.                 && tablero[fila][columna + 1] != Casillero.LIBRE
  356.                 && tablero[fila][columna + 1] != colorDeLaFichaActual()) {
  357.  
  358.             for (int x = 0; x + columna < contarColumnas() - 1; x++) {
  359.  
  360.                 if (tablero[fila][columna + 1] != tablero[fila][columna
  361.                         + (2 + x)]
  362.                         &&
  363.  
  364.                         tablero[fila][columna + (2 + x)] != Casillero.LIBRE) {
  365.                     puedeColocar = true;
  366.                 }
  367.             }
  368.         }
  369.  
  370.         return puedeColocar;
  371.     }
  372.  
  373.     private boolean sePuedeColocarFichaAlNorte(int fila, int columna) {
  374.  
  375.         boolean puedeColocar = false;
  376.  
  377.         if (fila < contarFilas() - 1
  378.                 && tablero[fila + 1][columna] != Casillero.LIBRE
  379.                 && tablero[fila + 1][columna] != colorDeLaFichaActual()) {
  380.  
  381.             for (int x = 0; x + fila < contarFilas() - 1; x++) {
  382.  
  383.                 if (tablero[fila + 1][columna] != tablero[fila + (2 + x)][columna]
  384.                         && tablero[fila + (2 + x)][columna] != Casillero.LIBRE) {
  385.                     puedeColocar = true;
  386.                 }
  387.             }
  388.         }
  389.         return puedeColocar;
  390.     }
  391.  
  392.     private boolean sePuedeColocarFichaAlNoroeste(int fila, int columna) {
  393.  
  394.         boolean puedeColocar = false;
  395.  
  396.         if (columna < contarColumnas() - 1 && fila < contarFilas() - 1
  397.                 && tablero[fila + 1][columna + 1] != Casillero.LIBRE
  398.                 && tablero[fila + 1][columna + 1] != colorDeLaFichaActual()) {
  399.  
  400.             for (int j = 0; j + fila < contarFilas() - 1; j++) {
  401.                 for (int i = 0; i + columna < contarColumnas() - 1; i++) {
  402.  
  403.                     if (tablero[fila + 1][columna + 1] != tablero[fila + 2][columna + 2]
  404.                             && tablero[fila + (2 + j)][columna + (2 + i)] != Casillero.LIBRE) {
  405.                         puedeColocar = true;
  406.                     }
  407.                 }
  408.             }
  409.         }
  410.         return puedeColocar;
  411.     }
  412.  
  413.     private void colocarFichaAlOeste(int fila, int columna) {
  414.  
  415.         int filaCorregida = fila - 1;
  416.         int columnaCorregida = columna - 1;
  417.  
  418.         for (int j = 1; j < tamanio - columna; j++) {
  419.             if (tablero[filaCorregida][columnaCorregida + j] != colorDeLaFichaActual()) {
  420.  
  421.                 tablero[filaCorregida][columnaCorregida + j] = colorDeLaFichaActual();
  422.  
  423.             } else if (tablero[filaCorregida][columnaCorregida + j] == colorDeLaFichaActual()
  424.                     || tablero[filaCorregida][columnaCorregida + j] == Casillero.LIBRE) {
  425.  
  426.                 j = tamanio;
  427.             }
  428.         }
  429.     }
  430.  
  431.     private void colocarFichaAlNorte(int fila, int columna) {
  432.  
  433.         int filaCorregida = fila - 1;
  434.         int columnaCorregida = columna - 1;
  435.  
  436.         for (int j = 1; j < tamanio - fila; j++) {
  437.             if (tablero[filaCorregida + j][columnaCorregida] != colorDeLaFichaActual()) {
  438.  
  439.                 tablero[filaCorregida + j][columnaCorregida] = colorDeLaFichaActual();
  440.  
  441.             } else if (tablero[filaCorregida + j][columnaCorregida] == colorDeLaFichaActual()
  442.                     || tablero[filaCorregida + j][columnaCorregida] == Casillero.LIBRE) {
  443.  
  444.                 j = tamanio;
  445.             }
  446.         }
  447.     }
  448.  
  449.     private void colocarFichaAlNoroeste(int fila, int columna) {
  450.  
  451.         int filaCorregida = fila - 1;
  452.         int columnaCorregida = columna - 1;
  453.  
  454.         for (int j = 1; j + fila < tamanio - fila; j++) {
  455.  
  456.             if (tablero[filaCorregida + j][columnaCorregida + j] != colorDeLaFichaActual()) {
  457.  
  458.                 tablero[filaCorregida + j][columnaCorregida + j] = colorDeLaFichaActual();
  459.  
  460.             } else if (tablero[filaCorregida + j][columnaCorregida + j] == colorDeLaFichaActual()
  461.                     || tablero[filaCorregida + j][columnaCorregida + j] == Casillero.LIBRE) {
  462.  
  463.                 j = tamanio;
  464.             }
  465.         }
  466.     }
  467. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!