Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » C/Visual C » juego de laberinto en c

C/Visual C - juego de laberinto en c

Volver
Nuevo Tema
<<>>
 
Vista:

juego de laberinto en c

Publicado por john (1 intervención) el 14/08/2001 22:36:10
diseño del algoritmo en c
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Diseño de un algoritmo para un juego de Laberinto en C

Publicado por Alejandro (913 intervenciones) el 10/10/2024 23:22:32
John, a continuación, te presento un diseño básico del algoritmo para un juego de laberinto en C. Este algoritmo utiliza una representación de matriz para el laberinto y permite al jugador moverse a través de él.

1. Representación del laberinto



Utilizaremos una matriz bidimensional donde:
- `0` representa un camino libre.
- `1` representa una pared.

1
2
3
4
5
6
7
8
9
10
#define FILAS 5
#define COLUMNAS 5
 
int laberinto[FILAS][COLUMNAS] = {
    {0, 1, 0, 0, 0},
    {0, 1, 0, 1, 0},
    {0, 0, 0, 1, 0},
    {1, 1, 0, 0, 0},
    {0, 0, 1, 1, 0}
};

2. Funciones principales



- Inicialización del laberinto: Cargar el laberinto en la matriz.
- Mostrar laberinto: Imprimir el laberinto en la consola.
- Movimiento del jugador: Permitir al jugador moverse por el laberinto.
- Verificación de ganador: Comprobar si el jugador ha llegado a la meta.

3. Algoritmo



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
#include <stdio.h>
 
#define FILAS 5
#define COLUMNAS 5
 
int laberinto[FILAS][COLUMNAS] = {
    {0, 1, 0, 0, 0},
    {0, 1, 0, 1, 0},
    {0, 0, 0, 1, 0},
    {1, 1, 0, 0, 0},
    {0, 0, 1, 1, 0}
};
 
int jugadorX = 0; // Posición inicial del jugador
int jugadorY = 0; // Posición inicial del jugador
 
void mostrarLaberinto() {
    for (int i = 0; i < FILAS; i++) {
        for (int j = 0; j < COLUMNAS; j++) {
            if (i == jugadorX && j == jugadorY) {
                printf("P "); // P para el jugador
            } else if (laberinto[i][j] == 1) {
                printf("# "); // # para las paredes
            } else {
                printf(". "); // . para los caminos libres
            }
        }
        printf("\n");
    }
}
 
int moverJugador(int nuevaX, int nuevaY) {
    if (nuevaX >= 0 && nuevaX < FILAS && nuevaY >= 0 && nuevaY < COLUMNAS) {
        if (laberinto[nuevaX][nuevaY] == 0) {
            jugadorX = nuevaX;
            jugadorY = nuevaY;
            return 1; // Movimiento válido
        }
    }
    return 0; // Movimiento inválido
}
 
int main() {
    char movimiento;
    while (1) {
        mostrarLaberinto();
        printf("Movimiento (w/a/s/d): ");
        scanf(" %c", &movimiento);
 
        switch (movimiento) {
            case 'w': moverJugador(jugadorX - 1, jugadorY); break; // Arriba
            case 's': moverJugador(jugadorX + 1, jugadorY); break; // Abajo
            case 'a': moverJugador(jugadorX, jugadorY - 1); break; // Izquierda
            case 'd': moverJugador(jugadorX, jugadorY + 1); break; // Derecha
            default: printf("Movimiento no válido.\n");
        }
 
        // Verificar si el jugador ha llegado a la meta (por ejemplo, en la esquina inferior derecha)
        if (jugadorX == FILAS - 1 && jugadorY == COLUMNAS - 1) {
            printf("¡Has llegado a la meta!\n");
            break;
        }
    }
    return 0;
}

Explicación del código



1. Representación del laberinto: Se define una matriz que representa el laberinto.
2. Mostrar laberinto: La función `mostrarLaberinto` imprime el estado actual del laberinto, mostrando la posición del jugador.
3. Movimiento del jugador: La función `moverJugador` verifica si el movimiento es válido y actualiza la posición del jugador.
4. Bucle principal: En el `main`, se ejecuta un bucle que permite al jugador ingresar movimientos hasta que llegue a la meta.

Este es un diseño básico y se puede expandir con características adicionales como niveles, enemigos, o un sistema de puntuación.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar