Hola a todos, hoy os voy a explicar como podemos programar el juego de escaleras y serpientes en Java.
Todos alguna vez de pequeños, hemos jugado al juego de escaleras y serpientes, se trata de juego de mesa donde el objetivo es llegar a la meta pudiendo adelantarnos mediante escaleras o bajar mediante serpientes.
Reglas de escaleras y serpientes
Los jugadores comienzan en la casilla 1 de un tablero de 64 casillas y se turnan para lanzar un dado que les indicará la cantidad de casillas que deben avanzar.
Si al finalizar un movimiento un jugador cae en una casilla donde comienza una escalera, sube por ella hasta la casilla donde ésta termina. Por el contrario, cae en una en donde comienza la cabeza de una serpiente, desciende por ésta hasta la casilla donde finaliza su cola.
Si un jugador obtiene un 6 podrá mover y tirar nuevamente el dado. Si un jugador obtiene tres 6 consecutivos, deberá regresar a la casilla inicial y no podrá mover su ficha hasta obtener nuevamente un 6.
El jugador que logra llegar a la casilla final es el ganador. En una de las modalidades se debe llegar al casilla final con el puntaje justo.
Tienes más detalles aquí.
Preparando todo lo necesario
En primer lugar, necesitaremos algunas variables que usaremos para nuestro juego:
- Dos arrays con las casillas especiales, uno con la casilla origen y otro con el destino. Por ejemplo, si caigo en la casilla 7, iría a la casilla 38.
- Un array con las posiciones de los jugadores donde la posición 0 es del jugador 1 y la posición 1 es del jugador 2.
- Un array de booleanos para indicar si el jugador esta bloqueado o no.
- Constante con el numero de casillas totales (64).
- Variable con la casilla limite que es la que se debe llegar, es decir, la última casilla.
- Variable turno para indicar el jugador que le toca, se combina con el array de las posiciones de los jugadores.
- Variable dado para almacenar el valor del dado que haya sacado un jugador.
- Variable tiradasConsecutivas indica el número de tiradas consecutivas con el valor 6 se han sacado.
- Variable casillaSuperior que la usaremos para el caso de que nos pasemos del tablero.
- Variable casillaEspecial indica si donde ha caído el jugador es una de las casillas especiales.
Necesitamos generar un número aleatorio para el dado, lo tenemos en este tutorial:
Como generar números aleatorios con el método Math.random de Java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
package escaleras_serpientes; public class EscalerasSerpientes { public static void main(String[] args) { // numero de casillas totales (0 a 63) final int NUM_CASILLAS = 64; // Casillas especiales int[] origenCasillasEspeciales = {7, 11, 31, 30, 40, 43, 50, 59}; int[] destinoCasillasEspeciales = {38, 37, 46, 2, 21, 60, 5, 42}; // Variables necesarias int[] jugadores = {0, 0}; boolean bloqueado[] = {false, false}; int turno = 0, dado, tiradasConsecutivas = 0, casillaSuperior; boolean casillaEspecial; int casillaLimite = NUM_CASILLAS - 1; } //Genera un numero aleatorio entre el minimo y el maximo, includo el maximo y el minimo public static int generaNumeroAleatorio(int minimo, int maximo) { return (int) (Math.random() * (maximo - minimo + 1) + (minimo)); } } |
Fin del juego de escaleras y serpientes
El juego se termina cuando uno de los dos jugadores llega a la casillaLimite.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
// Seguimos hasta que uno de los jugadores llegue a la casilla limite while (jugadores[0] != casillaLimite && jugadores[1] != casillaLimite) { // Tirada de dado // Desbloqueo de jugador y tiradas consecutivas // Bloqueo del jugador // Movimiento jugador // Casillas especiales } |
Tirada de dado
En cada turno, el jugador tira el dado, si es 6 no cambia el turno.
|
1 2 3 |
// tiro el dado dado = generaNumeroAleatorio(1, 6); System.out.println("El jugador " + (turno + 1) + " ha sacado un " + dado); |
Desbloqueo de jugador y tiradas consecutivas
Si sacamos un 6, tenemos un par de escenarios:
- El jugador esta bloqueado, por lo que lo desbloqueamos y reseteamos las tiradas consecutivas.
- El jugador no esta bloqueado, aumentamos en uno las tiradas consecutivas.
Sino es un 6, reseteamos las tiradas consecutivas.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
// Si saca un 6, añadimos en uno al contador de tiradas (sino esta bloqueado) if (dado == 6) { // Si el jugador esta bloqueado, se desbloquea if (bloqueado[turno]) { bloqueado[turno] = false; tiradasConsecutivas = 0; System.out.println("El jugador " + (turno + 1) + " se ha desbloqueado"); } else { tiradasConsecutivas++; } } else { tiradasConsecutivas = 0; } |
Bloqueo del jugador de escaleras y serpientes
Cuando el número de tiradas consecutivas llega a 3, bloqueamos al jugador del turno actual.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
// Si llega a 3, bloqueamos al jugador if (tiradasConsecutivas == 3) { bloqueado[turno] = true; jugadores[turno] = 0; System.out.println("El jugador " + (turno + 1) + " se ha bloqueado"); } else { // Movimiento jugador // Casillas especiales // Cambio de turno } |
Movimiento jugador
Las posiciones del jugador se van actualizando según el valor del dado, por otro lado, tenemos un caso especial que es cuando el jugador se pase de la casilla limite, por lo que «rebotaremos» hacia atrás.
|
1 2 3 4 5 6 7 |
// Movimiento rebotado if (jugadores[turno] + dado > NUM_CASILLAS - 1) { casillaSuperior = jugadores[turno] + dado; jugadores[turno] = casillaLimite - (casillaSuperior - casillaLimite); } else { jugadores[turno] += dado; } |
Casillas especiales de escaleras y serpientes
Cuando el jugador cae en una casilla, comprobamos si es especial, si el origen es mayor que el destino es una serpiente, sino es una escalera.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// Comprobamos si la casilla donde esta el jugador es una casilla especial casillaEspecial = false; for (int i = 0; i < origenCasillasEspeciales.length && !casillaEspecial; i++) { if (jugadores[turno] == origenCasillasEspeciales[i]) { // Si el origen es menor que el destino es una escalera, sino una serpiente if (origenCasillasEspeciales[i] < destinoCasillasEspeciales[i]) { System.out.println("El jugador " + (turno + 1) + " ha subido una escalera"); } else { System.out.println("El jugador " + (turno + 1) + " ha bajado una serpiente"); } // Transportamos al jugador jugadores[turno] = destinoCasillasEspeciales[i]; casillaEspecial = true; } } System.out.println("El jugador " + (turno + 1) + " esta en la casilla " + (jugadores[turno] + 1)); |
Cambio de turno
Al final, cambiaremos el turno siempre y cuando no sea un 6.
|
1 2 3 4 5 6 7 8 9 |
// Si saco un 6, no cambio de turno if (dado != 6) { // Cambio de turno if (turno == 0) { turno = 1; } else { turno = 0; } } |
Código final
Así queda nuestro código al final:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 |
package escaleras_serpientes; public class EscalerasSerpientes { public static void main(String[] args) { // numero de casillas totales (0 a 63) final int NUM_CASILLAS = 64; // Casillas especiales int[] origenCasillasEspeciales = {7, 11, 31, 30, 40, 43, 50, 59}; int[] destinoCasillasEspeciales = {38, 37, 46, 2, 21, 60, 5, 42}; // Variables necesarias int[] jugadores = {0, 0}; boolean bloqueado[] = {false, false}; int turno = 0, dado, tiradasConsecutivas = 0, casillaSuperior; boolean casillaEspecial; int casillaLimite = NUM_CASILLAS - 1; // Seguimos hasta que uno de los jugadores llegue a la casilla limite while (jugadores[0] != casillaLimite && jugadores[1] != casillaLimite) { // tiro el dado dado = generaNumeroAleatorio(1, 6); System.out.println("El jugador " + (turno + 1) + " ha sacado un " + dado); // Si saca un 6, añadimos en uno al contador de tiradas (sino esta bloqueado) if (dado == 6) { // Si el jugador esta bloqueado, se desbloquea if (bloqueado[turno]) { bloqueado[turno] = false; tiradasConsecutivas = 0; System.out.println("El jugador " + (turno + 1) + " se ha desbloqueado"); } else { tiradasConsecutivas++; } } else { tiradasConsecutivas = 0; } // Si llega a 3, bloqueamos al jugador if (tiradasConsecutivas == 3) { bloqueado[turno] = true; jugadores[turno] = 0; System.out.println("El jugador " + (turno + 1) + " se ha bloqueado"); } else { // Movimiento rebotado if (jugadores[turno] + dado > NUM_CASILLAS - 1) { casillaSuperior = jugadores[turno] + dado; jugadores[turno] = casillaLimite - (casillaSuperior - casillaLimite); } else { jugadores[turno] += dado; } // Comprobamos si la casilla donde esta el jugador es una casilla especial casillaEspecial = false; for (int i = 0; i < origenCasillasEspeciales.length && !casillaEspecial; i++) { if (jugadores[turno] == origenCasillasEspeciales[i]) { // Si el origen es menor que el destino es una escalera, sino una serpiente if (origenCasillasEspeciales[i] < destinoCasillasEspeciales[i]) { System.out.println("El jugador " + (turno + 1) + " ha subido una escalera"); } else { System.out.println("El jugador " + (turno + 1) + " ha bajado una serpiente"); } // Transportamos al jugador jugadores[turno] = destinoCasillasEspeciales[i]; casillaEspecial = true; } } System.out.println("El jugador " + (turno + 1) + " esta en la casilla " + (jugadores[turno] + 1)); } // Si saco un 6, no cambio de turno if (dado != 6) { // Cambio de turno if (turno == 0) { turno = 1; } else { turno = 0; } } } // Comprobación del ganador if (jugadores[0] == casillaLimite) { System.out.println("El jugador 1 ha ganado"); } else { System.out.println("El jugador 2 ha ganado"); } } //Genera un numero aleatorio entre el minimo y el maximo, includo el maximo y el minimo public static int generaNumeroAleatorio(int minimo, int maximo) { return (int) (Math.random() * (maximo - minimo + 1) + (minimo)); } } |
Resultados
Con todo listo, ya podemos probar nuestro programa:
Os dejo un video donde explicamos todo paso a paso
https://youtu.be/askCpTe-5t4
Recuerda que todo el código esta en github.
Espero que os sea de ayuda. Si tenéis dudas, preguntad. Estamos para ayudarte.
Deja una respuesta