🟡 Mini-Game EngineMatrices 2D en Acción

Arreglos de Dos Dimensiones: El Laberinto de Pac-Man

¿Alguna vez te has preguntado cómo los videojuegos clásicos representan mapas, laberintos y mundos cuadriculados? En esta lección aprenderás arreglos de dos dimensiones (matrices 2D) construyendo la lógica del mítico Pac-Man. Descubrirás cómo funcionan las filas y columnas, la detección de colisiones contra muros, el recorrido con bucles anidados y podrás jugar con un simulador interactivo en tiempo real que muestra la memoria de la matriz mientras te mueves.

🕹️ Laboratorio Práctico

Simulador de Pac-Man: Matriz 2D en Vivo

Puntos (Score)0

Puntos Restantes--

Posición Pac-Man[f: 7, c: 7]

Estado🟡 Jugando

🎮 Vista Gráfica del JuegoUsa ⬅️ ⬆️ ⬇️ ➡️ o WASD

💾 Matriz 2D en Memoria: char mapa[11][15]

Observa cómo la posición [fila][columna] cambia en tiempo real en la estructura bidimensional:

# : Muro (Impenetrable)

. : Punto (+10 pts)

P : Pac-Man (Jugador)

G : Fantasma (Blinky)

¿Qué es un Arreglo de Dos Dimensiones (Matriz 2D)?

Un arreglo unidimensional (1D) representa una línea de casillas (como el inventario de Minecraft). Una matriz o arreglo bidimensional (2D) es una cuadrícula con filas y columnas, ideal para representar mapas, tableros de ajedrez, hojas de cálculo de Excel o el laberinto de Pac-Man.

📐 Regla de Oro: Primero la Fila, Luego la Columna

Para acceder a cualquier celda en C++, usamos dos corchetes consecutivos:

matriz[fila][columna]La fila indica qué tan arriba o abajo estamos (eje Y). La columna indica qué tan a la izquierda o derecha estamos (eje X).

En C++, declaramos el laberinto de Pac-Man como una matriz de caracteres (char) de 11 filas por 15 columnas:

Declaración de la Matriz 2D de Pac-Man

CPP

const int FILAS = 11;
const int COLS = 15;
 
// Declaración e inicialización del laberinto de Pac-Man
char mapa[FILAS][COLS] = {
    {'#','#','#','#','#','#','#','#','#','#','#','#','#','#','#'},
    {'#','.','.','.','.','.','#','.','.','.','.','.','.','.','#'},
    {'#','.','#','#','.','#','#','#','.','#','#','.','#','.','#'},
    {'#','.','#','#','.','.','.','.','.','.','#','.','#','.','#'},
    {'#','.','.','.','.','#','#','#','.','.','.','.','.','.','#'},
    {'#','#','#','.','#','#',' ','#','#','.','#','#','#','#','#'},
    {'#','.','.','.','.','#','G','#','.','.','.','.','.','.','#'},
    {'#','.','#','#','.','.','.','P','.','.','#','#','.','.','#'},
    {'#','.','#','#','.','#','#','#','.','#','#','.','#','.','#'},
    {'#','.','.','.','.','.','.','.','.','.','.','.','.','.','#'},
    {'#','#','#','#','#','#','#','#','#','#','#','#','#','#','#'}
};

Bucles Anidados: Cómo Recorrer y Dibujar la Cuadrícula

Para imprimir o procesar una matriz 2D necesitamos dos bucles for anidados:

Bucle exterior (f): se mueve fila por fila desde 0 hasta FILAS - 1.
Bucle interior (c): recorre cada columna de esa fila desde 0 hasta COLS - 1.
Al terminar de imprimir una fila completa, hacemos cout << endl; para saltar a la siguiente línea en consola.

Función para dibujar la matriz en consola

CPP

void dibujarMapa(char mapa[FILAS][COLS]) {
    // Bucle exterior: itera sobre cada FILA
    for (int f = 0; f < FILAS; f++) {
        // Bucle interior: itera sobre cada COLUMNA de la fila actual
        for (int c = 0; c < COLS; c++) {
            cout << mapa[f][c] << " ";
        }
        cout << "\n"; // Salto de línea al terminar la fila
    }
}

