Programa el juego de escaleras y serpientes en Java

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

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.

// 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.

// 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.

// 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.

// 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.

// 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.

// 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.

// 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:

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

Recuerda que todo el código esta en github.

Espero que os sea de ayuda. Si tenéis dudas, preguntad. Estamos para ayudarte.