C/Visual C - inquietud

 
Vista:

inquietud

Publicado por edison quintero (1 intervención) el 07/04/2003 23:00:23
la inquietud es como se podria hacer un concentrese en c++, ya que se como crear la matriz, pero no se como llenarla con caracteres ascci, sabiendo que el jugador al encontrar una pareja se le da un punto y sigue jugando, sino juega la otra persona.
la matriz tiene que mostrar la fugura que halla en la casilla del numero que escogio el jugador y si son iguales debe mostrar una "X".
como podria realizarlo?

espero respuesta

gracias por la atención prestada
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 de un juego de concentración en C++

Publicado por Alejandro (1153 intervenciones) el 13/05/2025 20:52:31
Para implementar un juego de concentración en C++, donde los jugadores deben encontrar pares de cartas representadas por caracteres ASCII, puedes seguir estos pasos. A continuación, te muestro un ejemplo básico que incluye la creación de la matriz, llenarla con caracteres ASCII, y la lógica para jugar.

Pasos para implementar el juego de concentración



1. Crear la matriz: Define una matriz que contenga los caracteres ASCII que representarán las cartas.

2. Llenar la matriz: Llena la matriz con pares de caracteres ASCII.

3. Mostrar la matriz: Crea una función para mostrar la matriz en la consola, mostrando "X" para las cartas que han sido descubiertas.

4. Lógica del juego: Implementa la lógica para que los jugadores seleccionen cartas y verifiquen si son iguales.

Ejemplo de código



Aquí tienes un ejemplo básico de cómo podría verse el código:

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
80
81
82
83
84
85
86
87
88
89
90
#include <iostream>
#include <vector>
#include <ctime>
#include <cstdlib>
 
const int SIZE = 4; // Tamaño de la matriz (4x4)
char board[SIZE][SIZE]; // Matriz del juego
bool revealed[SIZE][SIZE]; // Matriz para saber qué cartas han sido reveladas
 
// Función para inicializar el tablero
void initializeBoard() {
    char characters[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'};
    std::vector<char> deck;
 
    // Llenar el deck con pares de caracteres
    for (char c : characters) {
        deck.push_back(c);
        deck.push_back(c);
    }
 
    // Mezclar el deck
    std::srand(static_cast<unsigned int>(std::time(0)));
    std::random_shuffle(deck.begin(), deck.end());
 
    // Llenar la matriz con los caracteres
    for (int i = 0; i < SIZE; ++i) {
        for (int j = 0; j < SIZE; ++j) {
            board[i][j] = deck[i * SIZE + j];
            revealed[i][j] = false; // Inicialmente, todas las cartas están ocultas
        }
    }
}
 
// Función para mostrar el tablero
void displayBoard() {
    std::cout << "Tablero:\n";
    for (int i = 0; i < SIZE; ++i) {
        for (int j = 0; j < SIZE; ++j) {
            if (revealed[i][j]) {
                std::cout << board[i][j] << " ";
            } else {
                std::cout << "* "; // Carta oculta
            }
        }
        std::cout << std::endl;
    }
}
 
// Función principal del juego
int main() {
    initializeBoard();
    int score = 0;
    int turns = 0;
 
    while (score < (SIZE * SIZE) / 2) { // Mientras haya pares por encontrar
        displayBoard();
        int x1, y1, x2, y2;
 
        // Primer intento
        std::cout << "Jugador, elige la primera carta (fila columna): ";
        std::cin >> x1 >> y1;
 
        // Revelar la carta seleccionada
        revealed[x1][y1] = true;
        displayBoard();
 
        // Segundo intento
        std::cout << "Jugador, elige la segunda carta (fila columna): ";
        std::cin >> x2 >> y2;
 
        // Revelar la segunda carta
        revealed[x2][y2] = true;
        displayBoard();
 
        // Verificar si son iguales
        if (board[x1][y1] == board[x2][y2]) {
            std::cout << "¡Encontraste un par!\n";
            score++;
        } else {
            std::cout << "No son iguales. Intenta de nuevo.\n";
            revealed[x1][y1] = false; // Ocultar la carta nuevamente
            revealed[x2][y2] = false; // Ocultar la carta nuevamente
        }
 
        turns++;
    }
 
    std::cout << "¡Felicidades! Has encontrado todos los pares en " << turns << " intentos.\n";
    return 0;
}

Explicación del código:


- initializeBoard: Esta función inicializa el tablero con pares de caracteres ASCII y los mezcla.
- displayBoard: Muestra el estado actual del tablero, revelando las cartas descubiertas y ocultando las demás.
- Lógica del juego: En el bucle principal, los jugadores eligen dos cartas. Si son iguales, se incrementa el puntaje; si no, se ocultan nuevamente.

Consideraciones:


- Asegúrate de que las entradas del usuario sean válidas (por ejemplo, que estén dentro del rango de la matriz).
- Puedes expandir el juego para incluir más características, como múltiples jugadores o un sistema de puntuación más complejo.

Espero que este ejemplo te ayude a implementar tu juego de concentración. ¡Buena suerte, Edison!
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