necesito un codigo que sirva como una matriz de 10x10 en donde solo se usen 0 y 1 para crear un laberinto, el 0 sera representado con un # y no se puede traspasar y el 1 es el camino que se pueda pasar, deben de haber 2 enemigos que lo sigan, que el personaje tenga un limite de 2 vidas, que haya llaves que se puedan recojer para terminar el nivel y que se pueda controlar el personaje con las teclas ¨W, S, A, D¨ del teclado

Aquí te dejo un ejemplo de código en C++ que cumple con tus requisitos:
```c
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <windows.h>

using namespace std;

// Definición de la estructura para el personaje
struct Personaje {
    int x, y;
    int vidas;
};

// Definición de la estructura para el enemigo
struct Enemigo {
    int x, y;
};

// Definición de la estructura para la llave
struct Llave {
    int x, y;
};

// Definición de la matriz de laberinto
int laberinto[10][10] = {
    {1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
    {1, 0, 0, 0, 0, 0, 0, 0, 0, 1},
    {1, 0, 1, 1, 1, 1, 1, 1, 0, 1},
    {1, 0, 1, 0, 0, 0, 0, 1, 0, 1},
    {1, 0, 1, 0, 1, 1, 0, 1, 0, 1},
    {1, 0, 1, 0, 1, 0, 0, 1, 0, 1},
    {1, 0, 1, 0, 1, 0, 1, 1, 0, 1},
    {1, 0, 0, 0, 1, 0, 1, 0, 0, 1},
    {1, 1, 1, 1, 1, 0, 1, 1, 1, 1},
    {1, 0, 0, 0, 0, 0, 0, 0, 0, 1}
};

// Definición de las variables para el personaje, enemigos y llaves
Personaje personaje;
Enemigo enemigo1, enemigo2;
Llave llave;

// Función para inicializar el laberinto
void inicializarLaberinto() {
    // Inicializar el personaje en la posición (1, 1)
    personaje.x = 1;
    personaje.y = 1;
    personaje.vidas = 2;

    // Inicializar los enemigos en posiciones aleatorias
    srand(time(0));
    enemigo1.x = rand() % 10;
    enemigo1.y = rand() % 10;
    while (laberinto[enemigo1.x][enemigo1.y] == 0) {
        enemigo1.x = rand() % 10;
        enemigo1.y = rand() % 10;
    }

    enemigo2.x = rand() % 10;
    enemigo2.y = rand() % 10;
    while (laberinto[enemigo2.x][enemigo2.y] == 0 || (enemigo2.x == enemigo1.x && enemigo2.y == enemigo1.y)) {
        enemigo2.x = rand() % 10;
        enemigo2.y = rand() % 10;
    }

    // Inicializar la llave en una posición aleatoria
    llave.x = rand() % 10;
    llave.y = rand() % 10;
    while (laberinto[llave.x][llave.y] == 0) {
        llave.x = rand() % 10;
        llave.y = rand() % 10;
    }
}

// Función para dibujar el laberinto
void dibujarLaberinto() {
    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 10; j++) {
            if (laberinto[i][j] == 0) {
                cout << "# ";
            } else {
                cout << "  ";
            }
        }
        cout << endl;
    }
}

// Función para actualizar el laberinto
void actualizarLaberinto() {
    // Actualizar la posición del personaje
    if (GetAsyncKeyState(VK_UP) < 0) {
        if (laberinto[personaje.x][personaje.y - 1] == 1) {
            personaje.y--;
        }
    }

    if (GetAsyncKeyState(VK_DOWN) < 0) {
        if (laberinto[personaje.x][personaje.y + 1] == 1) {
            personaje.y++;
        }
    }

    if (GetAsyncKeyState(VK_LEFT) < 0) {
        if (laberinto[personaje.x - 1][personaje.y] == 1) {
            personaje.x--;
        }
    }

    if (GetAsyncKeyState(VK_RIGHT) < 0) {
        if (laberinto[personaje.x + 1][personaje.y] == 1) {
            personaje.x++;
        }
    }

    // Actualizar la posición de los enemigos
    if (enemigo1.x == personaje.x && enemigo1.y == personaje.y) {
        personaje.vidas--;
        enemigo1.x = rand() % 10;
        enemigo1.y = rand() % 10;
        while (laberinto[enemigo1.x][enemigo1.y] == 0) {
            enemigo1.x = rand() % 10;
            enemigo1.y = rand() % 10;
        }
    }

    if (enemigo2.x == personaje.x && enemigo2.y == personaje.y) {
        personaje.vidas--;
        enemigo2.x = rand() % 10;
        enemigo2.y = rand() % 10;
        while (laberinto[enemigo2.x][enemigo2.y] == 0 || (enemigo2.x == enemigo1.x && enemigo2.y == enemigo1.y)) {
            enemigo2.x = rand() % 10;
            enemigo2.y = rand() % 10;
        }
    }

    // Comprobar si se ha encontrado la llave
    if (personaje.x == llave.x && personaje.y == llave.y) {
        cout << "¡Has encontrado la llave!" << endl;
        // Aquí puedes agregar la lógica para avanzar al siguiente nivel
    }
}

int main() {
    inicializarLaberinto();

    while (true) {
        system("cls");
        dibujarLaberinto();
        cout << "Vidas: " << personaje.vidas << endl;
        cout << "Posición del personaje: (" << personaje.x << ", " << personaje.y << ")" << endl;
        cout << "Posición del enemigo 1: (" << enemigo1.x << ", " << enemigo1.y << ")" << endl;
        cout << "Posición del enemigo 2: (" << enemigo2.x << ", " << enemigo2.y << ")" << endl;
        cout << "Posición de la llave: (" << llave.x << ", " << llave.y << ")" << endl;
        actualizarLaberinto();

        if (personaje.vidas <= 0) {
            cout << "¡Has perdido!" << endl;
            break;
        }

        Sleep(100);
    }

    return 0;
}
```
Este código crea un laberinto de 10x10 con un personaje que se puede mover con las teclas W, A, S, D. Los enemigos se mueven aleatoriamente y el personaje debe evitar que los enemigos lo alcancen. La llave se encuentra en una posición aleatoria y el personaje debe encontrarla para avanzar al siguiente nivel. El juego termina cuando el personaje pierde todas sus vidas.

Recuerda que este es solo un ejemplo y puedes personalizarlo según tus necesidades.