Juego de serpientes en C

En este artículo, la tarea es implementar un juego de serpientes básico . A continuación se dan algunas funcionalidades de este juego:

• La serpiente se representa con un símbolo 0 (cero).
• La fruta se representa con un símbolo * (asterisco).
• La serpiente puede moverse en cualquier dirección según el usuario con la ayuda del teclado (teclas W , A , S , D ).
• Cuando la serpiente come una fruta, la puntuación aumentará en 10 puntos.
• La fruta se generará automáticamente dentro de los límites.
• Cada vez que la serpiente toca el límite, el juego termina.

Pasos para crear este juego :

• Habrá cuatro funciones definidas por el usuario .
• Construya un límite dentro del cual se jugará el juego.
• Los frutos se generan aleatoriamente.
• Luego aumenta la puntuación cada vez que la serpiente coma una fruta.

Las funciones definidas por el usuario creadas en este programa se dan a continuación:

• Dibujar(): esta función crea el límite en el que se jugará el juego.
• Configuración(): esta función establecerá la posición de la fruta dentro del límite.
• Entrada(): esta función tomará la entrada del teclado.
• Lógica(): esta función establecerá el movimiento de la serpiente.

Funciones integradas utilizadas :

• kbhit(): Esta función en C se usa para determinar si una tecla ha sido presionada o no. Para utilizar esta función en un programa incluya el archivo de cabecera conio.h . Si se ha presionado una tecla, devuelve un valor distinto de cero; de lo contrario, devuelve cero.
• rand(): La función rand() se declara en stdlib.h . Devuelve un valor entero aleatorio cada vez que se llama.

Archivos de encabezado y variables :

• Los archivos de cabecera y las variables utilizadas en este programa son:

• Aquí incluya el archivo de encabezado <unistd.h> para la función sleep() .

Dibujar(): esta función es responsable de construir el límite dentro del cual se jugará el juego.

A continuación se muestra el programa C para construir el límite del contorno usando dibujar():

// C program to build the outline
// boundary using draw()
#include <stdio.h>
#include <stdlib.h>
int i, j, height = 30;
int width = 30, gameover, score;
  
// Function to draw a boundary
void draw()
{
    // system("cls");
    for (i = 0; i < height; i++) {
        for (j = 0; j < width; j++) {
            if (i == 0 || i == width - 1 || j == 0
                || j == height - 1) {
                printf("#");
            }
            else {
                printf(" ");
            }
        }
        printf("\n");
    }
}
  
// Driver Code
int main()
{
    // Function Call
    draw();
  
    return 0;
}

##############################
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
#                            #
##############################

setup(): nThisbfunction se usa para escribir el código para generar la fruta dentro del límite usando la función rand() .

• Usar rand()%20 porque el tamaño del límite es largo = 20 y ancho = 20 , por lo que la fruta se generará dentro del límite.

Entrada(): en esta función, el programador escribe el código para tomar la entrada del teclado (teclas W, A, S, D, X).

logic(): Aquí, escriba toda la lógica para este programa como para el movimiento de la serpiente, para aumentar la puntuación, cuando la serpiente toque el límite, el juego habrá terminado, para salir del juego y la generación aleatoria de la fruta. una vez la serpiente comerá la fruta.

sleep(): esta función en C es una función que retrasa la ejecución del programa durante la cantidad de segundos dada. En este código, sleep() se usa para ralentizar el movimiento de la serpiente para que sea fácil de jugar para el usuario.

main(): Desde la función main() se inicia la ejecución del programa. Llama a todas las funciones.

A continuación se muestra el programa C para construir el juego completo de la serpiente:

// C program to build the complete
// snake game
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
  
int i, j, height = 20, width = 20;
int gameover, score;
int x, y, fruitx, fruity, flag;
  
// Function to generate the fruit
// within the boundary
void setup()
{
    gameover = 0;
  
    // Stores height and width
    x = height / 2;
    y = width / 2;
label1:
    fruitx = rand() % 20;
    if (fruitx == 0)
        goto label1;
label2:
    fruity = rand() % 20;
    if (fruity == 0)
        goto label2;
    score = 0;
}
  
// Function to draw the boundaries
void draw()
{
    system("cls");
    for (i = 0; i < height; i++) {
        for (j = 0; j < width; j++) {
            if (i == 0 || i == width - 1
                || j == 0
                || j == height - 1) {
                printf("#");
            }
            else {
                if (i == x && j == y)
                    printf("0");
                else if (i == fruitx
                         && j == fruity)
                    printf("*");
                else
                    printf(" ");
            }
        }
        printf("\n");
    }
  
    // Print the score after the
    // game ends
    printf("score = %d", score);
    printf("\n");
    printf("press X to quit the game");
}
  
// Function to take the input
void input()
{
    if (kbhit()) {
        switch (getch()) {
        case 'a':
            flag = 1;
            break;
        case 's':
            flag = 2;
            break;
        case 'd':
            flag = 3;
            break;
        case 'w':
            flag = 4;
            break;
        case 'x':
            gameover = 1;
            break;
        }
    }
}
  
// Function for the logic behind
// each movement
void logic()
{
    sleep(0.01);
    switch (flag) {
    case 1:
        y--;
        break;
    case 2:
        x++;
        break;
    case 3:
        y++;
        break;
    case 4:
        x--;
        break;
    default:
        break;
    }
  
    // If the game is over
    if (x < 0 || x > height
        || y < 0 || y > width)
        gameover = 1;
  
    // If snake reaches the fruit
    // then update the score
    if (x == fruitx && y == fruity) {
    label3:
        fruitx = rand() % 20;
        if (fruitx == 0)
            goto label3;
  
    // After eating the above fruit
    // generate new fruit
    label4:
        fruity = rand() % 20;
        if (fruity == 0)
            goto label4;
        score += 10;
    }
}
  
// Driver Code
void main()
{
    int m, n;
  
    // Generate boundary
    setup();
  
    // Until the game is over
    while (!gameover) {
  
        // Function Call
        draw();
        input();
        logic();
    }
}

Producción:

Demostración: