C/Visual C - Jugo de Gato

 
Vista:

Jugo de Gato

Publicado por Érick ramírez (7 intervenciones) el 28/03/2001 23:44:25
Necesito hacer un juego de GATO en este lenguaje, con modo gráfico y quiero aprender a usarlo, y ideas para hacer el gato.gracias
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

Creación de un juego de GATO con modo gráfico y aprendizaje del lenguaje

Publicado por Alejandro (913 intervenciones) el 11/09/2024 00:24:31
¡Hola, Érick!

Para crear un juego de GATO en C con modo gráfico, puedes utilizar la biblioteca gráfica SDL (Simple DirectMedia Layer). SDL es una biblioteca multiplataforma que te permite crear aplicaciones gráficas y juegos de manera sencilla.

Aquí tienes un ejemplo básico de cómo podrías implementar un juego de GATO utilizando SDL 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
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#include <SDL.h>
#include <stdio.h>
 
// Dimensiones de la ventana
const int WINDOW_WIDTH = 400;
const int WINDOW_HEIGHT = 400;
 
// Tamaño de cada casilla del gato
const int CELL_SIZE = 100;
 
// Número de filas y columnas del gato
const int NUM_ROWS = 3;
const int NUM_COLS = 3;
 
// Representación del tablero del gato
char board[NUM_ROWS][NUM_COLS] = { { ' ', ' ', ' ' },
                                   { ' ', ' ', ' ' },
                                   { ' ', ' ', ' ' } };
 
// Función para dibujar el tablero del gato
void drawBoard(SDL_Renderer* renderer) {
    // Limpiar la pantalla
    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
    SDL_RenderClear(renderer);
 
    // Dibujar las líneas verticales
    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
    for (int i = 1; i < NUM_COLS; i++) {
        SDL_RenderDrawLine(renderer, i * CELL_SIZE, 0, i * CELL_SIZE, WINDOW_HEIGHT);
    }
 
    // Dibujar las líneas horizontales
    for (int i = 1; i < NUM_ROWS; i++) {
        SDL_RenderDrawLine(renderer, 0, i * CELL_SIZE, WINDOW_WIDTH, i * CELL_SIZE);
    }
 
    // Dibujar las X y O en las casillas correspondientes
    for (int row = 0; row < NUM_ROWS; row++) {
        for (int col = 0; col < NUM_COLS; col++) {
            if (board[row][col] == 'X') {
                // Dibujar X
                SDL_RenderDrawLine(renderer, col * CELL_SIZE, row * CELL_SIZE, (col + 1) * CELL_SIZE, (row + 1) * CELL_SIZE);
                SDL_RenderDrawLine(renderer, col * CELL_SIZE, (row + 1) * CELL_SIZE, (col + 1) * CELL_SIZE, row * CELL_SIZE);
            } else if (board[row][col] == 'O') {
                // Dibujar O
                int centerX = col * CELL_SIZE + CELL_SIZE / 2;
                int centerY = row * CELL_SIZE + CELL_SIZE / 2;
                int radius = CELL_SIZE / 2 - 10;
                SDL_RenderDrawCircle(renderer, centerX, centerY, radius);
            }
        }
    }
 
    // Actualizar la pantalla
    SDL_RenderPresent(renderer);
}
 
// Función para manejar los eventos del juego
void handleEvents(SDL_Renderer* renderer) {
    SDL_Event event;
    while (SDL_PollEvent(&event)) {
        switch (event.type) {
            case SDL_QUIT:
                exit(0);
                break;
            case SDL_MOUSEBUTTONDOWN:
                // Obtener las coordenadas del clic del mouse
                int mouseX = event.button.x;
                int mouseY = event.button.y;
 
                // Calcular la casilla correspondiente
                int row = mouseY / CELL_SIZE;
                int col = mouseX / CELL_SIZE;
 
                // Verificar si la casilla está vacía
                if (board[row][col] == ' ') {
                    // Colocar la marca del jugador actual
                    board[row][col] = 'X';
 
                    // Dibujar el tablero actualizado
                    drawBoard(renderer);
 
                    // Simular el turno del oponente (IA)
                    // Aquí puedes implementar tu lógica para el movimiento del oponente
 
                    // Dibujar el tablero actualizado
                    drawBoard(renderer);
                }
                break;
        }
    }
}
 
int main() {
    // Inicializar SDL
    SDL_Init(SDL_INIT_VIDEO);
 
    // Crear la ventana y el renderer
    SDL_Window* window = SDL_CreateWindow("Juego de GATO", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WINDOW_WIDTH, WINDOW_HEIGHT, 0);
    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
 
    // Ciclo principal del juego
    while (1) {
        // Manejar los eventos del juego
        handleEvents(renderer);
    }
 
    // Liberar recursos y cerrar SDL
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
 
    return 0;
}

Este es solo un ejemplo básico para que puedas comenzar. Puedes agregar lógica adicional para implementar la inteligencia artificial del oponente, verificar el estado del juego (ganador, empate, etc.) y agregar elementos gráficos adicionales según tus necesidades.

Espero que esto te sea útil para comenzar a crear tu juego de GATO en C con modo gráfico. ¡Diviértete programando!

Saludos.
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