Necesito que hagas un laberinto en dónde te puedas mover a base de este código #include <stdio.h> int main() { int sizeX = 6; int sizeY = 7; int matrix[6][7] = { {0, 1, 0, 0, 0, 0, 0}, {0, 1, 0, 0, 0, 0, 0}, {0, 1, 1, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0, 0}, {0, 0, 1, 1, 1, 0, 0}, {0, 0, 0, 0, 1, 0, 0} }; for (int i = 0; i < sizeX; i++) { for (int j = 0; j < sizeY; j++) { printf("%d ", matrix[i][j]); } printf("\n"); } printf("Hello World\n"); return 0; }

Aquí te dejo un ejemplo de cómo podrías implementar un laberinto en C++ utilizando el código que proporcionaste. En este ejemplo, el laberinto se representa como una matriz bidimensional, donde los valores 0 representan espacios vacíos y los valores 1 representan paredes.

```cpp
#include <iostream>
#include <vector>

// Estructura para representar la posición en el laberinto
struct Posicion {
    int x;
    int y;
};

// Clase para representar el laberinto
class Laberinto {
private:
    int sizeX;
    int sizeY;
    std::vector<std::vector<int>> matriz;

public:
    // Constructor para inicializar el laberinto
    Laberinto(int sizeX, int sizeY) {
        this->sizeX = sizeX;
        this->sizeY = sizeY;
        matriz.resize(sizeX, std::vector<int>(sizeY, 0));
    }

    // Método para inicializar la matriz del laberinto
    void inicializarMatriz(int** matriz) {
        for (int i = 0; i < sizeX; i++) {
            for (int j = 0; j < sizeY; j++) {
                this->matriz[i][j] = matriz[i][j];
            }
        }
    }

    // Método para imprimir el laberinto
    void imprimirLaberinto() {
        for (int i = 0; i < sizeX; i++) {
            for (int j = 0; j < sizeY; j++) {
                std::cout << matriz[i][j] << " ";
            }
            std::cout << std::endl;
        }
    }

    // Método para verificar si una posición es válida
    bool esPosicionValida(int x, int y) {
        return (x >= 0 && x < sizeX && y >= 0 && y < sizeY);
    }

    // Método para verificar si una posición está bloqueada por una pared
    bool estaBloqueada(int x, int y) {
        return matriz[x][y] == 1;
    }

    // Método para moverse a una posición
    void moverse(Posicion posicion) {
        if (esPosicionValida(posicion.x, posicion.y) && !estaBloqueada(posicion.x, posicion.y)) {
            std::cout << "Se ha movido a la posición (" << posicion.x << ", " << posicion.y << ")" << std::endl;
        } else {
            std::cout << "No se puede mover a la posición (" << posicion.x << ", " << posicion.y << ")" << std::endl;
        }
    }
};

int main() {
    int sizeX = 6;
    int sizeY = 7;

    int** matriz = new int*[sizeX];
    for (int i = 0; i < sizeX; i++) {
        matriz[i] = new int[sizeY];
        for (int j = 0; j < sizeY; j++) {
            matriz[i][j] = 0;
        }
    }

    matriz[0][1] = 1;
    matriz[1][1] = 1;
    matriz[2][1] = 1;
    matriz[2][2] = 1;
    matriz[3][2] = 1;
    matriz[4][2] = 1;
    matriz[4][3] = 1;
    matriz[4][4] = 1;
    matriz[5][4] = 1;

    Laberinto laberinto(sizeX, sizeY);
    laberinto.inicializarMatriz(matriz);

    laberinto.imprimirLaberinto();

    Posicion posicion;
    posicion.x = 0;
    posicion.y = 0;

    laberinto.moverse(posicion);

    delete[] matriz[0];
    delete[] matriz;
    return 0;
}
```

En este ejemplo, se crea una clase `Laberinto` que representa el laberinto. La clase tiene métodos para inicializar la matriz del laberinto, imprimir el laberinto, verificar si una posición es válida y verificar si una posición está bloqueada por una pared. El método `moverse` permite moverse a una posición en el laberinto.

En el `main`, se crea un laberinto con una matriz de 6x7 y se inicializa con algunas paredes. Luego, se imprime el laberinto y se mueve a la posición (0, 0).