Curso de lenguaje C Diseño Serpiente

2.1 Introducción a la función del programa

El juego de la serpiente es un minijuego clásico. Una serpiente está en una pared cerrada y un trozo de comida aparece aleatoriamente en la pared. presionando las cuatro teclas del cursor en el teclado, la serpiente se mueve hacia arriba, hacia abajo, hacia la izquierda y hacia la derecha. Si la serpiente derriba la comida con la cabeza, la comida se comerá. El cuerpo de la serpiente crecerá en una sección y 10. Se puntuarán puntos al mismo tiempo. Luego aparecerá comida, esperando a que la serpiente coma si la serpiente golpea una pared o El juego termina cuando el cuerpo se cruza y la cabeza de la serpiente derriba su propio cuerpo.

2.2 Descripción general del diseño del programa

Un juego debe tener una parte inicial, una parte de ejecución y una parte final (en realidad, la parte inicial y la parte de ejecución están integradas).

2.2.1 Ideas de diseño

La clave de este programa es representar la forma de la serpiente y el movimiento de la serpiente. Usa un rectángulo pequeño para representar una sección del cuerpo de la serpiente. Para cada sección del cuerpo, agrega un bloque rectangular y usa dos secciones para representar la cabeza de la serpiente. Al moverte, debes comenzar desde la cabeza de la serpiente, para que la serpiente no pueda moverse en la dirección opuesta, es decir, la cola de la serpiente no se puede cambiar por la cabeza de la serpiente. Si no se presiona ninguna tecla, la serpiente avanzará en la dirección actual por sí sola. Cuando el jugador presiona una tecla de dirección válida, la cabeza de la serpiente se mueve en la dirección especificada, moviendo una sección de su cuerpo en un solo paso. Se presiona una tecla de dirección válida, la cabeza de la serpiente se moverá en la dirección especificada. Primero determine la posición de la cabeza de la serpiente y luego el cuerpo de la serpiente se mueve con la cabeza de la serpiente. Los gráficos se realizan dibujando la serpiente desde la nueva posición. La cabeza de la serpiente en este momento, debido a la falta de Qingping, la posición de la serpiente original es una unidad diferente de la posición de la nueva serpiente, por lo que parece que la sociedad tiene una sección más del cuerpo, por lo que la última sección de la serpiente está cubierta. el color de fondo. La aparición y desaparición de los alimentos también están dibujadas y cubiertas por bloques rectangulares

2.2.2 ¿Diseño de estructura de datos e instrucciones de uso?

Parte inicial:

El juego se ejecuta en modo gráfico, por lo que el primer paso debe ser inicializar el modo gráfico, y luego debe haber una interfaz de inicio, al igual que la portada de un libro, configuro una pantalla de título del juego además de la pantalla de título del juego. , También configuré una pantalla de bienvenida. Después de la pantalla de título, se debe inicializar la parte en ejecución del juego, incluido dibujar el fondo cuando el juego se está ejecutando e inicializar algunas variables importantes del juego.

Parte de ejecución:

Como parte central del juego, contiene más funciones, es decir, más módulos. Primero, déjame simular el modo de juego Snake: una cierta serpiente. Apareció de repente en el mundo. Era muy corto y sus nervios motores eran anormales. No podía detener su TDAH. En su mundo, solo había comida. Tenía mucha hambre y codiciosa. cielo, pero lamentablemente no llegó a su boca; el hambriento protagonista, sin importar si era venenoso o no, y no preguntó de dónde venía la comida, se arrastró directo hacia la comida, se la comió, y su capacidad de asimilar; Más allá de lo imaginable, hizo que la comida fuera muy deliciosa. Rápidamente se convirtió en parte de mi cuerpo y su cuerpo se hizo más largo. Cuando comió el primer trozo de comida, Dios le dio un segundo trozo de comida, así que comió el segundo trozo de comida, y volvió a crecer, y luego hubo un tercer trozo de comida... Su cuerpo siguió alargándose, y no le importó. El problema con su cuerpo largo es que le cuesta darse la vuelta y continúa comiendo. Ahora solo abre bien la boca para que la comida tenga un canal verde. Pero una tarde se mordió y recordó que era una serpiente venenosa, por lo que se desmayó (no murió envenenada) o cuando cargó hacia la comida perdió el control y se estrelló contra la pared;

La primera ronda del bucle: el primer paso, aparece la comida; el segundo paso, la serpiente sigue moviéndose; el tercer paso, comprueba si la serpiente se golpea a sí misma o a la pared a partir del cuarto paso; el juego tiene dos líneas secundarias (A, B):

A: El cuarto paso, la serpiente no se toca a sí misma ni a la pared, la serpiente continúa avanzando, dibuja los movimientos de la serpiente; determinar si la serpiente ha comido comida, si la serpiente Después de comer comida, el cuerpo se alarga y la comida original desaparece. El sexto paso es que el jugador ingrese instrucciones de control para permitir que la serpiente cambie su dirección de movimiento en el segundo paso; el siguiente ciclo; el séptimo paso es el primer paso del segundo ciclo. Repite los pasos de la primera ronda;

