设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 51单片机LCD12864液晶贪吃蛇游戏Proteus仿真源程序制作
返回列表 发新帖
查看: 4795|回复: 2
收起左侧

51单片机LCD12864液晶贪吃蛇游戏Proteus仿真源程序制作

  [复制链接]
ID:22266 发表于 2021-5-16 04:50 | 显示全部楼层 |阅读模式
源码+需要用到的辅助软件分享
仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）
51hei.png 2.png 3.png
我是一个普通二本学校电气的学生。今年大三。
这个东西是我大二的时候做的玩的。

这里面有我做51单片机+12864液晶的贪吃蛇游戏机的详细资料。仿真实物我都做过，效果我自己比较满意。花的精力也比较多，代码也全都是自己一行一行的写下来。所以做完之后想把这些东西都整理一下，然后放在上面，方便后面要做这些东西的人。
open精神在国内是很重要的说···0 0、

环境： keil V4.02    protues version 7.5
   
我先说下我这个东西最主要的几块。

1.单片机用的是stc的，51内核，你首先要会这个···

2.用状态机实现按键。这个里面有别人写的技术帖子··

3.液晶是12864，2种控制器都做过，一个控制器是ST7920带字库的，一个控制器是KS0108不带字库的。2个的英文资料我都放在里面了。首先得弄懂液晶要怎么样和单片机连接。
要在液晶上面做游戏，推荐先看英文资料，一定要看英文，研究液晶读写时序和初始化方法，然后找别人的程序，实现液晶的基本操作，画点，写汉字什么的，读液晶···然后自己写程序实现液晶的所有基本操作。这样才能对液晶有充分的认识，才能开始在上面做游戏。有了这个基础，以后学别的液晶也会快的多。

4.菜单，游戏少不了要用到菜单，比如选择难度，选择地图什么的。我里面放了一个别人的文档，看了之后应该就会自己写了。（注意文档里面讲的是用函数指针实现菜单，但是KEIL这个环境下用51函数指针会很困难，推荐像我那样直接传菜单号）

5.贪吃蛇游戏，推荐先不要看别人的程序，自己在电脑上面下个贪吃蛇游戏，玩的时候就观察贪吃蛇游戏的特征···比如蛇在怎么动，蛇要怎么描述，是每个点都描述还是只要蛇头蛇尾···蛇转弯的时候怎么写？  对于上面的问题，可以参考别人的程序，然后就开始动手画图什么的表示出来这些过程，一个功能一个功能逐一实现。（推荐看带字库的那个程序，那个程序代码是最终优化版本。思路很清晰···）

6.液晶的动画，动画实际上就是图片一张一张的显示，我在里面放了一个把彩色照片黑白二值化的工具，可以找到自己喜欢的GIF动画，用提取工具把照片一张一张提取出来，然后黑白二值化，然后取模工具取模，然后实现···虽然过程蛮枯燥，但是效果还不过，也可以学到不少东西。

最后希望大家在看这个的时候，特别是贪吃蛇游戏实现的时候，哪一个方面有更好的办法一定通知我，因为我觉得我实现贪吃蛇游戏的方法已经很不错了。如果能有更好的，我会非常希望学习下····

