API tools faq
paste
AgusSaavedra

Reversi 2.0

AgusSaavedra
Nov 15th, 2018
68
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 20.00 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.             tamanio = tablero.length - 2;
  56.  
  57.         } else {
  58.  
  59.             Error cantidadDeFilasYColumnasErronea = new Error(
  60.                     "La dimensión del tablero es incorrecta");
  61.             throw cantidadDeFilasYColumnasErronea;
  62.  
  63.         }
  64.  
  65.         if (fichasBlancas.equals(fichasNegras) || fichasNegras.equals(fichasBlancas) ||
  66.                 fichasBlancas.equals("") || fichasNegras.equals("")) {
  67.  
  68.             Error nombreDeJugadorErronea = new Error(
  69.                     "El nombre de unos de los jugadores no es valido");
  70.             throw nombreDeJugadorErronea;
  71.  
  72.         } else {
  73.  
  74.             jugadorConFichasBlancas = fichasBlancas;
  75.             jugadorConFichasNegras = fichasNegras;
  76.  
  77.         }
  78.     }
  79.  
  80.     /**
  81.      * post: devuelve la cantidad de filas que tiene el tablero.
  82.      */
  83.     public int contarFilas() {
  84.  
  85.         return tamanio;
  86.     }
  87.  
  88.     /**
  89.      * post: devuelve la cantidad de columnas que tiene el tablero.
  90.      */
  91.     public int contarColumnas() {
  92.  
  93.         return tamanio;
  94.     }
  95.  
  96.     /**
  97.      * post: devuelve el nombre del jugador que debe colocar una ficha o null si
  98.      * terminó el juego.
  99.      */
  100.     public String obtenerJugadorActual() {
  101.  
  102.         String jugadorActual = null;
  103.  
  104.         if (turnoDeFichasNegras) {
  105.  
  106.             jugadorActual = jugadorConFichasNegras;
  107.  
  108.         } else if (!turnoDeFichasNegras) {
  109.  
  110.             jugadorActual = jugadorConFichasBlancas;
  111.         }
  112.  
  113.         return jugadorActual;
  114.     }
  115.  
  116.     /**
  117.      * pre : fila está en el intervalo [1, contarFilas()], columnas está en el
  118.      * intervalo [1, contarColumnas()]. post: indica quién tiene la posesión del
  119.      * casillero dado por fila y columna.
  120.      *
  121.      * @param fila
  122.      * @param columna
  123.      */
  124.     public Casillero obtenerCasillero(int fila, int columna) {
  125.  
  126.         int columnaCorregida = columna - 1;
  127.         int filaCorregida = fila - 1;
  128.         return tablero[filaCorregida][columnaCorregida];
  129.     }
  130.  
  131.     /**
  132.      *
  133.      * @param fila
  134.      * @param columna
  135.      * @return
  136.      */
  137.     public boolean puedeColocarFicha(int fila, int columna) {
  138.  
  139.         int filaCorregida = fila - 1;
  140.         int columnaCorregida = columna - 1;
  141.         boolean pusoFicha = false;
  142.  
  143.         if (tablero[filaCorregida][columnaCorregida] == Casillero.LIBRE) {
  144.  
  145.             if (sePuedeColocarFichaAlOeste(filaCorregida, columnaCorregida)) {
  146.  
  147.                 pusoFicha = true;
  148.  
  149.             }
  150.             if (sePuedeColocarFichaAlNorte(filaCorregida, columnaCorregida)) {
  151.  
  152.                 pusoFicha = true;
  153.  
  154.             }
  155.             if (sePuedeColocarFichaAlNoroeste(filaCorregida, columnaCorregida)) {
  156.  
  157.                 pusoFicha = true;
  158.             }
  159.             if (sePuedeColocarFichaAlSur(filaCorregida, columnaCorregida)) {
  160.  
  161.                 pusoFicha = true;
  162.             }
  163.             if (sePuedeColocarFichaAlEste(filaCorregida, columnaCorregida)) {
  164.  
  165.                 pusoFicha = true;
  166.             }
  167.             if (sePuedeColocarFichaAlSudeste(filaCorregida, columnaCorregida)) {
  168.  
  169.                 pusoFicha = true;
  170.             }
  171.             if (sePuedeColocarFichaAlSudoeste(filaCorregida, columnaCorregida)) {
  172.  
  173.                 pusoFicha = true;
  174.             }
  175.             if (sePuedeColocarFichaAlNoreste(filaCorregida, columnaCorregida)) {
  176.  
  177.                 pusoFicha = true;
  178.             }
  179.         }
  180.         return pusoFicha;
  181.     }
  182.  
  183.     /**
  184.      * pre : la posición indicada por (fila, columna) puede ser ocupada por una
  185.      * ficha. 'fila' está en el intervalo [1, contarFilas()]. 'columna' está en
  186.      * el intervalor [1, contarColumnas()]. y aún queda un Casillero.VACIO en la
  187.      * columna indicada. post: coloca una ficha en la posición indicada.
  188.      *
  189.      * @param fila
  190.      * @param columna
  191.      */
  192.  
  193.     public void colocarFicha(int fila, int columna) {
  194.  
  195.         int columnaCorregida = columna - 1;
  196.         int filaCorregida = fila - 1;
  197.  
  198.         if (puedeColocarFicha(fila, columna)) {
  199.  
  200.             if (turnoDeFichasNegras) {
  201.  
  202.                 tablero[filaCorregida][columnaCorregida] = Casillero.NEGRAS;
  203.                 if (sePuedeColocarFichaAlOeste(filaCorregida, columnaCorregida)) {
  204.  
  205.                     colocarFichaAlOeste(fila, columna);
  206.  
  207.                 }
  208.                 if (sePuedeColocarFichaAlNorte(filaCorregida, columnaCorregida)) {
  209.  
  210.                     colocarFichaAlNorte(fila, columna);
  211.  
  212.                 }
  213.                 if (sePuedeColocarFichaAlNoroeste(filaCorregida,
  214.                         columnaCorregida)) {
  215.  
  216.                     colocarFichaAlNoroeste(fila, columna);
  217.                 }
  218.                 if (sePuedeColocarFichaAlEste(filaCorregida, columnaCorregida)) {
  219.  
  220.                     colocarFichaAlEste(fila, columna);
  221.  
  222.                 }
  223.                 if (sePuedeColocarFichaAlSur(filaCorregida, columnaCorregida)) {
  224.  
  225.                     colocarFichaAlSur(fila, columna);
  226.  
  227.                 }
  228.                 if (sePuedeColocarFichaAlSudeste(filaCorregida,
  229.                         columnaCorregida)) {
  230.  
  231.                     colocarFichaAlSudeste(fila, columna);
  232.                 }
  233.  
  234.                 if (sePuedeColocarFichaAlSudoeste(filaCorregida,
  235.                         columnaCorregida)) {
  236.  
  237.                     colocarFichaAlSudoeste(fila, columna);
  238.                 }
  239.                 if (sePuedeColocarFichaAlNoreste(filaCorregida,
  240.                         columnaCorregida)) {
  241.  
  242.                     colocarFichaAlNoreste(fila, columna);
  243.                 }
  244.  
  245.                 turnoDeFichasNegras = !turnoDeFichasNegras;
  246.  
  247.             } else if (!turnoDeFichasNegras) {
  248.  
  249.                 tablero[filaCorregida][columnaCorregida] = Casillero.BLANCAS;
  250.                 if (sePuedeColocarFichaAlOeste(filaCorregida, columnaCorregida)) {
  251.  
  252.                     colocarFichaAlOeste(fila, columna);
  253.  
  254.                 }
  255.                 if (sePuedeColocarFichaAlNorte(filaCorregida, columnaCorregida)) {
  256.  
  257.                     colocarFichaAlNorte(fila, columna);
  258.  
  259.                 }
  260.                 if (sePuedeColocarFichaAlNoroeste(filaCorregida,
  261.                         columnaCorregida)) {
  262.  
  263.                     colocarFichaAlNoroeste(fila, columna);
  264.                 }
  265.                 if (sePuedeColocarFichaAlEste(filaCorregida, columnaCorregida)) {
  266.  
  267.                     colocarFichaAlEste(fila, columna);
  268.  
  269.                 }
  270.                 if (sePuedeColocarFichaAlSur(filaCorregida, columnaCorregida)) {
  271.  
  272.                     colocarFichaAlSur(fila, columna);
  273.  
  274.                 }
  275.                 if (sePuedeColocarFichaAlSudeste(filaCorregida,
  276.                         columnaCorregida)) {
  277.  
  278.                     colocarFichaAlSudeste(fila, columna);
  279.                 }
  280.                 if (sePuedeColocarFichaAlSudoeste(filaCorregida,
  281.                         columnaCorregida)) {
  282.  
  283.                     colocarFichaAlSudoeste(fila, columna);
  284.                 }
  285.                 if (sePuedeColocarFichaAlNoreste(filaCorregida,
  286.                         columnaCorregida)) {
  287.  
  288.                     colocarFichaAlNoreste(fila, columna);
  289.                 }
  290.  
  291.                 turnoDeFichasNegras = !turnoDeFichasNegras;
  292.  
  293.             }
  294.         }
  295.     }
  296.  
  297.     /**
  298.      * post: devuelve la cantidad de fichas negras en el tablero.
  299.      */
  300.     public int contarFichasNegras() {
  301.  
  302.         int cantidadDeFichasNegras = 0;
  303.         for (int i = 0; i < tablero.length; i++) {
  304.             for (int j = 0; j < tablero[i].length; j++) {
  305.                 if (tablero[i][j] == Casillero.NEGRAS) {
  306.  
  307.                     cantidadDeFichasNegras++;
  308.  
  309.                 }
  310.             }
  311.         }
  312.         return cantidadDeFichasNegras;
  313.     }
  314.  
  315.     /**
  316.      * post: devuelve la cantidad de fichas blancas en el tablero.
  317.      */
  318.     public int contarFichasBlancas() {
  319.  
  320.         int cantidadDeFichasBlancas = 0;
  321.         for (int i = 0; i < tablero.length; i++) {
  322.             for (int j = 0; j < tablero[i].length; j++) {
  323.                 if (tablero[i][j] == Casillero.BLANCAS) {
  324.  
  325.                     cantidadDeFichasBlancas++;
  326.  
  327.                 }
  328.             }
  329.         }
  330.         return cantidadDeFichasBlancas;
  331.     }
  332.  
  333.     /**
  334.      * post: indica si el juego terminó porque no existen casilleros vacíos o
  335.      * ninguno de los jugadores puede colocar una ficha.
  336.      */
  337.     public boolean termino() {
  338.  
  339.         boolean terminoElJuego = false;
  340.  
  341.         if (fichasTotales == (contarFichasBlancas() + contarFichasNegras())
  342.                 || (contarFichasBlancas() == 0 || contarFichasNegras() == 0) ||
  343.                 !puedeColocarElJugadorActual()) {
  344.  
  345.             terminoElJuego = true;
  346.         }
  347.  
  348.         return terminoElJuego;
  349.     }
  350.  
  351.     /**
  352.      * post: indica si el juego terminó y tiene un ganador.
  353.      */
  354.     public boolean hayGanador() {
  355.  
  356.         boolean hayUnGanador;
  357.  
  358.         if (ganoElJugadorDeLasFichasBlancas()
  359.                 || ganoElJugadorDeLasFichasNegras() && termino() == true) {
  360.  
  361.             hayUnGanador = true;
  362.  
  363.         } else {
  364.  
  365.             hayUnGanador = false;
  366.         }
  367.  
  368.         return hayUnGanador;
  369.     }
  370.  
  371.     /**
  372.      * pre : el juego terminó. post: devuelve el nombre del jugador que ganó el
  373.      * juego.
  374.      */
  375.     public String obtenerGanador() {
  376.  
  377.         String ganador = null;
  378.         if (termino() == true && hayGanador() == true) {
  379.  
  380.             if (ganoElJugadorDeLasFichasNegras()) {
  381.  
  382.                 ganador = jugadorConFichasNegras;
  383.  
  384.             } else if (ganoElJugadorDeLasFichasBlancas()) {
  385.  
  386.                 ganador = jugadorConFichasBlancas;
  387.             }
  388.         }
  389.         return ganador;
  390.     }
  391.  
  392.     /**
  393.      * post: Devuelve si gano el jugador de las fichas negras.
  394.      */
  395.  
  396.     private boolean ganoElJugadorDeLasFichasNegras() {
  397.  
  398.         boolean ganoLasFichasNegras = false;
  399.  
  400.         if ((contarFichasBlancas() < contarFichasNegras() || contarFichasBlancas() == 0)
  401.                 && termino() == true) {
  402.  
  403.             ganoLasFichasNegras = true;
  404.         }
  405.  
  406.         return ganoLasFichasNegras;
  407.     }
  408.  
  409.     /**
  410.      * post: Devuelve si gano el jugador de las fichas blancas.
  411.      */
  412.  
  413.     private boolean ganoElJugadorDeLasFichasBlancas() {
  414.  
  415.         boolean ganoLasFichasBlancas = false;
  416.  
  417.         if ((contarFichasNegras() < contarFichasBlancas() || contarFichasNegras() == 0)
  418.                 && termino() == true) {
  419.  
  420.             ganoLasFichasBlancas = true;
  421.         }
  422.  
  423.         return ganoLasFichasBlancas;
  424.     }
  425.  
  426.     /**
  427.      * post: Evalua cual es el color de la ficha que esta
  428.      * jugando actualmente.
  429.      */
  430.    
  431.     private Casillero colorDeLaFichaActual() {
  432.  
  433.         Casillero colorActual = Casillero.NEGRAS;
  434.         if (!turnoDeFichasNegras) {
  435.  
  436.             colorActual = Casillero.BLANCAS;
  437.         }
  438.         return colorActual;
  439.     }
  440.  
  441.     /**
  442.      * post: Evalua si se puede colocar ficha al Oeste de la posicion
  443.      */
  444.     private boolean sePuedeColocarFichaAlOeste(int fila, int columna) {
  445.  
  446.         int columnaActual = columna + 1;
  447.         boolean puedeColocar = false;
  448.  
  449.         while (columnaActual <= tamanio
  450.                 && tablero[fila][columnaActual] != Casillero.LIBRE
  451.                 && tablero[fila][columnaActual] != colorDeLaFichaActual()) {
  452.  
  453.             columnaActual++;
  454.  
  455.             if (tablero[fila][columnaActual] == colorDeLaFichaActual()) {
  456.  
  457.                 puedeColocar = true;
  458.             }
  459.         }
  460.         return puedeColocar;
  461.     }
  462.  
  463.     /**
  464.      * post: Evalua si se puede colocar ficha al Norte de la posicion
  465.      */
  466.     private boolean sePuedeColocarFichaAlNorte(int fila, int columna) {
  467.  
  468.         int filaActual = fila + 1;
  469.         boolean puedeColocar = false;
  470.  
  471.         while (filaActual <= tamanio
  472.                 && tablero[filaActual][columna] != Casillero.LIBRE
  473.                 && tablero[filaActual][columna] != colorDeLaFichaActual()) {
  474.  
  475.             filaActual++;
  476.  
  477.             if (tablero[filaActual][columna] == colorDeLaFichaActual()) {
  478.  
  479.                 puedeColocar = true;
  480.             }
  481.         }
  482.         return puedeColocar;
  483.     }
  484.  
  485.     /**
  486.      * post: Evalua si se puede colocar ficha al sur de la posicion
  487.      */
  488.     private boolean sePuedeColocarFichaAlNoroeste(int fila, int columna) {
  489.  
  490.         int filaActual = fila + 1;
  491.         int columnaActual = columna + 1;
  492.         boolean puedeColocar = false;
  493.  
  494.         while (filaActual <= tamanio && columnaActual <= tamanio
  495.                 && tablero[filaActual][columnaActual] != Casillero.LIBRE
  496.                 && tablero[filaActual][columnaActual] != colorDeLaFichaActual()) {
  497.  
  498.             filaActual++;
  499.             columnaActual++;
  500.  
  501.             if (tablero[filaActual][columnaActual] == colorDeLaFichaActual()) {
  502.  
  503.                 puedeColocar = true;
  504.             }
  505.         }
  506.         return puedeColocar;
  507.     }
  508.  
  509.     private boolean sePuedeColocarFichaAlSur(int fila, int columna) {
  510.  
  511.         boolean puedeColocar = false;
  512.         int filaActual = fila - 1;
  513.  
  514.         while (filaActual > 0
  515.                 && tablero[filaActual][columna] != Casillero.LIBRE
  516.                 && tablero[filaActual][columna] != colorDeLaFichaActual()) {
  517.  
  518.             filaActual--;
  519.  
  520.             if (tablero[filaActual][columna] == colorDeLaFichaActual()) {
  521.  
  522.                 puedeColocar = true;
  523.             }
  524.         }
  525.  
  526.         return puedeColocar;
  527.     }
  528.    
  529.     /**
  530.      * post: Evalua si se puede colocar ficha al este de la posicion
  531.      */
  532.     private boolean sePuedeColocarFichaAlEste(int fila, int columna) {
  533.  
  534.         int columnaActual = columna - 1;
  535.         boolean puedeColocar = false;
  536.  
  537.         while (columnaActual > 0
  538.                 && tablero[fila][columnaActual] != Casillero.LIBRE
  539.                 && tablero[fila][columnaActual] != colorDeLaFichaActual()) {
  540.  
  541.             columnaActual--;
  542.  
  543.             if (tablero[fila][columnaActual] == colorDeLaFichaActual()) {
  544.  
  545.                 puedeColocar = true;
  546.             }
  547.         }
  548.  
  549.         return puedeColocar;
  550.     }
  551.  
  552.     /**
  553.      * post: Evalua si se puede colocar ficha al sudeste de la posicion
  554.      */
  555.     private boolean sePuedeColocarFichaAlSudeste(int fila, int columna) {
  556.  
  557.         boolean puedeColocar = false;
  558.         int columnaActual = columna - 1;
  559.         int filaActual = fila - 1;
  560.  
  561.         while (columnaActual > 0 && filaActual > 0
  562.                 && tablero[filaActual][columnaActual] != Casillero.LIBRE
  563.                 && tablero[filaActual][columnaActual] != colorDeLaFichaActual()) {
  564.  
  565.             columnaActual--;
  566.             filaActual--;
  567.  
  568.             if (tablero[filaActual][columnaActual] == colorDeLaFichaActual()) {
  569.  
  570.                 puedeColocar = true;
  571.             }
  572.         }
  573.         return puedeColocar;
  574.     }
  575.  
  576.     /**
  577.      * post: Evalua si se puede colocar ficha al Sudoeste de la posicion
  578.      */
  579.     private boolean sePuedeColocarFichaAlSudoeste(int fila, int columna) {
  580.  
  581.         boolean puedeColocar = false;
  582.         int columnaActual = columna + 1;
  583.         int filaActual = fila - 1;
  584.  
  585.         while (columnaActual < tamanio && filaActual > 0
  586.                 && tablero[filaActual][columnaActual] != Casillero.LIBRE
  587.                 && tablero[filaActual][columnaActual] != colorDeLaFichaActual()) {
  588.  
  589.             columnaActual++;
  590.             filaActual--;
  591.  
  592.             if (tablero[filaActual][columnaActual] == colorDeLaFichaActual()) {
  593.  
  594.                 puedeColocar = true;
  595.             }
  596.         }
  597.         return puedeColocar;
  598.     }
  599.  
  600.     /**
  601.      * post: Evalua si se puede colocar ficha al Noreste de la posicion
  602.      */
  603.     private boolean sePuedeColocarFichaAlNoreste(int fila, int columna) {
  604.  
  605.         boolean puedeColocar = false;
  606.         int columnaActual = columna - 1;
  607.         int filaActual = fila + 1;
  608.  
  609.         while (columnaActual > 0 && filaActual < tamanio
  610.                 && tablero[filaActual][columnaActual] != Casillero.LIBRE
  611.                 && tablero[filaActual][columnaActual] != colorDeLaFichaActual()) {
  612.  
  613.             columnaActual--;
  614.             filaActual++;
  615.  
  616.             if (tablero[filaActual][columnaActual] == colorDeLaFichaActual()) {
  617.  
  618.                 puedeColocar = true;
  619.             }
  620.         }
  621.         return puedeColocar;
  622.     }
  623.  
  624.     /**
  625.      * post: si la posicion del casillero es valida coloca ficha en
  626.      * el casillero posicionado al oeste
  627.      */
  628.     private void colocarFichaAlOeste(int fila, int columna) {
  629.  
  630.         int filaCorregida = fila - 1;
  631.         int columnaCorregida = columna - 1;
  632.         int j = 1;
  633.  
  634.         while (columnaCorregida + j < tamanio
  635.                 && tablero[filaCorregida][columnaCorregida + j] != colorDeLaFichaActual()) {
  636.  
  637.             tablero[filaCorregida][columnaCorregida + j] = colorDeLaFichaActual();
  638.             j++;
  639.         }
  640.     }
  641.  
  642.     /**
  643.      * post: si la posicion del casillero es valida coloca ficha en
  644.      * el casillero posicionado al norte
  645.      */
  646.  
  647.     private void colocarFichaAlNorte(int fila, int columna) {
  648.  
  649.         int filaCorregida = fila - 1;
  650.         int columnaCorregida = columna - 1;
  651.         int j = 1;
  652.  
  653.         while (filaCorregida + j < tamanio
  654.                 && tablero[filaCorregida + j][columnaCorregida] != colorDeLaFichaActual()) {
  655.  
  656.             tablero[filaCorregida + j][columnaCorregida] = colorDeLaFichaActual();
  657.             j++;
  658.         }
  659.     }
  660.    
  661.     /**
  662.      * post: si la posicion del casillero es valida coloca ficha en
  663.      * el casillero posicionado al noroeste
  664.      */
  665.    
  666.     private void colocarFichaAlNoroeste(int fila, int columna) {
  667.  
  668.         int filaCorregida = fila - 1;
  669.         int columnaCorregida = columna - 1;
  670.         int j = 1;
  671.  
  672.         while (filaCorregida + j < tamanio
  673.                 && columnaCorregida + j < tamanio
  674.                 && tablero[filaCorregida + j][columnaCorregida + j] != colorDeLaFichaActual()) {
  675.  
  676.             tablero[filaCorregida + j][columnaCorregida + j] = colorDeLaFichaActual();
  677.             j++;
  678.         }
  679.     }
  680.  
  681.     /**
  682.      * post: si la posicion del casillero es valida coloca ficha en
  683.      * el casillero posicionado al este
  684.      */
  685.     private void colocarFichaAlEste(int fila, int columna) {
  686.  
  687.         int filaCorregida = fila - 1;
  688.         int columnaCorregida = columna - 1;
  689.         int j = 1;
  690.  
  691.         while (tablero[filaCorregida][columnaCorregida - j] != colorDeLaFichaActual()
  692.                 && columnaCorregida - j > 0) {
  693.  
  694.             tablero[filaCorregida][columnaCorregida - j] = colorDeLaFichaActual();
  695.             j++;
  696.         }
  697.     }
  698.  
  699.      /**
  700.      * post: si la posicion del casillero es valida coloca ficha en
  701.      * el casillero posicionado al sur
  702.      */
  703.     private void colocarFichaAlSur(int fila, int columna) {
  704.  
  705.         int filaCorregida = fila - 1;
  706.         int columnaCorregida = columna - 1;
  707.         int j = 1;
  708.  
  709.         while (filaCorregida - j >= 0
  710.                 && tablero[filaCorregida - j][columnaCorregida] != colorDeLaFichaActual()) {
  711.  
  712.             tablero[filaCorregida - j][columnaCorregida] = colorDeLaFichaActual();
  713.             j++;
  714.         }
  715.     }
  716.    
  717.  
  718.     /**
  719.      * post: si la posicion del casillero es valida coloca ficha en
  720.      * el casillero posicionado al sudeste
  721.      */
  722.     private void colocarFichaAlSudeste(int fila, int columna) {
  723.  
  724.         int filaCorregida = fila - 1;
  725.         int columnaCorregida = columna - 1;
  726.         int j = 1;
  727.  
  728.         while (tablero[filaCorregida - j][columnaCorregida - j] != colorDeLaFichaActual()
  729.                 && filaCorregida - j > 0 && columnaCorregida - j > 0) {
  730.  
  731.             tablero[filaCorregida - j][columnaCorregida - j] = colorDeLaFichaActual();
  732.             j++;
  733.         }
  734.     }
  735.  
  736.      /**
  737.      * post: si la posicion del casillero es valida coloca ficha en
  738.      * el casillero posicionado al sudoeste
  739.      */
  740.     private void colocarFichaAlSudoeste(int fila, int columna) {
  741.  
  742.         int filaCorregida = fila - 1;
  743.         int columnaCorregida = columna - 1;
  744.         int j = 1;
  745.  
  746.         while (tablero[filaCorregida - j][columnaCorregida + j] != colorDeLaFichaActual()
  747.                 && filaCorregida - j > 0 && columnaCorregida + j < tamanio) {
  748.  
  749.             tablero[filaCorregida - j][columnaCorregida + j] = colorDeLaFichaActual();
  750.             j++;
  751.         }
  752.     }
  753.  
  754.     /**
  755.      * post: si la posicion del casillero es valida coloca ficha en
  756.      * el casillero posicionado al Noreste
  757.      */
  758.     private void colocarFichaAlNoreste(int fila, int columna) {
  759.  
  760.         int filaCorregida = fila - 1;
  761.         int columnaCorregida = columna - 1;
  762.         int j = 1;
  763.  
  764.         while (filaCorregida + j < tamanio
  765.                 && columnaCorregida - j > 0
  766.                 && tablero[filaCorregida + j][columnaCorregida - j] != colorDeLaFichaActual()) {
  767.  
  768.             tablero[filaCorregida + j][columnaCorregida - j] = colorDeLaFichaActual();
  769.             j++;
  770.         }
  771.     }
  772.  
  773.     /**
  774.      * post: devuelve si los dos jugadores pueden colocar ficha.
  775.      */
  776.     private boolean puedeColocarElJugadorActual() {
  777.  
  778.         boolean puedenColocarLosJugadores [][];
  779.         boolean puedeColocar = true;
  780.         int jugadasNoValidas = 0;
  781.  
  782.         puedenColocarLosJugadores = new boolean[tamanio][tamanio];
  783.        
  784.         for (int i = 1; i < tamanio; i++) {
  785.             for (int j = 1; j < tamanio; j++) {
  786.  
  787.                 puedenColocarLosJugadores[i][j] = true;
  788.             }
  789.         }
  790.        
  791.         for (int i = 1; i < tamanio; i++) {
  792.             for (int j = 1; j < tamanio; j++) {
  793.                 if (!puedeColocarFicha(i, j)){
  794.                
  795.                     puedenColocarLosJugadores[i][j] = false;
  796.                     jugadasNoValidas++;
  797.                 }  
  798.             }
  799.         }
  800.        
  801.         if (jugadasNoValidas == ((tamanio*tamanio) - (contarFichasBlancas() + contarFichasNegras()))){
  802.            
  803.             puedeColocar = false;
  804.         }
  805.        
  806.         return puedeColocar;
  807.     }
  808.  
  809.     /*
  810.      * metodo utilizado para hacer pruebas.
  811.      */
  812.  
  813.     public void setCasillero(int fila, int columna, Casillero casilleroColor) {
  814.  
  815.         tablero[fila - 1][columna - 1] = casilleroColor;
  816.  
  817.     }
  818. }
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!