B: En el cuarto paso, la serpiente se toca a sí misma o a la pared, finalizando el juego.

Parte final:

Cuando el juego termina, se muestra "GAME OVER", que es una regla común, y mi juego no es una excepción.

Además de la pantalla de final del juego, también configuré una pantalla de salida del juego, "Un buen comienzo y un buen final".

Con la división aproximada anterior, dividí todo el programa en (13 2) módulos (en realidad funciones)

2.2.3 Estructura del programa (diagrama de flujo)

Figura 2.1 Diagrama de flujo

De acuerdo con los requisitos de la tarea a procesar, planifique los datos de entrada y los resultados de salida, y determine la estructura de datos para almacenar los datos.

La estructura de datos en lenguaje C se refleja principalmente en el tipo de datos. Por lo tanto, al diseñar la programación en lenguaje C, las variables, matrices, punteros, etc. utilizados en el programa deben planificarse en su conjunto, como un todo. así como sus tipos. Esto es muy importante. Si elige una variable o matriz inapropiada durante este período, será muy difícil modificarla en el futuro.

Ahora analiza los elementos del juego de la Serpiente, y luego obtén sus correspondientes descripciones en el programa:

Serpiente:

Descripción básica: Longitud, color, ubicación .

Datos y tipos de datos correspondientes: Longitud: aunque se puede expresar mediante coordenadas, la cantidad de cálculo será muy grande, por lo que se convierte a una unidad más grande: el número de secciones, y cada sección es se describe como una longitud fija; Coordenadas: tipo entero; Color: tipo entero: coordenadas X, Y;

Descripción agregada: la dirección del movimiento de la serpiente, la vida de la serpiente.

Datos y tipos de datos correspondientes: estas descripciones están diseñadas para conectarse con la parte de entrada clave del programa y la parte que determina el final del juego. Sólo hay cuatro direcciones: arriba, abajo, izquierda y derecha. Se pueden configurar cuatro números enteros correspondientes: 3, 4, 2 y 1. En la vida sólo existen dos situaciones: muerte o vida, correspondientes a 0 o 1.

Comida: ?

Descripción básica: color, ubicación.

Datos y tipos de datos correspondientes: dado que el color está configurado para ser fijo, no se volverá a discutir. Posición: coordenadas X, Y.

Descripción añadida: la presencia de comida.

Datos y tipos de datos correspondientes: esto está configurado para evitar la aparición repetida de alimentos y está relacionado con la función de extraer alimentos. Solo hay dos valores: 0 o 1 (sin comida ni comida)

Otros elementos: pared, ya que existe como fondo en la pantalla, no hay indicación de que las paredes reales sean cuatro Un cuadro delimitador compuesto por líneas rectas, descritas por coordenadas.

Variables también necesarias: valores clave ingresados ​​en el teclado (como variables globales, números enteros); variables de bucle de uso frecuente; matrices de caracteres para puntuaciones de juegos (; velocidad de la serpiente).

Figura 2.2 Diagrama de flujo del algoritmo clave del movimiento continuo de la serpiente

2.2.4 Función y descripción del programa de cada módulo

Ideas de implementación e implementación de los módulos principales Descripción del diagrama de flujo del algoritmo:

El punto clave - Snakemove() donde la serpiente sigue moviéndose:

La serpiente sigue moviéndose, lo que significa que la siguiente sección de la serpiente reemplaza la sección anterior Posición, en la computadora, significa que las coordenadas de posición de la siguiente sección de la serpiente se convierten en las coordenadas de posición de la sección anterior. En lo anterior, las coordenadas de posición de la serpiente se han definido como un tipo de matriz. Un conjunto de coordenadas corresponde a la posición de una sección. Supongamos que hay i 1 sección, de 0 a i sección. son las coordenadas del tramo i-1 Las coordenadas del tramo i-1 toman las coordenadas del tramo i-2... hasta que el tramo 1 toma las coordenadas del tramo 0. Las coordenadas de la sección 0, es decir, las coordenadas de la cabeza de la serpiente, deben cambiar en una dirección determinada, y la cantidad de cambio es la longitud de cada sección de la serpiente. Esta rotación coordinada de la serpiente requiere una declaración de bucle para continuar.

?

2.2.5 Resultados del programa

Ejecute el programa para obtener el siguiente diagrama de interfaz inicial:

Figura 2.3 Diagrama de resultados del programa

Utilice un pequeño El rectángulo representa una sección del cuerpo de la serpiente. Para cada sección del cuerpo, se agrega un bloque rectangular y la cabeza de la serpiente está representada por dos secciones:

Figura 2.4 Diagrama de resultados del programa

p>

La serpiente no se toca a sí misma ni a la pared, la serpiente continúa avanzando:

Figura 2.5 Tabla de resultados del programa

Cuando el juego termina, se dice "GAME OVER". mostrado

Figura 2.6 Gráfico de resultados del programa

2.3 Código fuente del programa y comentarios

#define N 200

#include gráficos. hgt;

#include lt; stdlib.hgt;

#include lt;dos.hgt;

#define IZQUIERDA 0x4b00

