API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 16th, 2018
87
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 25.74 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; // Arreglo que contiene que ficha hay en cada
  14. // Casillero
  15.  
  16. private boolean[][] jugadasValidas; // Arreglo que indica si es posible o no
  17. // colocar una ficha
  18.  
  19. private boolean turnoDeNegras = true;
  20.  
  21. private String jugadorDeFichasNegras;
  22. private String jugadorDeFichasBlancas;
  23.  
  24. /**
  25. * pre : 'dimension' es un número par, mayor o igual a 4. post: empieza el
  26. * juego entre el jugador que tiene fichas negras, identificado como
  27. * 'fichasNegras' y el jugador que tiene fichas blancas, identificado como
  28. * 'fichasBlancas'. El tablero tiene 4 fichas: 2 negras y 2 blancas. Estas
  29. * fichas están intercaladas en el centro del tablero.
  30. *
  31. * @param dimensionTablero
  32. * : cantidad de filas y columnas que tiene el tablero.
  33. * @param fichasNegras
  34. * : nombre del jugador con fichas negras.
  35. * @param fichasBlancas
  36. * : nombre del jugador con fichas blancas.
  37. */
  38. public Reversi(int dimensionTablero, String fichasNegras,
  39. String fichasBlancas) {
  40.  
  41. verificarSiElTableroEsMenorA10MayorA4YPar(dimensionTablero);
  42.  
  43. verificarQueLosNombresDeLosJugadoresNoSeasIguales(fichasNegras,
  44. fichasBlancas);
  45.  
  46. verificarQueAmbosJugaresTenganUnNombre(fichasNegras, fichasBlancas);
  47.  
  48. jugadorDeFichasBlancas = fichasBlancas;
  49. jugadorDeFichasNegras = fichasNegras;
  50.  
  51. /*
  52. * tablero debe tener misma cantidad de filas que de columnas
  53. */
  54.  
  55. tablero = new Casillero[dimensionTablero][dimensionTablero];
  56.  
  57. /*
  58. * jugadasValidas debe ser una copia de tablero
  59. */
  60.  
  61. jugadasValidas = new boolean[dimensionTablero][dimensionTablero];
  62.  
  63. /*
  64. * Inicializo el tablero con todas los casilleros en libre y en el medio
  65. * dos fichas blancas y dos fichas negras, tal cual lo indica las reglas
  66. * para comenzar una partida.
  67. */
  68.  
  69. for (int i = 0; i < dimensionTablero; i++) {
  70. for (int j = 0; j < dimensionTablero; j++) {
  71. tablero[i][j] = Casillero.LIBRE;
  72.  
  73. }
  74. }
  75.  
  76. tablero[(dimensionTablero / 2) - 1][(dimensionTablero / 2) - 1] = Casillero.BLANCAS;
  77. tablero[(dimensionTablero / 2)][(dimensionTablero / 2)] = Casillero.BLANCAS;
  78. tablero[(dimensionTablero / 2)][(dimensionTablero / 2) - 1] = Casillero.NEGRAS;
  79. tablero[(dimensionTablero / 2) - 1][(dimensionTablero / 2)] = Casillero.NEGRAS;
  80.  
  81. /*
  82. * inicializo las posiciones para poder colocar fichas en falso.
  83. */
  84.  
  85. for (int i = 0; i < dimensionTablero; i++) {
  86. for (int j = 0; j < dimensionTablero; j++) {
  87. jugadasValidas[i][j] = false;
  88.  
  89. }
  90. }
  91.  
  92. }
  93.  
  94. /**
  95. * post: devuelve la cantidad de filas que tiene el tablero.
  96. */
  97. public int contarFilas() {
  98.  
  99. return tablero.length;
  100. }
  101.  
  102. /**
  103. * post: devuelve la cantidad de columnas que tiene el tablero.
  104. */
  105. public int contarColumnas() {
  106.  
  107. return tablero.length;
  108. }
  109.  
  110. /**
  111. * post: devuelve el nombre del jugador que debe colocar una ficha o null si
  112. * terminó el juego.
  113. */
  114. public String obtenerJugadorActual() {
  115. String turnoActual;
  116. turnoActual = jugadorDeFichasNegras;
  117. if (!turnoDeNegras) {
  118. turnoActual = jugadorDeFichasBlancas;
  119. }
  120. return turnoActual;
  121. }
  122.  
  123. /**
  124. * pre : fila está en el intervalo [1, contarFilas()], columnas está en el
  125. * intervalo [1, contarColumnas()]. post: indica quién tiene la posesión del
  126. * casillero dado por fila y columna.
  127. *
  128. * @param fila
  129. * @param columna
  130. */
  131. public Casillero obtenerCasillero(int fila, int columna) {
  132.  
  133. int filaCorregida = fila - 1;
  134. int columnaCorregida = columna - 1;
  135.  
  136. return tablero[filaCorregida][columnaCorregida];
  137. }
  138.  
  139. public boolean puedeColocarFicha(int fila, int columna) {
  140.  
  141. int filaCorregida = fila - 1;
  142.  
  143. int columnaCorregida = columna - 1;
  144.  
  145. reiniciarPosibilidadesDeColocarfichas();
  146.  
  147. if (turnoDeNegras) {
  148.  
  149. validarJugadasPosibles(Casillero.NEGRAS);
  150.  
  151. } else {
  152.  
  153. validarJugadasPosibles(Casillero.BLANCAS);
  154. }
  155.  
  156. quitarLaPosibilidadDePonerFichasEncimaDeOtras();
  157.  
  158. return jugadasValidas[filaCorregida][columnaCorregida];
  159. }
  160.  
  161. private void validarCasillero(int fila, int columna) {
  162.  
  163. jugadasValidas[fila][columna] = true;
  164.  
  165. }
  166.  
  167. private void validarJugadasPosibles(Casillero fichaUtilizada) {
  168.  
  169. validarCasilleroParaConvertirFichasHaciaElEste(fichaUtilizada);
  170. validarCasilleroParaConvertirFichasHaciaElOeste(fichaUtilizada);
  171. validarCasilleroParaConvertirFichasHaciaElSur(fichaUtilizada);
  172. validarCasilleroParaConvertirFichasHaciaElNorte(fichaUtilizada);
  173. validarCasilleroParaConvertirFichasHaciaElSurOeste(fichaUtilizada);
  174. validarCasilleroParaConvertirFichasHaciaElSurEste(fichaUtilizada);
  175. validarCasilleroParaConvertirFichasHaciaElNorOeste(fichaUtilizada);
  176. validarCasilleroParaConvertirFichasHaciaElNorEste(fichaUtilizada);
  177.  
  178. }
  179.  
  180. private void verificarQueLosNombresDeLosJugadoresNoSeasIguales(
  181. String nombreDeFichasNegras, String nombreDeFichasBlancas) {
  182.  
  183. if (nombreDeFichasNegras.equals(nombreDeFichasBlancas)
  184. || nombreDeFichasBlancas.equals(nombreDeFichasNegras)) {
  185. Error jugadoresConElMismoNombre = new Error(
  186. "Los jugadores no pueden tener el mismo nombre.");
  187. throw jugadoresConElMismoNombre;
  188. }
  189. }
  190.  
  191. private void verificarQueAmbosJugaresTenganUnNombre(
  192. String nombreDeFichasNegras, String nombreDeFichasBlancas) {
  193.  
  194. if (nombreDeFichasNegras.equals("") || nombreDeFichasBlancas.equals("")) {
  195. Error jugadorSinNombre = new Error(
  196. "Ambos jugadores deben tener nombre");
  197. throw jugadorSinNombre;
  198. }
  199.  
  200. }
  201.  
  202. private void verificarSiElTableroEsMenorA10MayorA4YPar(int dimensionTablero) {
  203.  
  204. if ((dimensionTablero % 2 == 1)
  205. || ((dimensionTablero > 10) || (dimensionTablero < 4))) {
  206.  
  207. Error tamanioInvalido = new Error(
  208. "El tamaño debe ser mayor a 4 y menor a 10 y ser par.");
  209. throw tamanioInvalido;
  210. }
  211.  
  212. }
  213.  
  214. private void reiniciarPosibilidadesDeColocarfichas() {
  215.  
  216. for (int i = 0; i < tablero.length; i++) {
  217. for (int j = 0; j < tablero.length; j++) {
  218. jugadasValidas[i][j] = false;
  219.  
  220. }
  221. }
  222. }
  223.  
  224. private void quitarLaPosibilidadDePonerFichasEncimaDeOtras() {
  225.  
  226. for (int i = 0; i < tablero.length; i++) {
  227. for (int j = 0; j < tablero.length; j++) {
  228.  
  229. if (tablero[i][j] != Casillero.LIBRE) {
  230.  
  231. jugadasValidas[i][j] = false;
  232. }
  233. }
  234. }
  235.  
  236. }
  237.  
  238. // METODOS DESDE EL CLICK HACIA EL ESTE
  239.  
  240. private void validarCasilleroParaConvertirFichasHaciaElEste(
  241. Casillero fichaUtilizada) {
  242.  
  243. for (int i = 0; i < tablero.length; i++) {
  244. for (int j = 0; j < tablero.length; j++) {
  245.  
  246. if (tablero[i][j] != fichaUtilizada
  247. && tablero[i][j] != Casillero.LIBRE) {
  248.  
  249. if (j > 0) {
  250.  
  251. if (escanearAlEsteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlfinalUnaPropia(
  252. i, j - 1, fichaUtilizada)) {
  253.  
  254. validarCasillero(i, j - 1);
  255. }
  256. }
  257. }
  258.  
  259. }
  260. }
  261.  
  262. }
  263.  
  264. private boolean escanearAlEsteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlfinalUnaPropia(
  265. int fila, int columna, Casillero fichaUtilizada) {
  266.  
  267. boolean respuesta = false;
  268.  
  269. for (int i = 1; i < tablero.length - columna; i++) {
  270.  
  271. if (tablero[fila][columna + i] != fichaUtilizada
  272. && tablero[fila][columna + i] != Casillero.LIBRE) {
  273.  
  274. } else if (tablero[fila][columna + i] == Casillero.LIBRE) {
  275.  
  276. i = tablero.length - columna; // finalizo el for
  277.  
  278. } else if (tablero[fila][columna + i] == fichaUtilizada) {
  279.  
  280. respuesta = true;
  281.  
  282. }
  283.  
  284. }
  285. return respuesta;
  286.  
  287. }
  288.  
  289. private void convertirDesdeLaPosicionIndicadaHaciaElEsteFichasContrariasEnPropiasHastaEncontrarUnaPropia(
  290. int fila, int columna, Casillero fichaUtilizada) {
  291.  
  292. int distanciaEntreCasilleros = 1;
  293.  
  294. if (escanearAlEsteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlfinalUnaPropia(
  295. fila, columna, fichaUtilizada)) {
  296.  
  297. while (tablero[fila][columna + distanciaEntreCasilleros] != fichaUtilizada) {
  298.  
  299. tablero[fila][columna + distanciaEntreCasilleros] = fichaUtilizada;
  300.  
  301. tablero[fila][columna] = fichaUtilizada;
  302.  
  303. distanciaEntreCasilleros++;
  304.  
  305. }
  306. }
  307. }
  308.  
  309. // METODOS DESDE EL CLICK HACIA EL OESTE
  310.  
  311. private void validarCasilleroParaConvertirFichasHaciaElOeste(
  312. Casillero fichaUtilizada) {
  313.  
  314. for (int i = 0; i < tablero.length; i++) {
  315. for (int j = 0; j < tablero.length; j++) {
  316.  
  317. if (tablero[i][j] != fichaUtilizada
  318. && tablero[i][j] != Casillero.LIBRE) {
  319.  
  320. if (j < tablero.length - 1) {
  321.  
  322. if (escanearAlOesteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  323. i, j + 1, fichaUtilizada)) {
  324.  
  325. validarCasillero(i, j + 1);
  326. }
  327. }
  328. }
  329.  
  330. }
  331. }
  332.  
  333. }
  334.  
  335. private boolean escanearAlOesteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  336. int fila, int columna, Casillero fichaUtilizada) {
  337.  
  338. boolean respuesta = false;
  339.  
  340. for (int i = 1; i <= columna; i++) {
  341.  
  342. if (tablero[fila][columna - i] != fichaUtilizada
  343. && tablero[fila][columna - i] != Casillero.LIBRE) {
  344.  
  345. } else if (tablero[fila][columna - i] == Casillero.LIBRE) {
  346.  
  347. i = columna; // finalizo el for
  348. } else if (tablero[fila][columna - i] == fichaUtilizada) {
  349.  
  350. respuesta = true;
  351.  
  352. }
  353.  
  354. }
  355. return respuesta;
  356. }
  357.  
  358. private void convertirDesdeLaPosicionIndicadaHaciaElOesteFichasContrariasEnPropiasHastaEncontrarUnaPropia(
  359. int fila, int columna, Casillero fichaUtilizada) {
  360.  
  361. int distanciaEntreCasilleros = 1;
  362.  
  363. if (escanearAlOesteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  364. fila, columna, fichaUtilizada)) {
  365.  
  366. while (tablero[fila][columna - distanciaEntreCasilleros] != fichaUtilizada) {
  367.  
  368. tablero[fila][columna - distanciaEntreCasilleros] = fichaUtilizada;
  369.  
  370. tablero[fila][columna] = fichaUtilizada;
  371.  
  372. distanciaEntreCasilleros++;
  373.  
  374. }
  375. }
  376. }
  377.  
  378. // METODOS DESDE EL CLICK HACIA EL SUR
  379.  
  380. private void validarCasilleroParaConvertirFichasHaciaElSur(
  381. Casillero fichaUtilizada) {
  382.  
  383. for (int i = 0; i < tablero.length; i++) {
  384. for (int j = 0; j < tablero.length; j++) {
  385.  
  386. if (tablero[i][j] != fichaUtilizada
  387. && tablero[i][j] != Casillero.LIBRE) {
  388.  
  389. if (i > 0) {
  390.  
  391. if (escanearAlSurDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  392. i - 1, j, fichaUtilizada)) {
  393.  
  394. validarCasillero(i - 1, j);
  395.  
  396. }
  397. }
  398. }
  399.  
  400. }
  401. }
  402.  
  403. }
  404.  
  405. private boolean escanearAlSurDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  406. int fila, int columna, Casillero fichaUtilizada) {
  407.  
  408. boolean respuesta = false;
  409.  
  410. for (int i = 1; i < tablero.length - fila; i++) {
  411.  
  412. if (tablero[fila + i][columna] != fichaUtilizada
  413. && tablero[fila + i][columna] != Casillero.LIBRE) {
  414.  
  415. } else if (tablero[fila + i][columna] == Casillero.LIBRE) {
  416.  
  417. i = tablero.length - fila; // finalizo el for
  418.  
  419. } else if (tablero[fila + i][columna] == fichaUtilizada) {
  420.  
  421. respuesta = true;
  422.  
  423. }
  424. }
  425. return respuesta;
  426. }
  427.  
  428. private void convertirDesdeLaPosicionIndicadaHaciaElSurFichasContrariasEnPropiasHastaEncontrarUnaPropia(
  429. int fila, int columna,
  430.  
  431. Casillero fichaUtilizada) {
  432.  
  433. int distanciaEntreCasilleros = 1;
  434.  
  435. if (escanearAlSurDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  436. fila, columna, fichaUtilizada)) {
  437.  
  438. while (tablero[fila + distanciaEntreCasilleros][columna] != fichaUtilizada) {
  439.  
  440. tablero[fila + distanciaEntreCasilleros][columna] = fichaUtilizada;
  441.  
  442. tablero[fila][columna] = fichaUtilizada;
  443.  
  444. distanciaEntreCasilleros++;
  445.  
  446. }
  447. }
  448. }
  449.  
  450. // METODOS DESDE EL CLICK PARA CONVERTIR HACIA EL NORTE
  451.  
  452. private void validarCasilleroParaConvertirFichasHaciaElNorte(
  453. Casillero fichaUtilizada) {
  454.  
  455. for (int i = 0; i < tablero.length; i++) {
  456. for (int j = 0; j < tablero.length; j++) {
  457.  
  458. if (tablero[i][j] != fichaUtilizada
  459. && tablero[i][j] != Casillero.LIBRE) {
  460.  
  461. if (i < tablero.length - 1) {
  462.  
  463. if (escanearAlNorteDeLaPosicionIndicadaEnLosParametroslSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  464. i + 1, j, fichaUtilizada))
  465.  
  466. validarCasillero(i + 1, j);
  467. }
  468. }
  469.  
  470. }
  471. }
  472.  
  473. }
  474.  
  475. private boolean escanearAlNorteDeLaPosicionIndicadaEnLosParametroslSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  476. int fila, int columna, Casillero fichaUtilizada) {
  477.  
  478. boolean respuesta = false;
  479.  
  480. for (int i = 1; i <= fila; i++) {
  481.  
  482. if (tablero[fila - i][columna] != fichaUtilizada
  483. && tablero[fila - i][columna] != Casillero.LIBRE) {
  484.  
  485. } else if (tablero[fila - i][columna] == Casillero.LIBRE) {
  486.  
  487. i = fila; // finalizo el for
  488. } else if (tablero[fila - i][columna] == fichaUtilizada) {
  489.  
  490. respuesta = true;
  491.  
  492. }
  493.  
  494. }
  495.  
  496. return respuesta;
  497. }
  498.  
  499. private void convertirDesdeLaPosicionIndicadaHaciaElNorteFichasContrariasEnPropiasHastaEncontrarUnaPropia(
  500. int fila, int columna,
  501.  
  502. Casillero fichaUtilizada) {
  503.  
  504. int distanciaEntreCasilleros = 1;
  505.  
  506. if (escanearAlNorteDeLaPosicionIndicadaEnLosParametroslSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  507. fila, columna, fichaUtilizada)) {
  508.  
  509. while (tablero[fila - distanciaEntreCasilleros][columna] != fichaUtilizada) {
  510.  
  511. tablero[fila - distanciaEntreCasilleros][columna] = fichaUtilizada;
  512.  
  513. tablero[fila][columna] = fichaUtilizada;
  514.  
  515. distanciaEntreCasilleros++;
  516.  
  517. }
  518. }
  519. }
  520.  
  521. // METODOS DESDE EL CLICK PARA CONVERTIR HACIA EL SUR OESTE
  522.  
  523. private void validarCasilleroParaConvertirFichasHaciaElSurOeste(
  524. Casillero fichaUtilizada) {
  525.  
  526. for (int i = 0; i < tablero.length; i++) {
  527. for (int j = 0; j < tablero.length; j++) {
  528.  
  529. if (tablero[i][j] != fichaUtilizada
  530. && tablero[i][j] != Casillero.LIBRE) {
  531.  
  532. if (i > 0 && j < tablero.length - 1) {
  533.  
  534. if (escanearAlSurOesteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  535. i - 1, j + 1, fichaUtilizada)) {
  536.  
  537. validarCasillero(i - 1, j + 1);
  538. }
  539. }
  540. }
  541.  
  542. }
  543. }
  544.  
  545. }
  546.  
  547. private boolean escanearAlSurOesteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  548. int fila, int columna, Casillero fichaUtilizada) {
  549.  
  550. boolean respuesta = false;
  551.  
  552. for (int i = 1; i <= columna && i < tablero.length - fila; i++) {
  553.  
  554. if (tablero[fila + i][columna - i] != fichaUtilizada
  555. && tablero[fila + i][columna - i] != Casillero.LIBRE) {
  556.  
  557. } else if (tablero[fila + i][columna - i] == Casillero.LIBRE) {
  558.  
  559. i = columna; // finalizo el for
  560. } else if (tablero[fila + i][columna - i] == fichaUtilizada) {
  561.  
  562. respuesta = true;
  563.  
  564. }
  565.  
  566. }
  567. return respuesta;
  568. }
  569.  
  570. private void convertirDesdeLaPosicionIndicadaHaciaElSurOesteFichasContrariasEnPropiasHastaEncontrarUnaPropia(
  571. int fila, int columna, Casillero fichaUtilizada) {
  572.  
  573. int distanciaEntreCasilleros = 1;
  574.  
  575. if (escanearAlSurOesteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  576. fila, columna, fichaUtilizada)) {
  577.  
  578. while (tablero[fila + distanciaEntreCasilleros][columna
  579. - distanciaEntreCasilleros] != fichaUtilizada) {
  580.  
  581. tablero[fila + distanciaEntreCasilleros][columna
  582. - distanciaEntreCasilleros] = fichaUtilizada;
  583.  
  584. tablero[fila][columna] = fichaUtilizada;
  585.  
  586. distanciaEntreCasilleros++;
  587.  
  588. }
  589. }
  590. }
  591.  
  592. // METODOS DESDE EL CLICK PARA CONVERTIR HACIA EL SUR ESTE
  593.  
  594. private void validarCasilleroParaConvertirFichasHaciaElSurEste(
  595. Casillero fichaUtilizada) {
  596.  
  597. for (int i = 0; i < tablero.length; i++) {
  598. for (int j = 0; j < tablero.length; j++) {
  599.  
  600. if (tablero[i][j] != fichaUtilizada
  601. && tablero[i][j] != Casillero.LIBRE) {
  602.  
  603. if (i > 0 && j > 0) {
  604.  
  605. if (escanearAlSurEsteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  606. i - 1, j - 1, fichaUtilizada)) {
  607.  
  608. validarCasillero(i - 1, j - 1);
  609.  
  610. }
  611. }
  612. }
  613.  
  614. }
  615. }
  616.  
  617. }
  618.  
  619. private boolean escanearAlSurEsteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  620. int fila, int columna, Casillero fichaUtilizada) {
  621.  
  622. boolean respuesta = false;
  623.  
  624. for (int i = 1; i < tablero.length - fila
  625. && i < tablero.length - columna; i++) {
  626.  
  627. if (tablero[fila + i][columna + i] != fichaUtilizada
  628. && tablero[fila + i][columna + i] != Casillero.LIBRE) {
  629.  
  630. } else if (tablero[fila + i][columna + i] == Casillero.LIBRE) {
  631.  
  632. i = tablero.length - columna; // finalizo el for
  633. } else if (tablero[fila + i][columna + i] == fichaUtilizada) {
  634.  
  635. respuesta = true;
  636.  
  637. }
  638.  
  639. }
  640. return respuesta;
  641. }
  642.  
  643. private void convertirDesdeLaPosicionIndicadaHaciaElSurEsteFichasContrariasEnPropiasHastaEncontrarUnaPropia(
  644. int fila, int columna, Casillero fichaUtilizada) {
  645.  
  646. int distanciaEntreCasilleros = 1;
  647.  
  648. if (escanearAlSurEsteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  649. fila, columna, fichaUtilizada)) {
  650.  
  651. while (tablero[fila + distanciaEntreCasilleros][columna
  652. + distanciaEntreCasilleros] != fichaUtilizada) {
  653.  
  654. tablero[fila + distanciaEntreCasilleros][columna
  655. + distanciaEntreCasilleros] = fichaUtilizada;
  656.  
  657. tablero[fila][columna] = fichaUtilizada;
  658.  
  659. distanciaEntreCasilleros++;
  660.  
  661. }
  662. }
  663. }
  664.  
  665. // METODOS DESDE EL CLICK PARA CONVERTIR HACIA EL NOR OESTE
  666.  
  667. private void validarCasilleroParaConvertirFichasHaciaElNorOeste(
  668. Casillero fichaUtilizada) {
  669.  
  670. for (int i = 0; i < tablero.length; i++) {
  671. for (int j = 0; j < tablero.length; j++) {
  672.  
  673. if (tablero[i][j] != fichaUtilizada
  674. && tablero[i][j] != Casillero.LIBRE) {
  675.  
  676. if (i < tablero.length - 1 && j < tablero.length - 1) {
  677.  
  678. if (escanearAlNorOesteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  679. i + 1, j + 1, fichaUtilizada)) {
  680.  
  681. validarCasillero(i + 1, j + 1);
  682. }
  683. }
  684. }
  685.  
  686. }
  687. }
  688.  
  689. }
  690.  
  691. private boolean escanearAlNorOesteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  692. int fila, int columna, Casillero fichaUtilizada) {
  693.  
  694. boolean respuesta = false;
  695.  
  696. for (int i = 1; i <= fila && i <= columna; i++) {
  697.  
  698. if (tablero[fila - i][columna - i] != fichaUtilizada
  699. && tablero[fila - i][columna - i] != Casillero.LIBRE) {
  700.  
  701. } else if (tablero[fila - i][columna - i] == Casillero.LIBRE) {
  702.  
  703. i = columna; // finalizo el for
  704. } else if (tablero[fila - i][columna - i] == fichaUtilizada) {
  705.  
  706. respuesta = true;
  707.  
  708. }
  709.  
  710. }
  711.  
  712. return respuesta;
  713.  
  714. }
  715.  
  716. private void convertirDesdeLaPosicionIndicadaHaciaElNorOesteFichasContrariasEnPropiasHastaEncontrarUnaPropia(
  717. int fila, int columna, Casillero fichaUtilizada) {
  718.  
  719. int distanciaEntreCasilleros = 1;
  720.  
  721. if (escanearAlNorOesteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  722. fila, columna, fichaUtilizada)) {
  723.  
  724. while (tablero[fila - distanciaEntreCasilleros][columna
  725. - distanciaEntreCasilleros] != fichaUtilizada) {
  726.  
  727. tablero[fila - distanciaEntreCasilleros][columna
  728. - distanciaEntreCasilleros] = fichaUtilizada;
  729.  
  730. tablero[fila][columna] = fichaUtilizada;
  731.  
  732. distanciaEntreCasilleros++;
  733.  
  734. }
  735. }
  736. }
  737.  
  738. // METODOS DESDE EL CLICK PARA CONVERTIR HACIA EL NOR ESTE
  739.  
  740. private void validarCasilleroParaConvertirFichasHaciaElNorEste(
  741. Casillero fichaUtilizada) {
  742.  
  743. for (int i = 0; i < tablero.length; i++) {
  744. for (int j = 0; j < tablero.length; j++) {
  745.  
  746. if (tablero[i][j] != fichaUtilizada
  747. && tablero[i][j] != Casillero.LIBRE) {
  748.  
  749. if (i < tablero.length - 1 && j > 0) {
  750.  
  751. if (escanearAlNorEsteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  752. i + 1, j - 1, fichaUtilizada)) {
  753.  
  754. validarCasillero(i + 1, j - 1);
  755.  
  756. }
  757. }
  758. }
  759.  
  760. }
  761. }
  762. }
  763.  
  764. private boolean escanearAlNorEsteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  765. int fila, int columna, Casillero fichaUtilizada) {
  766.  
  767. boolean respuesta = false;
  768.  
  769. for (int i = 1; i <= fila && i < tablero.length - columna; i++) {
  770.  
  771. if (tablero[fila - i][columna + i] != fichaUtilizada
  772. && tablero[fila - i][columna + i] != Casillero.LIBRE) {
  773.  
  774. } else if (tablero[fila - i][columna + i] == Casillero.LIBRE) {
  775.  
  776. i = fila; // finalizo el for
  777. } else if (tablero[fila - i][columna + i] == fichaUtilizada) {
  778.  
  779. respuesta = true;
  780.  
  781. }
  782.  
  783. }
  784.  
  785. return respuesta;
  786.  
  787. }
  788.  
  789. private void convertirDesdeLaPosicionIndicadaHaciaElNorEsteFichasContrariasEnPropiasHastaEncontrarUnaPropia(
  790. int fila, int columna, Casillero fichaUtilizada) {
  791.  
  792. int distanciaEntreCasilleros = 1;
  793.  
  794. if (escanearAlNorEsteDeLaPosicionIndicadaEnLosParametrosSiHayUnaSecuenciaDeFichasContrariasYAlFinalUnaPropia(
  795. fila, columna, fichaUtilizada)) {
  796.  
  797. while (tablero[fila - distanciaEntreCasilleros][columna
  798. + distanciaEntreCasilleros] != fichaUtilizada) {
  799.  
  800. tablero[fila - distanciaEntreCasilleros][columna
  801. + distanciaEntreCasilleros] = fichaUtilizada;
  802.  
  803. tablero[fila][columna] = fichaUtilizada;
  804.  
  805. distanciaEntreCasilleros++;
  806.  
  807. }
  808. }
  809. }
  810.  
  811. /*
  812. *
  813. * post: ejecuta todos los metodos, pero solo van a ser ejecutados
  814. * satisfactoriamente si hay un casillero habilitado especificamente para su
  815. * funcion.
  816. */
  817.  
  818. private void ejecutarJugadasPosibles(int fila, int columna,
  819. Casillero fichaUtilizada) {
  820.  
  821. convertirDesdeLaPosicionIndicadaHaciaElSurFichasContrariasEnPropiasHastaEncontrarUnaPropia(
  822. fila, columna, fichaUtilizada);
  823.  
  824. convertirDesdeLaPosicionIndicadaHaciaElNorteFichasContrariasEnPropiasHastaEncontrarUnaPropia(
  825. fila, columna, fichaUtilizada);
  826.  
  827. convertirDesdeLaPosicionIndicadaHaciaElEsteFichasContrariasEnPropiasHastaEncontrarUnaPropia(
  828. fila, columna, fichaUtilizada);
  829.  
  830. convertirDesdeLaPosicionIndicadaHaciaElOesteFichasContrariasEnPropiasHastaEncontrarUnaPropia(
  831. fila, columna, fichaUtilizada);
  832.  
  833. convertirDesdeLaPosicionIndicadaHaciaElSurOesteFichasContrariasEnPropiasHastaEncontrarUnaPropia(
  834. fila, columna, fichaUtilizada);
  835.  
  836. convertirDesdeLaPosicionIndicadaHaciaElNorOesteFichasContrariasEnPropiasHastaEncontrarUnaPropia(
  837. fila, columna, fichaUtilizada);
  838.  
  839. convertirDesdeLaPosicionIndicadaHaciaElSurEsteFichasContrariasEnPropiasHastaEncontrarUnaPropia(
  840. fila, columna, fichaUtilizada);
  841.  
  842. convertirDesdeLaPosicionIndicadaHaciaElNorEsteFichasContrariasEnPropiasHastaEncontrarUnaPropia(
  843. fila, columna, fichaUtilizada);
  844.  
  845. }
  846.  
  847. private boolean noTieneJugadasPosibles(Casillero fichaDelTurno) {
  848.  
  849. boolean noPuedeSeguirJugando = true;
  850.  
  851. for (int i = 0; i < tablero.length; i++) {
  852. for (int j = 0; j < tablero.length; j++) {
  853.  
  854. if (jugadasValidas[i][j] == true) {
  855.  
  856. noPuedeSeguirJugando = false;
  857. }
  858.  
  859. }
  860. }
  861.  
  862. return noPuedeSeguirJugando;
  863.  
  864. }
  865.  
  866. /**
  867. * pre : la posición indicada por (fila, columna) puede ser ocupada por una
  868. * ficha. 'fila' está en el intervalo [1, contarFilas()]. 'columna' está en
  869. * el intervalor [1, contarColumnas()]. y aún queda un Casillero.VACIO en la
  870. * columna indicada. post: coloca una ficha en la posición indicada.
  871. *
  872. * @param columna
  873. * @param fila
  874. */
  875.  
  876. public void colocarFicha(int fila, int columna) {
  877.  
  878. int filaCorregida = fila - 1;
  879. int columnaCorregida = columna - 1;
  880.  
  881. if (turnoDeNegras) {
  882.  
  883. ejecutarJugadasPosibles(filaCorregida, columnaCorregida,
  884. Casillero.NEGRAS);
  885.  
  886. turnoDeNegras = !turnoDeNegras;
  887.  
  888. } else {
  889.  
  890. ejecutarJugadasPosibles(filaCorregida, columnaCorregida,
  891. Casillero.BLANCAS);
  892.  
  893. turnoDeNegras = !turnoDeNegras;
  894.  
  895. }
  896.  
  897. }
  898.  
  899. /*
  900. *
  901. * String filas = "prueba.colocarFicha(";
  902. *
  903. * String columnas = ");";
  904. *
  905. * String comaEntreMedio = ",";
  906. *
  907. * System.out.print(filas);
  908. *
  909. * System.out.print(fila);
  910. *
  911. * System.out.print(comaEntreMedio);
  912. *
  913. * System.out.print(columna);
  914. *
  915. * System.out.print(columnas);
  916. */
  917.  
  918. /**
  919. * post: devuelve la cantidad de fichas negras en el tablero.
  920. */
  921. public int contarFichasNegras() {
  922. int contador = 0;
  923. for (int i = 0; i < tablero.length; i++) {
  924. for (int j = 0; j < tablero.length; j++) {
  925. if (tablero[i][j] == Casillero.NEGRAS) {
  926. contador++;
  927. }
  928. }
  929. }
  930. return contador;
  931. }
  932.  
  933. /**
  934. * post: devuelve la cantidad de fichas blancas en el tablero.
  935. */
  936. public int contarFichasBlancas() {
  937. int contador = 0;
  938. for (int i = 0; i < tablero.length; i++) {
  939. for (int j = 0; j < tablero.length; j++) {
  940. if (tablero[i][j] == Casillero.BLANCAS) {
  941. contador++;
  942. }
  943. }
  944. }
  945. return contador;
  946. }
  947.  
  948. /**
  949. * post: indica si el juego terminó porque no existen casilleros vacíos o
  950. * ninguno de los jugadores puede colocar una ficha.
  951. */
  952.  
  953. public boolean termino() {
  954.  
  955. boolean terminoLaPartida = true;
  956.  
  957. for (int i = 0; i < tablero.length; i++) {
  958. for (int j = 0; j < tablero.length; j++) {
  959.  
  960. if (jugadasValidas[i][j] == true) {
  961.  
  962. terminoLaPartida = false;
  963.  
  964. }
  965.  
  966. }
  967.  
  968. }
  969. return terminoLaPartida;
  970.  
  971. }
  972.  
  973. /**
  974. * post: indica si el juego terminó y tiene un ganador.
  975. */
  976. public boolean hayGanador() {
  977.  
  978. return (termino() && contarFichasBlancas() != contarFichasNegras());
  979. }
  980.  
  981. /**
  982. * pre : el juego terminó. post: devuelve el nombre del jugador que ganó el
  983. * juego.
  984. */
  985. public String obtenerGanador() {
  986.  
  987. String respuesta = "";
  988.  
  989. if (hayGanador() && contarFichasBlancas() > contarFichasNegras()) {
  990.  
  991. respuesta = jugadorDeFichasBlancas;
  992. }
  993. if (hayGanador() && contarFichasBlancas() < contarFichasNegras()) {
  994.  
  995. respuesta = jugadorDeFichasNegras;
  996. }
  997.  
  998. return respuesta;
  999. }
  1000.  
  1001. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!