2 usuarios conectados

Laberinto textual. Juego en Python

Comparte esto
Python

 

def crear_laberinto(ancho, alto, inicio, fin, paredes):
    laberinto = [['#' for _ in range(ancho)] for _ in range(alto)]
    for r in range(alto):
        for c in range(ancho):
            if (r, c) not in paredes:
                laberinto[r][c] = ' '
    laberinto[inicio[0]][inicio[1]] = 'S'  # Inicio
    laberinto[fin[0]][fin[1]] = 'E'      # Fin
    return laberinto

def mostrar_laberinto(laberinto):
    for fila in laberinto:
        print(''.join(fila))

def jugar_laberinto():
    ancho = 15
    alto = 10
    inicio = (0, 1)
    fin = (alto - 1, ancho - 2)
    paredes = {
        (1, 1), (1, 2), (1, 3), (1, 5), (1, 6), (1, 7), (1, 9), (1, 10), (1, 11),
        (2, 1), (2, 7), (2, 11),
        (3, 1), (3, 3), (3, 4), (3, 5), (3, 7), (3, 9), (3, 10), (3, 11),
        (4, 3), (4, 7),
        (5, 0), (5, 1), (5, 2), (5, 3), (5, 5), (5, 6), (5, 7), (5, 9), (5, 10), (5, 11),
        (6, 5),
        (7, 1), (7, 2), (7, 3), (7, 5), (7, 7), (7, 8), (7, 9), (7, 11),
        (8, 7)
    }

    laberinto = crear_laberinto(ancho, alto, inicio, fin, paredes)
    posicion_actual = list(inicio)  # Usamos una lista para que sea mutable

    print("¡Bienvenido al Laberinto Textual!")
    print("Usa 'w' (arriba), 's' (abajo), 'a' (izquierda), 'd' (derecha) para moverte.")
    print("Intenta llegar a la 'E' (Salida) desde la 'S' (Inicio).")
    mostrar_laberinto(laberinto)

    while posicion_actual != list(fin):
        movimiento = input("Introduce tu movimiento (w/a/s/d): ").lower()
        nueva_posicion = list(posicion_actual)

        if movimiento == 'w':
            nueva_posicion[0] -= 1
        elif movimiento == 's':
            nueva_posicion[0] += 1
        elif movimiento == 'a':
            nueva_posicion[1] -= 1
        elif movimiento == 'd':
            nueva_posicion[1] += 1
        else:
            print("¡Movimiento inválido! Usa 'w', 'a', 's' o 'd'.")
            continue

        fila, col = nueva_posicion

        if 0 <= fila < alto and 0 <= col < ancho and laberinto[fila][col] != '#':
            laberinto[posicion_actual[0]][posicion_actual[1]] = ' '  # Dejar rastro
            posicion_actual = nueva_posicion
            laberinto[posicion_actual[0]][posicion_actual[1]] = 'P'  # Marcar la posición del jugador
            mostrar_laberinto(laberinto)
        elif laberinto[fila][col] == '#':
            print("¡Te has topado con una pared!")
        else:
            print("¡Fuera de los límites del laberinto!")

        if posicion_actual == list(fin):
            print("¡Felicidades! ¡Has encontrado la salida!")

if __name__ == "__main__":
    jugar_laberinto()

¿Cómo funciona el código?

  1. crear_laberinto(ancho, alto, inicio, fin, paredes):
    • Inicializa una matriz 2D (laberinto) del tamaño especificado, llena de # (paredes).
    • Itera sobre las coordenadas y marca las celdas que no están en el conjunto paredes como ' ' (espacio vacío).
    • Marca la posición de inicio con 'S' y la posición de fin con 'E'.
    • Devuelve el laberinto creado.
  2. mostrar_laberinto(laberinto): Imprime el laberinto en la consola, fila por fila.
  3. jugar_laberinto(): La función principal del juego:
    • Define las dimensiones del laberinto (ancho, alto), las coordenadas de inicio y fin, y un conjunto paredes que especifica las ubicaciones de los muros. Puedes modificar estos para crear laberintos diferentes.
    • Llama a crear_laberinto() para generar el laberinto.
    • Inicializa la posicion_actual del jugador en las coordenadas de inicio (como una lista para que sea mutable).
    • Imprime las instrucciones del juego y muestra el laberinto inicial.
    • Entra en un bucle while que continúa hasta que la posicion_actual sea igual a la fin.
    • Pide al jugador que introduzca un movimiento (w, a, s, d).
    • Calcula la nueva_posicion basándose en el movimiento.
    • Verifica si la nueva_posicion está dentro de los límites del laberinto y no es una pared (#).
    • Si el movimiento es válido:
      • Marca la posición anterior del jugador con un espacio vacío (' ') para dejar rastro.
      • Actualiza la posicion_actual.
      • Marca la nueva posición del jugador con 'P' en el laberinto.
      • Muestra el laberinto actualizado.
    • Si el movimiento es inválido (pared o fuera de límites), informa al jugador.
    • Comprueba si el jugador ha llegado a la salida (fin). Si es así, imprime un mensaje de felicitación y termina el bucle.
  4. if __name__ == "__main__":: Asegura que la función jugar_laberinto() se ejecute cuando el script se llama directamente.

Cómo jugar:

  1. Guarda este código en un archivo con extensión .py (por ejemplo, laberinto_textual.py).
  2. Abre una terminal o símbolo del sistema.
  3. Navega al directorio donde guardaste el archivo.
  4. Ejecuta el script con el comando: python laberinto_textual.py
  5. Sigue las instrucciones e introduce w, a, s o d para moverte por el laberinto. Intenta llegar a la E sin chocar con las #.