Las listas son estructuras fundamentales en Python que nos permiten organizar y almacenar colecciones de datos de manera eficiente.

Una lista simple es una estructura de datos unidimensional que puede contener elementos de cualquier tipo. Es una colección ordenada de elementos que se puede modificar después de su creación. 

lista = [ 1, 2, 3]

Una lista anidada es una lista de listas donde cada elemento de la lista principal es otra lista, formando así una tabla bidimensional. Imita así una matriz.

matriz = [

                  [1, 2, 3],

                  [4, 5, 6],  

                  [7, 8, 9]

]

Matriz del laberinto

laberinto = [[1, 1, 1, 1, 1, 1, 1],
             [1, 0, 0, 0, 0, 0, 3],
             [1, 0, 0, 1, 1, 1, 1],
             [1, 0, 0, 0, 0, 0, 1],
             [1, 0, 0, 0, 0, 0, 1],
             [1, 1, 1, 1, 1, 0, 1],
             [1, 2, 0, 0, 0, 0, 1],
             [1, 1, 1, 1, 1, 1, 1]]

Este bloque de código crea un mapa en forma de matriz (una tabla con filas y columnas). Cada número dentro de la matriz representa algo en el juego. Es como dibujar el mapa del laberinto. Imagina que los números son piezas de un rompecabezas, donde:

• El número 0 son los caminos por donde el jugador puede moverse.
• número 1 son las paredes.
• El número 2 es el jugador.
• El número 3 es la meta o el punto de llegada.

Creación de la pantalla y dibujar el laberinto:

screen = pygame.display.set_mode((len(laberinto[0]) * tamaño_celdas, len(laberinto) * tamaño_celdas))
pygame.display.set_caption("Laberinto")

Aquí se define el tamaño de la ventana del juego. La función pygame.display.set_mode crea una ventana que tiene el mismo tamaño que el laberinto. Es como si el laberinto se imprimiera en una hoja del tamaño exacto para que todo encaje. La función pygame.display.set_caption simplemente da un nombre a la ventana del juego, en este caso "Laberinto".

Dibujar el laberinto en pantalla:

def draw_laberinto():
    for row in range(len(laberinto)):
        for col in range(len(laberinto[0])):
            if laberinto[row][col] == 1:
                pygame.draw.rect(screen, BLACK, (col * tamaño_celdas, row * tamaño_celdas, tamaño_celdas, tamaño_celdas))
            elif laberinto[row][col] == 2:
                pygame.draw.rect(screen, GREEN, (col * tamaño_celdas, row * tamaño_celdas, tamaño_celdas, tamaño_celdas))
            elif laberinto[row][col] == 3:
                pygame.draw.rect(screen, RED, (col * tamaño_celdas, row * tamaño_celdas, tamaño_celdas, tamaño_celdas))

Esta función draw_laberinto() se encarga de dibujar el laberinto en la pantalla. Recorre cada celda del laberinto (las filas y columnas) y dibuja un cuadrado de color dependiendo del número que encuentre:

• Si encuentra un 1, dibuja un cuadrado negro (una pared).
• Si encuentra un 2, dibuja un cuadrado verde (el jugador).
• Si encuentra un 3, dibuja un cuadrado rojo (la meta).

Imagina que estás construyendo un laberinto en un papel cuadriculado. Cada número del laberinto es una celda, y la función draw_laberinto() es como una mano que pinta cada celda con su color correspondiente.

Código del laberinto

laberinto = [[1, 1, 1, 1, 1, 1, 1],
             [1, 0, 0, 0, 0, 0, 3],
             [1, 0, 0, 1, 1, 1, 1],
             [1, 0, 0, 0, 0, 0, 1],
             [1, 0, 0, 0, 0, 0, 1],
             [1, 1, 1, 1, 1, 0, 1],
             [1, 2, 0, 0, 0, 0, 1],
             [1, 1, 1, 1, 1, 1, 1]]

screen = pygame.display.set_mode((len(laberinto[0]) * tamaño_celdas, len(laberinto) * tamaño_celdas))
pygame.display.set_caption("Laberinto")

def draw_laberinto():
    for row in range(len(laberinto)):
        for col in range(len(laberinto[0])):
            if laberinto[row][col] == 1:
                pygame.draw.rect(screen, BLACK, (col * tamaño_celdas, row * tamaño_celdas, tamaño_celdas, tamaño_celdas))
            elif laberinto[row][col] == 2:
                pygame.draw.rect(screen, GREEN, (col * tamaño_celdas, row * tamaño_celdas, tamaño_celdas, tamaño_celdas))
            elif laberinto[row][col] == 3:
                pygame.draw.rect(screen, RED, (col * tamaño_celdas, row * tamaño_celdas, tamaño_celdas, tamaño_celdas))