Le code du serpent c++ est [snake_position position[(N-2)*(N-2)+1], void Snake_position::initialize(int &j), {x = 1;y = j; char s[N][N]】.
[Recommandations d'apprentissage associées : Tutoriel vidéo C]
Analyse des idées
Parlons de toute l'idée de conception de Snake :
1
La caractéristique de Snake est qu'il génère de la nourriture de manière aléatoire puis la contrôle de haut en bas. Touches de direction gauche et droite. Le mouvement d'un serpent gourmand :
Quand il rencontre de la nourriture, il la mange, augmentant ainsi la longueur de son corps de un. Ici, "#" est utilisé comme tête de serpent, et. "*" est utilisé comme corps et nourriture du serpent.
Alors je me suis demandé : comment la nourriture produite peut-elle atteindre le caractère aléatoire ? En consultant les informations, nous avons appris que dans le fichier d'en-tête time.h, la fonction rand() est définie pour générer des nombres aléatoires. Voici les connaissances pertinentes :
Vue d'ensemble
La fonction rand() est une fonction aléatoire qui génère des nombres aléatoires. Il existe également des fonctions srand() en langage C.
Détails
(1) Pour utiliser cette fonction, vous devez d'abord inclure le fichier d'en-tête stdlib.h au début
#include
(2) Dans la bibliothèque standard C, la fonction rand() peut générer un nombre aléatoire entre 0~RAND_MAX, où RAND_MAX est un entier défini dans stdlib. h, qui concernait le système.
(3) La fonction rand() n'a pas de paramètres d'entrée et est directement référencée via l'expression rand(); par exemple, vous pouvez utiliser l'instruction suivante pour imprimer deux nombres aléatoires :
printf("Random numbers are: %i %i\n",rand(),rand());(4) Étant donné que la fonction rand() génère des entiers dans un ordre spécifié, les deux mêmes valeurs seront imprimées à chaque fois que l'instruction ci-dessus est exécutée. Par conséquent, le caractère aléatoire en langage C n'est pas vraiment aléatoire et est parfois appelé. nombre pseudo-aléatoire.
(5) Afin de permettre au programme de générer une nouvelle séquence de valeurs aléatoires à chaque fois qu'il est exécuté, nous fournissons généralement une nouvelle graine aléatoire au générateur de nombres aléatoires. La fonction srand() (de stdlib.h) peut générer un générateur de nombres aléatoires. Tant que les graines sont différentes, la fonction rand() générera différentes séquences de nombres aléatoires. srand() est appelé l'initialiseur du générateur de nombres aléatoires.
Comme la fonction srand() n'a pas été utilisée au début, après l'avoir exécutée plusieurs fois, il a été constaté que les positions des aliments générées après chaque exécution étaient cohérentes et que l'objectif du caractère aléatoire n'était pas vraiment atteint. Par conséquent, la fonction srand() est utilisée et la fonction time() est utilisée pour appeler une heure système à chaque fois comme graine de srand(). Étant donné que l'heure système de chaque appel est différente, la graine est différente à chaque fois, de sorte que la fonction rand() atteint l'objectif des nombres aléatoires. Voici les connaissances pertinentes sur la fonction time() :
La fonction time() renvoie le nombre de secondes de l'heure actuelle depuis l'époque Unix (1er janvier 1970 00:00:00 GMT).
est principalement utilisé pour obtenir l'heure actuelle du système. Le résultat renvoyé est de type time_t, et sa valeur représente l'heure depuis le 1er janvier 1970 UTC (temps universel coordonné) 00:00:00 (appelé). Le nombre de secondes entre l'heure Epoch des systèmes UNIX et le moment actuel. Appelez ensuite la fonction localtime pour convertir l'heure UTC représentée par time_t en heure locale (nous sommes dans la zone +8, soit 8 heures de plus que UTC) et convertissez-la en un type struct tm. Chaque membre de données de ce type représente le. respectivement année, mois, jour, heure, minute et seconde. Le fichier d'en-tête <time.h> doit être inclus.
Fonction de bibliothèque standard C
time_t time(time_t *t);
Si t est un pointeur nul, renvoie directement l'heure actuelle. Si t n'est pas un pointeur nul, lors du renvoi de l'heure actuelle, la valeur de retour est affectée à l'espace mémoire pointé par t.
De cette façon, des nombres aléatoires sont générés via la fonction rand(), et en prenant le modulo, des nombres aléatoires dans une certaine plage sont obtenus.
2.
Ensuite, il y a le problème de manger. Lorsque la tête de serpent rencontre une nourriture (la nourriture est en direction du serpent gourmand), elle transforme la nourriture en tête de serpent. , puis La tête de serpent d'origine est transformée en corps de serpent, atteignant ainsi l'objectif de manger.
Et s'il n'y a pas de nourriture ? Continuez simplement dans la direction d’origine ou dans la direction dans laquelle vous avez appuyé sur le clavier.
3.
Voici le problème de mise en œuvre Comment afficher chaque dynamique ? C'est-à-dire que le serpent gourmand avance pas à pas.
Ici, j'ai utilisé la fonction clock() Voici les connaissances pertinentes :
clock() est une fonction de synchronisation en C/C++, et le type de données qui lui est associé est <🎜. >. Dans MSDN, la fonction horloge est définie comme suit : clock_t
clock_t clock(void) ;
int start = clock();while(clock()-start<=gamespeed);
这样一个方式来达到了延时的目的，延时的时间则根据gamespeed的值来确定，当gamespeed值越小时，延时时间越短。经过延时后，再执行下一步代码，从而实现了贪吃蛇自动前进的功能和控制其前进的速度啦。
然而，仅仅有这些还是不行的，还需要解决输出问题。
通过查阅资料得知，system(“cls”);具有清屏的功能，清除当前屏幕上的内容，进行下一步的输出，因此我便使用了每动一下都要进行清屏，然后将贪吃蛇棋盘整个画面进行输出。
四、
为了增加游戏的娱乐性，我又从中加入了等级选择功能，通过输入数字来选择等级，等级越高，贪吃蛇移动速度越快，而且得分越高。得分规则：score += grade*20;
考虑到游戏的功能性，在游戏结束后输出得分情况，并提示是否继续游戏，而不是直接退出游戏，这样用户就不必每次游戏失败后重新打开程序进行游戏，而是通过选择的方式决定继续游戏或者退出游戏。
而且加入暂停功能，当玩家玩累了，需要暂停的时候，按下空格（space）键实现暂停，
但由于我的原因，无法解决需要按两下空格才能继续游戏的bug，就暂定为按两下空格键继续游戏吧。
#include <windows.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>
#include <cstring>
#include <cstdio>
#include <iostream>
#define N 22
using namespace std;
int gameover;
int x1, y1; // 随机出米
int x,y;
long start;
//=======================================
//类的实现与应用initialize
//=======================================
//下面定义贪吃蛇的坐标类
class snake_position
{
public:
int x,y; //x表示行，y表示列
snake_position(){};
void initialize(int &);//坐标初始化
};
snake_position position[(N-2)*(N-2)+1]; //定义贪吃蛇坐标类数组，有(N-2)*(N-2)个坐标
void snake_position::initialize(int &j)
{
x = 1;
y = j;
}
//下面定义贪吃蛇的棋盘图
class snake_map
{
private:
char s[N][N];//定义贪吃蛇棋盘，包括墙壁。
int grade, length;
int gamespeed; //前进时间间隔
char direction; // 初始情况下，向右运动
int head,tail;
int score;
bool gameauto;
public:
snake_map(int h=4,int t=1,int l=4,char d=77,int s=0):length(l),direction(d),head(h),tail(t),score(s){}
void initialize(); //初始化函数
void show_game();
int updata_game();
void setpoint();
void getgrade();
void display();
};
//定义初始化函数，将贪吃蛇的棋盘图进行初始化
void snake_map::initialize()
{
int i,j;
for(i=1;i<=3;i++)
s[1][i] = '*';
s[1][4] = '#';
for(i=1;i<=N-2;i++)
for(j=1;j<=N-2;j++)
s[i][j]=' '; // 初始化贪吃蛇棋盘中间空白部分
for(i=0;i<=N-1;i++)
s[0][i] = s[N-1][i] = '-'; //初始化贪吃蛇棋盘上下墙壁
for(i=1;i<=N-2;i++)
s[i][0] = s[i][N-1] = '|'; //初始化贪吃蛇棋盘左右墙壁
}
//============================================
//输出贪吃蛇棋盘信息
void snake_map::show_game()
{
system("cls"); // 清屏
int i,j;
cout << endl;
for(i=0;i<N;i++)
{
cout << '\t';
for(j=0;j<N;j++)
cout<<s[i][j]<<' '; // 输出贪吃蛇棋盘
if(i==2) cout << "\t等级：" << grade;
if(i==6) cout << "\t速度：" << gamespeed;
if(i==10) cout << "\t得分：" << score << "分" ;
if(i==14) cout << "\t暂停：按一下空格键" ;
if(i==18) cout << "\t继续：按两下空格键" ;
cout<<endl;
}
}
//输入选择等级
void snake_map::getgrade()
{
cin>>grade;
while( grade>7 || grade<1 )
{
cout << "请输入数字1-7选择等级，输入其他数字无效" << endl;
cin >> grade;
}
switch(grade)
{
case 1: gamespeed = 1000;gameauto = 0;break;
case 2: gamespeed = 800;gameauto = 0;break;
case 3: gamespeed = 600;gameauto = 0;break;
case 4: gamespeed = 400;gameauto = 0;break;
case 5: gamespeed = 200;gameauto = 0;break;
case 6: gamespeed = 100;gameauto = 0;break;
case 7: grade = 1;gamespeed = 1000;gameauto = 1;break;
}
}
//输出等级，得分情况以及称号
void snake_map::display()
{
cout << "\n\t\t\t\t等级：" << grade;
cout << "\n\n\n\t\t\t\t速度：" << gamespeed;
cout << "\n\n\n\t\t\t\t得分：" << score << "分" ;
}
//随机产生米
void snake_map::setpoint()
{
srand(time(0));
do
{
x1 = rand() % (N-2) + 1;
y1 = rand() % (N-2) + 1;
}while(s[x1][y1]!=' ');
s[x1][y1]='*';
}
char key;
int snake_map::updata_game()
{
gameover = 1;
key = direction;
start = clock();
while((gameover=(clock()-start<=gamespeed))&&!kbhit());
//如果有键按下或时间超过自动前进时间间隔则终止循环
if(gameover)
{
getch();
key = getch();
}
if(key == ' ')
{
while(getch()!=' '){};//这里实现的是按空格键暂停，按空格键继续的功能，但不知为何原因，需要按两下空格才能继续。这是个bug。
}
else
direction = key;
switch(direction)
{
case 72: x= position[head].x-1; y= position[head].y;break; // 向上
case 80: x= position[head].x+1; y= position[head].y;break; // 向下
case 75: x= position[head].x; y= position[head].y-1;break; // 向左
case 77: x= position[head].x; y= position[head].y+1; // 向右
}
if(!(direction==72||direction==80||direction==75 ||direction==77)) // 按键非方向键
gameover = 0;
else if(x==0 || x==N-1 ||y==0 || y==N-1) // 碰到墙壁
gameover = 0;
else if(s[x][y]!=' '&&!(x==x1&&y==y1)) // 蛇头碰到蛇身
gameover = 0;
else if(x==x1 && y==y1)
{ // 吃米，长度加1
length ++;
if(length>=8 && gameauto)
{
length -= 8;
grade ++;
if(gamespeed>=200)
gamespeed -= 200; // 改变贪吃蛇前进速度
else
gamespeed = 100;
}
s[x][y]= '#'; //更新蛇头
s[position[head].x][position[head].y] = '*'; //吃米后将原先蛇头变为蛇身
head = (head+1) % ( (N-2)*(N-2) ); //取蛇头坐标
position[head].x = x;
position[head].y = y;
show_game();
gameover = 1;
score += grade*20; //加分
setpoint(); //产生米
}
else
{ // 不吃米
s[position[tail].x][position[tail].y]=' ';//将蛇尾置空
tail= (tail+1) % ( (N-2) * (N-2) );//更新蛇尾坐标
s[position[head].x][position[head].y]='*'; //将蛇头更为蛇身
head= (head+1) % ( (N-2) * (N-2) );
position[head].x = x;
position[head].y = y;
s[position[head].x][position[head].y]='#'; //更新蛇头
gameover = 1;
}
return gameover;
}
//====================================
//主函数部分
//====================================
int main()
{
char ctn = 'y';
int nodead;
cout<<"\n\n\n\n\n\t\t\t 欢迎进入贪吃蛇游戏!"<<endl;//欢迎界面;
cout<<"\n\n\n\t\t\t 按任意键马上开始。。。"<<endl;//准备开始;;
getch();
while( ctn=='y' )
{
system("cls"); // 清屏
snake_map snake;
snake.initialize();
cout << "\n\n请输入数字选择游戏等级：" << endl;
cout << "\n\n\n\t\t\t1.等级一：速度 1000 \n\n\t\t\t2.等级二：速度 800 \n\n\t\t\t3.等级三：速度 600 ";
cout << "\n\n\t\t\t4.等级四：速度 400 \n\n\t\t\t5.等级五：速度 200 \n\n\t\t\t6.等级六：速度 100 \n\n\t\t\t7.自动升级模式" << endl;
snake.getgrade();//获取等级
for(int i=1;i<=4;i++)
{
position[i].initialize(i);//初始化坐标
}
snake.setpoint(); // 产生第一个米
do
{
snake.show_game();
nodead = snake.updata_game();
}while(nodead);
system("cls"); //清屏
cout << "\n\n\n\t\t\t\tGameover！\n\n"<<endl;
snake.display();//输出等级/得分情况
cout << "\n\n\n\t\t 是否选择继续游戏？输入 y 继续，n 退出" << endl;
cin >> ctn;
}
return 0;
}Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Quelles sont les différences entre le langage C++ et C
Ordre d'apprentissage recommandé pour C++ et Python
Analyse coût-efficacité de l'apprentissage de Python et C++
Le langage C est-il identique au C++ ?
Quel est le meilleur moyen d'apprendre en premier, le langage C ou le C++ ?
La différence et le lien entre le langage C et C++
Tutoriel de modification du logiciel C++ en chinois
Analyse coût-efficacité de l'apprentissage de Python, Java et C++
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