Posición del Jugador en Coordenadas 2D

En lugar de buscar a Pac-Man en toda la matriz en cada frame, guardamos sus coordenadas exactas en dos variables simples:

Fila Actual (Eje Y):int pacmanFila = 7;

Moverse arriba resta 1, moverse abajo suma 1.

Columna Actual (Eje X):int pacmanCol = 7;

Moverse a la izquierda resta 1, a la derecha suma 1.

Detección de Colisiones y Validación de Muros (`'#'`)

Antes de modificar la posición de Pac-Man, calculamos la celda destino a la que desea avanzar. Si la celda contiene un muro '#', el movimiento se rechaza:

Lógica de movimiento y colisiones en 2D

CPP

void moverPacman(char mapa[FILAS][COLS], int& pacmanFila, int& pacmanCol, char direccion, int& puntos) {
    int nuevaFila = pacmanFila;
    int nuevaCol = pacmanCol;
 
    // 1. Calcular nueva coordenada tentativa según la dirección
    if (direccion == 'w' || direccion == 'W') nuevaFila--; // Arriba
    else if (direccion == 's' || direccion == 'S') nuevaFila++; // Abajo
    else if (direccion == 'a' || direccion == 'A') nuevaCol--;  // Izquierda
    else if (direccion == 'd' || direccion == 'D') nuevaCol++;  // Derecha
 
    // 2. Validar que no se salga de la matriz
    if (nuevaFila < 0 || nuevaFila >= FILAS || nuevaCol < 0 || nuevaCol >= COLS) {
        return; // Movimiento fuera de límites
    }
 
    // 3. Validar colisión contra muros
    if (mapa[nuevaFila][nuevaCol] == '#') {
        cout << "¡Pared! No puedes atravesar muros.\n";
        return;
    }
 
    // 4. Si hay un punto, sumamos score
    if (mapa[nuevaFila][nuevaCol] == '.') {
        puntos += 10;
    }
 
    // 5. Actualizar la matriz: vaciar la celda anterior y colocar a Pac-Man en la nueva
    mapa[pacmanFila][pacmanCol] = ' ';
    pacmanFila = nuevaFila;
    pacmanCol = nuevaCol;
    mapa[pacmanFila][pacmanCol] = 'P';
}

Inteligencia Artificial del Fantasma: Vecindario de 4 Direcciones

El fantasma ('G') evalúa las 4 celdas adyacentes: arriba (f-1, c), abajo (f+1, c), izquierda (f, c-1) y derecha(f, c+1). Escoge una celda libre de muros y se desplaza hacia ella. Si coincide exactamente con la celda de Pac-Man, ¡el juego termina!

IA de Fantasma en Matriz 2D

CPP

bool moverFantasma(char mapa[FILAS][COLS], int& ghostFila, int& ghostCol, int pacmanFila, int pacmanCol) {
    // Si el fantasma toca a Pac-Man, Game Over
    if (ghostFila == pacmanFila && ghostCol == pacmanCol) {
        return true; // Colisión letal
    }
 
    // Movimiento básico hacia Pac-Man en la matriz
    int dFila = (pacmanFila > ghostFila) ? 1 : (pacmanFila < ghostFila ? -1 : 0);
    int dCol = (pacmanCol > ghostCol) ? 1 : (pacmanCol < ghostCol ? -1 : 0);
 
    int nFila = ghostFila + dFila;
    int nCol = ghostCol + dCol;
 
    if (mapa[nFila][nCol] != '#') {
        ghostFila = nFila;
        ghostCol = nCol;
    }
 
    return (ghostFila == pacmanFila && ghostCol == pacmanCol);
}

Código Fuente Completo en C++ (Consola)

Puedes compilar y ejecutar este programa directamente en tu terminal de C++ con g++ pacman.cpp -o pacman:

Juego Pac-Man 2D completo en C++

CPP