#define DERECHA 0x4d00

#define ABAJO 0x5000

#define ARRIBA 0x4800

#define ESC 0x011b

int i, clave ;

int score=0; /*score*/

int gamespeed=50000; /*Ajusta la velocidad del juego tú mismo*/

struct Food{

int x; /*La abscisa de la comida*/

int y;/*La coordenada vertical de la comida*/

int yes;/ *Una variable para determinar si la comida debe aparecer*/

}comida;/*La estructura de la comida*/

struct Snake{

int x[N] ;

int y[N];

int node; /*El número de segmentos de la serpiente*/

int dirección; la serpiente se mueve*/

int vida; /* La vida de la serpiente, 0 viva, 1 muerta*/

}serpiente;

void Init(void );/*Controlador de gráficos*/

void Close(void);/*Fin del gráfico*/

void DrawK(void);/*Pantalla de inicio*/

void GameOver(void); /*Fin del juego*/

void GamePlay(void /*Jugar El proceso específico del juego*/

void PrScore(void); );/*Puntuación de salida*/

/*Función principal*/

void main(void){

Init() /*Controlador de gráficos* /

DrawK(); /*Pantalla de inicio*/

GamePlay(); /*Proceso de detalles del juego*/

Cerrar();/* Fin de gráficos*/}

/*Controlador de gráficos*/

void Init(void){

int gd=DETECT,gm;

registerbgidriver(EGAVGA_driver);

initgraph(amp;gd,amp;gm,"c:\\archivos de programa\\winyes \\tc20h\\bgi");

cleardevice();}

/*Inicie la pantalla, las coordenadas de la esquina superior izquierda son (50, 40) y las coordenadas de la esquina inferior derecha son (610, 460) pared*/

vacío D

rawK(void){

/*setbkcolor(LIGHTGREEN);*/

setcolor(11);

setlinestyle(SOLID_LINE, 0, THICK_WIDTH);/ *Establecer tipo de línea*/

for(i=50; ilt; =600; i =10)/*Dibujar valla*/? {

rectangle(i, 40, i 10, 49); /*borde superior*/

rectangle(i, 451, i 10, 460); /*borde inferior*/ }

for(i=40); ; ilt ;=450; i =10) ?{

rectangle(50,i,59,i 10); /*Lado izquierdo*/

rectangle(601,i, 610,i 10);/*lado derecho*/ }}

/*proceso específico de jugar*/

void GamePlay(void){

randomize();/ *Generador de números aleatorios*/

food.yes=1; /*1 significa que es necesario que aparezcan nuevos alimentos, 0 significa que los alimentos ya existen*/

serpiente .life=0;/ *Alive*/

snake.direction=1; /*Dirección a la derecha*/

snake.x[0]=100; [0]=100;/ *Cabeza de serpiente*/

snake.x[1]=110; serpiente.y[1]=100;

snake.node=2; /*Número de secciones*/

PrScore();/*Puntuación de salida*/

while(1)/*Puedes jugar el juego repetidamente y presionar la tecla ESC para finalizar */? {

while( !kbhit())/*La serpiente mueve su cuerpo por sí sola sin presionar un botón*/ ?{

if(food.yes==1 )/*Es necesario que aparezcan nuevos alimentos*/ {

food.x=rand()400 60;

food.y=rand()350 60;

while(food.x10!=0)/*food Después de aparecer aleatoriamente, la comida debe estar dentro de toda la cuadrícula, para que la serpiente pueda comerla*/

food.x;

while(food.y10!=0)

food.y;

food.yes=0 /*Hay comida en la pantalla*/ }

if(food.yes==0)/* Cuando haya comida en la pantalla, se mostrará*/ {

setcolor(GREEN);

rectangle(comida.x, comida.y, comida.x 10, comida.y-10 }

for(i=snake.node-1;igt;0;i--) /*Cada eslabón de la serpiente avanza, que es el algoritmo clave de la serpiente codiciosa*/ {

snake.x[i]=snake.x[i-1]; p>snake.y[i]=snake.y[i-1]; }

/*1, 2, 3, 4 representan las cuatro direcciones: derecha, izquierda, arriba y abajo. juicio para mover la cabeza de serpiente*/

switch(snake.direction) {

caso 1: Snake.x[0] =10;

caso 2: serpiente.x[0]-=10; descanso;

>

caso 3: serpiente.y[0]-=10; romper;

caso 4: serpiente.y[0] =10; i=3; ilt; Snake.node; i )/*Empieza desde el cuarto segmento de la serpiente para determinar si te golpeó, porque la cabeza de la serpiente tiene dos segmentos y es imposible dar la vuelta desde el tercer segmento*/ {

if(snake.x[i]==snake.x[0]amp;amp;snake.y[i]==snake.y[0]) {

GameOver();/* Fallo de visualización*/

snake.life=1;

break; lt; 55||snake. x[0]gt;595||snake.y[0]lt;55||

snake.y[0]gt;455)/*Si la serpiente golpeó la pared*/ {

GameOver() /*Este juego ha terminado*/

snake.life=1 /*La serpiente muere*/ }