C/Visual C - memorice

 
Vista:

memorice

Publicado por pedro (1 intervención) el 01/11/2002 02:59:35
necesito informacion de como crear en c el juego memorice,dos player,y con lo tipico del juego.
el juego es el de buscar cartas iguales entre un monton
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

Implementación del juego Memorice en C para dos jugadores

Publicado por Alejandro (913 intervenciones) el 31/03/2025 19:14:59
Aquí tienes una guía sobre cómo crear el juego Memorice (también conocido como Memory o Concentration) en C para dos jugadores. Este juego consiste en encontrar pares de cartas iguales entre un conjunto de cartas ocultas. A continuación, te proporcionaré un esquema básico y un ejemplo de código.

Estructura del juego



1. Tablero: Un arreglo que representa las cartas. Cada carta puede ser un número o un símbolo. Las cartas se colocan en un arreglo y se muestran al jugador en forma oculta.

2. Jugadores: Dos jugadores alternan turnos para seleccionar dos cartas.

3. Lógica del juego:
- Mostrar el tablero.
- Permitir a los jugadores seleccionar dos cartas.
- Verificar si las cartas seleccionadas son iguales.
- Si son iguales, se quedan descubiertas; si no, se ocultan nuevamente.
- El juego termina cuando todos los pares han sido encontrados.

Ejemplo de código en C



Aquí tienes un ejemplo básico de cómo implementar el juego Memorice en C:

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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
#define SIZE 4 // Tamaño del tablero (4x4)
 
void inicializarTablero(char tablero[SIZE][SIZE], char cartas[SIZE*SIZE]) {
    int index = 0;
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            tablero[j] = '*'; // Inicializar con cartas ocultas
        }
    }
 
    // Barajar las cartas
    for (int i = 0; i < SIZE * SIZE; i++) {
        int j = rand() % (SIZE * SIZE);
        char temp = cartas[i];
        cartas[i] = cartas[j];
        cartas[j] = temp;
    }
 
    // Colocar las cartas en el tablero
    index = 0;
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            tablero[i][j] = cartas[index++];
        }
    }
}
 
void mostrarTablero(char tablero[SIZE][SIZE]) {
    printf("Tablero:\n");
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j < SIZE; j++) {
            printf("%c ", tablero[i][j]);
        }
        printf("\n");
    }
}
 
int main() {
    char tablero[SIZE][SIZE];
    char cartas[SIZE * SIZE] ={'A', 'A', 'B', 'B', 'C', 'C', 'D', 'D', 'E', 'E', 'F', 'F', 'G', 'G', 'H', 'H'};
    int paresEncontrados = 0;
    int totalPares = SIZE * SIZE / 2;
    int jugador = 1;
 
    srand(time(NULL)); // Inicializar la semilla para la aleatoriedad
    inicializarTablero(tablero, cartas);
 
    while (paresEncontrados < totalPares) {
        mostrarTablero(tablero);
        printf("Jugador %d, elige dos cartas (fila columna):\n", jugador);
 
        int fila1, col1, fila2, col2;
        printf("Primera carta: ");
        scanf("%d %d", &fila1, &col1);
        printf("Segunda carta: ");
        scanf("%d %d", &fila2, &col2);
 
        // Verificar si las cartas son iguales
        if (tablero[fila1][col1] == tablero[fila2][col2]) {
            printf("¡Encontraste un par!\n");
            paresEncontrados++;
        } else {
            printf("No son iguales. Intenta de nuevo.\n");
            // Ocultar las cartas nuevamente
            tablero[fila1][col1] = '*';
            tablero[fila2][col2] = '*';
        }
 
        // Cambiar de jugador
        jugador = (jugador == 1) ? 2 : 1;
    }
 
    printf("¡Jugador %d ha ganado!\n", jugador);
    return 0;
}

Explicación del código



1. Inicialización:
- Se define un tablero de 4x4 y un arreglo de cartas que contiene pares de letras.
- Las cartas se barajan y se colocan en el tablero.

2. Mostrar tablero:
- Se imprime el tablero, mostrando las cartas ocultas (representadas por `*`).

3. Turnos de los jugadores:
- Los jugadores eligen dos cartas ingresando las coordenadas (fila y columna).
- Se verifica si las cartas son iguales. Si lo son, se incrementa el contador de pares encontrados; si no, se ocultan nuevamente.

4. Fin del juego:
- El juego termina cuando todos los pares han sido encontrados, y se declara al ganador.

Mejoras posibles



- Validar la entrada del usuario para asegurarse de que las coordenadas sean válidas.
- Implementar un temporizador o un límite de intentos.
- Agregar una interfaz gráfica utilizando bibliotecas como SDL o ncurses para una mejor experiencia de usuario.

Este código es un punto de partida básico. Puedes expandirlo y mejorarlo según tus necesidades. ¡Espero que esto te ayude a crear tu juego [i]Memorice
!
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