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 sin #include <windows.h>

Aquí te dejo un ejemplo de código en C++ que cumple con tus requisitos. Este código utiliza la biblioteca `ncurses` para crear una matriz de 10x10 y controlar el personaje con las teclas `W`, `S`, `A` y `D`.

```c
#include <ncurses.h>
#include <stdlib.h>
#include <time.h>

// Definimos las constantes para la matriz
const int FILAS = 10;
const int COLUMNAS = 10;

// Definimos las constantes para el personaje y los enemigos
const int PERSONAJE = 1;
const int ENEMIGO = 2;
const int LLAVE = 3;

// Definimos las constantes para las teclas
const int TECLA_ARRIBA = 'w';
const int TECLA_ABAJO = 's';
const int TECLA_IZQUIERDA = 'a';
const int TECLA_DERECHA = 'd';

// Definimos las constantes para las vidas
const int VIDAS_INICIALES = 2;

// Definimos la matriz de laberinto
int laberinto[FILAS][COLUMNAS];

// Definimos las variables para el personaje y los enemigos
int personaje_x, personaje_y;
int enemigo1_x, enemigo1_y;
int enemigo2_x, enemigo2_y;
int vida = VIDAS_INICIALES;
int llave_recolectada = 0;

int main() {
    // Inicializamos la biblioteca ncurses
    initscr();
    cbreak();
    noecho();
    curs_set(0);

    // Inicializamos la matriz de laberinto
    for (int i = 0; i < FILAS; i++) {
        for (int j = 0; j < COLUMNAS; j++) {
            laberinto[i][j] = 0;
        }
    }

    // Creamos los enemigos
    srand(time(NULL));
    enemigo1_x = rand() % COLUMNAS;
    enemigo1_y = rand() % FILAS;
    enemigo2_x = rand() % COLUMNAS;
    enemigo2_y = rand() % FILAS;

    // Creamos la llave
    int llave_x, llave_y;
    do {
        llave_x = rand() % COLUMNAS;
        llave_y = rand() % FILAS;
    } while (laberinto[llave_y][llave_x] != 0);

    // Colocamos el personaje en la posición inicial
    personaje_x = 1;
    personaje_y = 1;

    // Colocamos el personaje en la matriz
    laberinto[personaje_y][personaje_x] = PERSONAJE;

    // Colocamos los enemigos en la matriz
    laberinto[enemigo1_y][enemigo1_x] = ENEMIGO;
    laberinto[enemigo2_y][enemigo2_x] = ENEMIGO;

    // Colocamos la llave en la matriz
    laberinto[llave_y][llave_x] = LLAVE;

    // Dibujamos la matriz de laberinto
    while (true) {
        // Limpia la pantalla
        clear();

        // Dibuja la matriz de laberinto
        for (int i = 0; i < FILAS; i++) {
            for (int j = 0; j < COLUMNAS; j++) {
                if (laberinto[i][j] == 0) {
                    addstr("# ");
                } else if (laberinto[i][j] == PERSONAJE) {
                    addstr("P ");
                } else if (laberinto[i][j] == ENEMIGO) {
                    addstr("E ");
                } else if (laberinto[i][j] == LLAVE) {
                    addstr("L ");
                } else {
                    addstr("  ");
                }
            }
            addstr("\n");
        }

        // Muestra el número de vidas
        addstr("Vidas: ");
        addstr(itoa(vida, NULL, 10));
        addstr("\n");

        // Muestra el mensaje de victoria
        if (llave_recolectada == 1) {
            addstr("¡Victoria!");
            refresh();
            delay(2000);
            break;
        }

        // Obtiene la tecla presionada
        int tecla = getch();

        // Mueve el personaje según la tecla presionada
        switch (tecla) {
            case TECLA_ARRIBA:
                if (personaje_y > 0 && laberinto[personaje_y - 1][personaje_x] != 0) {
                    personaje_y--;
                    laberinto[personaje_y][personaje_x] = PERSONAJE;
                    laberinto[personaje_y + 1][personaje_x] = 0;
                }
                break;
            case TECLA_ABAJO:
                if (personaje_y < FILAS - 1 && laberinto[personaje_y + 1][personaje_x] != 0) {
                    personaje_y++;
                    laberinto[personaje_y][personaje_x] = PERSONAJE;
                    laberinto[personaje_y - 1][personaje_x] = 0;
                }
                break;
            case TECLA_IZQUIERDA:
                if (personaje_x > 0 && laberinto[personaje_y][personaje_x - 1] != 0) {
                    personaje_x--;
                    laberinto[personaje_y][personaje_x] = PERSONAJE;
                    laberinto[personaje_y][personaje_x + 1] = 0;
                }
                break;
            case TECLA_DERECHA:
                if (personaje_x < COLUMNAS - 1 && laberinto[personaje_y][personaje_x + 1] != 0) {
                    personaje_x++;
                    laberinto[personaje_y][personaje_x] = PERSONAJE;
                    laberinto[personaje_y][personaje_x - 1] = 0;
                }
                break;
        }

        // Comprueba si el personaje ha encontrado la llave
        if (personaje_x == llave_x && personaje_y == llave_y) {
            llave_recolectada = 1;
        }

        // Comprueba si el personaje ha sido atacado por un enemigo
        if (personaje_x == enemigo1_x && personaje_y == enemigo1_y) {
            vida--;
            laberinto[personaje_y][personaje_x] = 0;
            enemigo1_x = rand() % COLUMNAS;
            enemigo1_y = rand() % FILAS;
            laberinto[enemigo1_y][enemigo1_x] = ENEMIGO;
        } else if (personaje_x == enemigo2_x && personaje_y == enemigo2_y) {
            vida--;
            laberinto[personaje_y][personaje_x] = 0;
            enemigo2_x = rand() % COLUMNAS;
            enemigo2_y = rand() % FILAS;
            laberinto[enemigo2_y][enemigo2_x] = ENEMIGO;
        }

        // Comprueba si el personaje ha muerto
        if (vida == 0) {
            addstr("¡Game Over!");
            refresh();
            delay(2000);
            break;
        }

        // Actualiza la pantalla
        refresh();
        delay(100);
    }

    // Termina la biblioteca ncurses
    endwin();

    return 0;
}
```

Este código crea un laberinto de 10x10 con un personaje, dos enemigos y una llave. El personaje se puede mover con las teclas `W`, `S`, `A` y `D`. El objetivo es encontrar la llave y regresar al punto de partida sin ser atacado por los enemigos. Si el personaje muere, el juego termina.