#include <iostream>
#include <vector>
 
using namespace std;
 
const int FILAS = 9;
const int COLS = 13;
 
char mapa[FILAS][COLS] = {
    {'#','#','#','#','#','#','#','#','#','#','#','#','#'},
    {'#','.','.','.','#','.','.','.','#','.','.','.','#'},
    {'#','.','#','.','#','.','#','.','#','.','#','.','#'},
    {'#','.','.','.','.','.','.','.','.','.','.','.','#'},
    {'#','#','#','.','#','#',' ','#','#','.','#','#','#'},
    {'#','.','.','.','.','.','.','.','.','.','.','.','#'},
    {'#','.','#','.','#','.','#','.','#','.','#','.','#'},
    {'#','.','.','.','#','.','P','.','#','.','.','.','#'},
    {'#','#','#','#','#','#','#','#','#','#','#','#','#'}
};
 
int main() {
    int pFila = 7, pCol = 7;
    int puntos = 0;
    char tecla;
 
    cout << "=== MINI PAC-MAN 2D EN C++ ===\n";
    cout << "Controles: W (Arriba), S (Abajo), A (Izq), D (Der), Q (Salir)\n\n";
 
    while (true) {
        // 1. Dibujar matriz
        for (int f = 0; f < FILAS; f++) {
            for (int c = 0; c < COLS; c++) {
                cout << mapa[f][c] << " ";
            }
            cout << "\n";
        }
        cout << "Puntaje: " << puntos << " | Posicion: [" << pFila << "][" << pCol << "]\n";
        cout << "Ingresa direccion (W/A/S/D): ";
        cin >> tecla;
 
        if (tecla == 'q' || tecla == 'Q') break;
 
        int nFila = pFila;
        int nCol = pCol;
 
        if (tecla == 'w' || tecla == 'W') nFila--;
        else if (tecla == 's' || tecla == 'S') nFila++;
        else if (tecla == 'a' || tecla == 'A') nCol--;
        else if (tecla == 'd' || tecla == 'D') nCol++;
 
        // Validar muro
        if (nFila >= 0 && nFila < FILAS && nCol >= 0 && nCol < COLS && mapa[nFila][nCol] != '#') {
            if (mapa[nFila][nCol] == '.') puntos += 10;
            mapa[pFila][pCol] = ' ';
            pFila = nFila;
            pCol = nCol;
            mapa[pFila][pCol] = 'P';
        }
        cout << "\n----------------------------------\n";
    }
 
    cout << "¡Juego terminado! Puntos finales: " << puntos << "\n";
    return 0;
}

← 7.1 Arreglos Fijos (1D)7.4 Examen CRUD: Estudiantes➡️

Contenido

📚 Cursos de Café y Código

Arreglos de Dos Dimensiones: El Laberinto de Pac-Man

Simulador de Pac-Man: Matriz 2D en Vivo

¿Qué es un Arreglo de Dos Dimensiones (Matriz 2D)?

📐 Regla de Oro: Primero la Fila, Luego la Columna

Bucles Anidados: Cómo Recorrer y Dibujar la Cuadrícula

Posición del Jugador en Coordenadas 2D

Detección de Colisiones y Validación de Muros (`'#'`)

Inteligencia Artificial del Fantasma: Vecindario de 4 Direcciones

Código Fuente Completo en C++ (Consola)

¡Hecho con mucho cariño! ☕

Arreglos de Dos Dimensiones: El Laberinto de Pac-Man

Simulador de Pac-Man: Matriz 2D en Vivo

¿Qué es un Arreglo de Dos Dimensiones (Matriz 2D)?

📐 Regla de Oro: Primero la Fila, Luego la Columna

Bucles Anidados: Cómo Recorrer y Dibujar la Cuadrícula

Posición del Jugador en Coordenadas 2D

Detección de Colisiones y Validación de Muros ('#')

Inteligencia Artificial del Fantasma: Vecindario de 4 Direcciones

Código Fuente Completo en C++ (Consola)

Detección de Colisiones y Validación de Muros (`'#'`)