单片机源程序如下:
  1. #include <st7920.h>
  2. #include <tanchishe_resource.h>
  3. #define num 15

  5. //用来描述蛇在液晶上面一个点的结构体
  6. struct she
  7. {
  8.         unsigned char x,y;
  9.         unsigned int value;
  10.         unsigned char direction;        
  11. };

  13. struct loop_queue  //利用数组实现循环队列，拐点不会超过15个。所以大小选15足以。
  14. {   
  15.         unsigned int front;
  16.         unsigned int rear;
  17.         unsigned int count;
  18.         struct she dat[num];
  19. };
  20. //不熟悉数组实现循环队列的可以在纸上画一下操作过程

  22. struct she tou,wei,food; //蛇的头尾节点  和食物点
  23. struct loop_queue queue;//循环队列  蛇转弯则形成拐点 将拐点入队列  尾巴到达拐点则拐点出队列

  25. unsigned char flag_exit_game; //返回标志  为1时  从贪吃蛇游戏返回菜单
  26. unsigned char flag_game_over; //结束标志  为1时  显示游戏结束画面 同时使返回标志为1
  27. unsigned char tcs_key_flag;  //贪吃蛇在一次移动中   只允许捕获一次按键  也就是只能产生一个拐点
  28. unsigned char tcs_key_state; //用于按键状态机的实现
  29. unsigned int  tcs_df;  //贪吃蛇得分
  30. unsigned char tcs_stop;//贪吃蛇暂定功能的实现

  32. unsigned char tcs_nd;  //贪吃蛇难度的选择
  33. unsigned char tcs_dt;  //贪吃蛇地图的选择 这2个是全局变量  在menu里面要用到


  36. void tcs_bianjie(unsigned int he);//贪吃蛇游戏地图的实现和边界
  37. void timer0_initial();
  38. void timer1_initial();

  40. //循环队列的基本操作
  41. void queue_initial(struct loop_queue *q);  
  42. void queue_in(struct loop_queue *q,struct she h)  ;
  43. struct she queue_out(struct loop_queue *q)  ;

  45. void tcs_game_initial();
  46. void food_produce();

  48. void tcs_game()
  49. {
  50.         struct she check;  //用与暂存蛇即将移动的点  从而进行判断
  51.         unsigned int he;
  52.         unsigned char flag;//flag作为吃到食物的标志

  54.         flag_exit_game=0;
  55.         flag_game_over=0;
  56.         tcs_key_state=0;
  57.         tcs_df=0;
  58.         tcs_stop=1;

  60. //        draw_lcd_picture(&tcs_picture[0]); //贪吃蛇游戏画面
  61. //        delay_ms(2000);

  63.         tcs_bianjie(tcs_dt); //贪吃蛇游戏边界
  64.         tcs_game_initial();//贪吃蛇初始化  主要是设定蛇头蛇尾  并显示蛇
  65.         timer0_initial(); //定时器0工作在方式2  8位自动装初值  只计数不中断 用来产生随机数
  66.         timer1_initial(); //定时器1工作在方式1        16位     10ms中断一次扫描键盘

  68.         do
  69.         {
  70.                 food_produce();//产生一个随机数 即随即产生x y value3个值确定一个点为食物
  71.                 he=test_point_exist(food.x,food.y,food.value);//检测产生的点的地方是否已经有点存在
  72.         }
  73.         while(he==food.value);//如果随机数产生在蛇的身体以及边界上 则重新再产生一个  
  74.         draw_lcd_point(food.x,food.y,food.value);//显示食物 先读取这个点所在xy的情况 以免破坏现场
  75.         
  76.         queue_initial(&queue);//初始化循环队列  使队列空  front rear 即头尾指针为0

  78.         while(1)
  79.         {
  80.                 if(flag_exit_game==1)//如果游戏过程中按下返回键  则立即结束游戏  返回菜单
  81.                         break;
  82.                 if(flag_game_over==1)//如果游戏过程中蛇死了  则立即结束游戏 显示结束动画 按键后返回菜单
  83.                         break;
  84.                
  85.                 ET1=1;   //允许扫描按键          贪吃蛇游戏难度决定蛇2次移动之间的间隔时间  也就是检测按键的时间
  86.                 tcs_key_flag=0; //允许捕获按键  在检测按键时间内  只允许生产一个拐点  即捕获到一个有效的
  87.                                                 //按键以后  就置一这个变量 不允许再增加拐点
  88.                 while(tcs_stop==0);//暂定键按下会取反tcs_stop的值  从而实现暂停功能
  89.                 switch(tcs_nd)
  90.                 {
  91.                         case 0:  {delay_ms(10); break;}//0代表变态难度  蛇的2次移动之间只有10ms的机会检测键盘按下
  92.                         case 1:  {delay_ms(50); break;}//难度减小  2次移动间隔增加
  93.                         case 2:  {delay_ms(100); break;}
  94.                 }
  95.                 ET1=0;

  97.                 switch(tou.direction)//这个switch用来根据蛇头的x y value值以及当前蛇头移动的方向
  98.                                                          //取出蛇头要到达的下一个点  存入check中  来判断是否撞墙 吃到食物 什么的···
  99.                 {        
  100.                         case 0: {         
  101.                                                 check.y=tou.y;
  102.                                                 if(tou.value==0x0001)//x的值要发生改变
  103.                                                 {
  104.                                                         if(tou.x==3)//蛇碰到上屏幕的右边界  则回到左边界
  105.                                                                 check.x=0;
  106.                                                         else if(tou.x==11)//蛇碰到下屏幕的右边界  则回到左边界
  107.                                                                 check.x=8;
  108.                                                         else
  109.                                                                 check.x=tou.x+1;
  110.                                                         check.value=0x8000;
  111.                                                 }
  112.                                                 else
  113.                                                 {
  114.                                                         check.x=tou.x;
  115.                                                         check.value=tou.value>>1;
  116.                                                 }
  117.                                                  break ;
  118.                                         }//->向右y不变

  120.                         case 1: {//向下value值不变                                          
  121.                                                 check.value=tou.value;
  122.                                                 if(tou.y==31) //蛇头从在上下屏之间移动
  123.                                                 {
  124.                                                         if(tou.x<=3)//蛇头从上屏移动到下屏
  125.                                                                 check.x=tou.x+8;
  126.                                                         else                 //蛇头从下屏移动到上屏
  127.                                                                 check.x=tou.x-8;
  128.                                                         check.y=0;
  129.                                                 }
  130.                                                 else
  131.                                                 {
  132.                                                         check.y=tou.y+1;
  133.                                                         check.x=tou.x;  //蛇头的x值不变
  134.                                             }
  135.                                                 break ;
  136.                                         }

  138.                         case 2: {//<-向左y不变         
  139.                                                 check.y=tou.y;
  140.                                                 if(tou.value==0x8000)//x的值要发生改变
  141.                                                 {
  142.                                                         if(tou.x==0)//蛇碰到上屏幕的左边界  则回到右边界
  143.                                                                 check.x=3;
  144.                                                         else if(tou.x==8)//蛇碰到下屏幕的左边界  则回到右边界
  145.                                                                 check.x=11;
  146.                                                         else
  147.                                                                 check.x=tou.x-1;
  148.                                                         check.value=0x0001;
  149.                                                 }
  150.                                                 else
  151.                                                 {
  152.                                                         check.x=tou.x;
  153.                                                         check.value=tou.value<<1;
  154.                                                 }
  155.                                                  break ;
  156.                                         }

  158.                         case 3: { //↑         向上value不变
  159.                                                 check.value=tou.value;
  160.                                                 if(tou.y==0) //蛇头从在上下屏之间移动
  161.                                                 {
  162.                                                         if(tou.x<=3)//蛇头从上屏移动到下屏
  163.                                                                 check.x=tou.x+8;
  164.                                                         else                 //蛇头从下屏移动到上屏
  165.                                                                 check.x=tou.x-8;
  166.                                                         check.y=31;
  167.                                                 }
  168.                                                 else
  169.                                                 {
  170.                                                         check.y=tou.y-1;
  171.                                                         check.x=tou.x;  //蛇头的x值不变
  172.                                             }
  173.                                                 break ;
  174.                                         }        
  175.                 }                        
  176.                 flag=0;//初始化吃到食物标志  表示没有吃到        
  177.                 he=test_point_exist(check.x,check.y,check.value); // 检测蛇头移动的下一个点是否几经有点存在
  178.                 if(he==check.value) //如果前面的点已经存在        则可以是食物 或者是墙和蛇身
  179.                 {
  180.                         if(        (check.x==food.x) && (check.y==food.y) && (check.value==food.value) )//吃到食物
  181.                         {
  182.                                 flag=1;//吃到食物
  183.                                 tcs_df++;
  184.                                 write_lcd_shuzi(5,16,tcs_shuzi[tcs_df/100]       );                         //显示分数的百位
  185.                                 write_lcd_shuzi(6,16,tcs_shuzi[ (tcs_df%100)/10] );                                //                        十
  186.                                 write_lcd_shuzi(7,16,tcs_shuzi[tcs_df%10]        );                                //          个
  187.                         
  188.                                 food.direction=tou.direction;//食物本没有方向 但是为了下面的语句
  189.                                 tou=food; //食物就成了蛇头···蛇头的方向依然不变
  190.                                  
  191.                                 do
  192.                                 {
  193.                                         food_produce();
  194.                                         he=test_point_exist(food.x,food.y,food.value);
  195.                                 }
  196.                                 while(he==food.value);  
  197.                                 draw_lcd_point(food.x,food.y,food.value);//上面有说过  这个是产生并显示食物
  198.                         }
  199.                         else//撞到身体或者墙
  200.                         {
  201.                                 flag_game_over=1; // 游戏结束
  202.                         }
  203.                 }
  204.                 else  //什么都么有遇到 继续前进
  205.                 {
  206.                         check.direction=tou.direction;//这么做的理由同上 为了保持蛇头当前的移动方向
  207.                         tou=check;
  208.                         draw_lcd_point(tou.x,tou.y,tou.value);//画出此时的蛇头
  209.                 }

  211.                 //下面是对尾巴的操作               
  212.                
  213.                 if(flag==1)//如果吃到食物 直接结束此轮循环 尾巴不做任何操作
  214.                 {
  215.                
  216.                 }
  217.                 else
  218.                 {
  219.                         if (  (wei.x == queue.dat[queue.front].x) && ( wei.y==queue.dat[queue.front].y ) && ( wei.value== queue.dat[queue.front].value)  ) //如果尾巴到达拐点
  220.                         {
  221.                                  check=queue_out(&queue);         
  222.                                 wei.direction=check.direction; //尾巴按照拐点指示的方向走
  223.                         }
  224.                         else //如果没有到达拐点 尾巴移动的方向不变
  225.                         {
  226.                                        
  227.                         }                                                
  228.                                                                         
  229.                         switch( wei.direction ) //这个是尾巴的移动  以及尾巴节点数据的修改
  230.                         {
  231.                                 case 0:        {//->向右y不变        
  232.                                                         clear_lcd_point(wei.x,wei.y,wei.value);
  233.                                                         if(wei.value==0x0001)//x的值要发生改变
  234.                                                         {
  235.                                                                 if(wei.x==3)//蛇碰到上屏幕的右边界  则回到左边界
  236.                                                                         wei.x=0;
  237.                                                                 else if(wei.x==11)//蛇碰到下屏幕的右边界  则回到左边界
  238.                                                                         wei.x=8;
  239.                                                                 else
  240.                                                                         wei.x=wei.x+1;
  241.                                                                 wei.value=0x8000;
  242.                                                         }
  243.                                                         else
  244.                                                         {
  245.                                                                 wei.value=wei.value>>1;
  246.                                                         }
  247.                                                         break;
  248.                                                 }
  249.                                 case 1:        {//向下value值不变        
  250.                                                         clear_lcd_point(wei.x,wei.y,wei.value);
  251.                                                         if(wei.y==31) //蛇从在上下屏之间移动
  252.                                                         {
  253.                                                                 if(wei.x<=3)//蛇从上屏移动到下屏
  254.                                                                         wei.x=wei.x+8;
  255.                                                                 else                 //蛇从下屏移动到上屏
  256.                                                                         wei.x=wei.x-8;
  257.                                                                 wei.y=0;
  258.                                                         }
  259.                                                         else
  260.                                                         {
  261.                                                                 wei.y=wei.y+1;
  262.                                                     }
  263.                                                         break ;
  264.                                                         
  265.                                                     }                                                                                
  266.                                 case 2:        {//<-向左y不变   
  267.                                                         clear_lcd_point(wei.x,wei.y,wei.value);
  268.                                                         if(wei.value==0x8000)//x的值要发生改变
  269.                                                         {
  270.                                                                 if(wei.x==0)//蛇碰到上屏幕的左边界  则回到右边界
  271.                                                                         wei.x=3;
  272.                                                                 else if(wei.x==8)//蛇碰到下屏幕的左边界  则回到右边界
  273.                                                                         wei.x=11;
  274.                                                                 else
  275.                                                                         wei.x=wei.x-1;
  276.                                                                 wei.value=0x0001;
  277.                                                         }
  278.                                                         else
  279.                                                         {
  280.                                                                 wei.value=wei.value<<1;
  281.                                                         }
  282.                                                         break;
  283.                                                  }
  284.                                 case 3:        {//↑         向上value不变  
  285.                                                         clear_lcd_point(wei.x,wei.y,wei.value);
  286.                                                         if(wei.y==0) //蛇从在上下屏之间移动
  287.                                                         {
  288.                                                                 if(wei.x<=3)//蛇从上屏移动到下屏
  289.                                                                         wei.x=wei.x+8;
  290.                                                                 else                 //蛇从下屏移动到上屏
  291.                                                                         wei.x=wei.x-8;
  292.                                                                 wei.y=31;
  293.                                                         }
  294.                                                         else
  295.                                                         {
  296.                                                                 wei.y=wei.y-1;
  297.                                                             }
  298.                                                         break;
  299.                                                  }        
  300.                           }
  301.                 }                                                        
  302.         }        
  303.         TR0=0;
  304.         TR1=0;
  305.         ET1=0;  //退出游戏时 关闭游戏过程中用到的定时器0和1  然后定时器中断也要关闭


  308. }

  310. //状态机实现按键   参考里面资料别人的技术贴
  311. void timer1() interrupt 3
  312. {        
  313.         unsigned char tou_last_direction; //记录蛇头原来的移动方向
  314.         
  315.         TR1=0;
  316.         TH1=0xDC;               
  317.         TL1=0x00;

  319.         switch (tcs_key_state)
  320.         {
  321.                 case 0:        {                // 按键初始态
  322.                                         if ( (P2 & 0xfe) != 0xfe )   tcs_key_state = 1;        // 键被按下，状态转换到键确认态
  323.                                                 else          tcs_key_state = 0;
  324.                                         break;
  325.                                 }
  326.         
  327.                 case 1:        {                        // 按键确认态
  328.                                         if ( (P2 & 0xfe) != 0xfe)
  329.                                         {
  330.                                                 // 按键仍按下，此时确定记录一次有效按键
  331.                                                         tcs_key_state = 2;        // 状态转换到键释放态
  332.                                                         if(tcs_key_flag==0)         //如果此时允许捕获按键
  333.                                                         {
  334.                                                                 tou_last_direction=tou.direction;
  335.                                                                 switch(P2 & 0xfe)
  336.                                                                 {        
  337.                                                                         case 0xfc:        break; // 确定键  不进行任何操作
  338.                                                                         case 0xfa:        {  flag_exit_game=1;   break; }//返回键           结束游戏 返回菜单
  339.                                                                         case 0xbe:        {  tou.direction=3;break; }//↑
  340.                                                                         case 0xee:        {  tou.direction=2;break; }//←
  341.                                                                         case 0xde:        {  tou.direction=1;break; }//↓
  342.                                                                         case 0x7e:        {  tou.direction=0;break; }//->         
  343.                                                                         case 0xf6:  {  if(tcs_stop==0) tcs_stop=1; else tcs_stop=0; break;}//暂停键
  344.                                                                 }
  345.                                                 
  346.                                                                 if( (tou.direction==tou_last_direction) || (tou.direction+tou_last_direction==2) || (tou.direction+tou_last_direction==4) )
  347.                                                                 //如果本来就是按此方向移动   或者按键给的方向与蛇移动方向相反 则不做任何操作 此次按键无效
  348.                                                                 {
  349.                                                                         tou.direction=tou_last_direction; //   还原蛇头的移动方向
  350.                                                                 }
  351.                                                                 else //否则记录此头结点成为拐点           
  352.                                                                 {                        
  353.                                                                         queue_in(&queue,tou);
  354.                                                                         tcs_key_flag=1; //已经捕获到一次按键信息 这次移动拐点已经产生 关闭捕获键盘
  355.                                                                
  356. ……………………

  358. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
51单片机 12864液晶贪吃蛇游戏机（完美版）.7z (6.69 MB, 下载次数: 180)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:981320 发表于 2021-11-15 22:12 | 显示全部楼层
本帖最后由 Shrink001 于 2021-11-15 22:24 编辑

你好，关于你的单片机实现的贪吃蛇游戏的程序，我现在想降低程序在data中的内存，将一部分存储到xdata中，但是尝试了很久都没有成功，会出现各种报错，请问您有没有什么好的想法呢？求您解答一下我现在是把tcs_game.c文件中21,22行的两个结构体添加了xdata的前缀，data是降下来了程序也可以编译通过，但是在proteus仿真时会出现黄色的短路电平，不知道这个该怎么办。。。
回复

使用道具 举报

ID:981320 发表于 2021-11-15 22:19 | 显示全部楼层
求助！关于你的单片机实现的贪吃蛇游戏的程序，我现在想降低程序在data中的内存，将一部分存储到xdata中，但是尝试了很久都没有成功，会出现各种报错，请问您有没有什么好的想法呢？求您解答一下
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表