【51项目】51单片机自制小霸王游戏机

视频演示结果：

     纳新作品——小霸王游戏机
  
目录：

   目录
  视频演示结果：
  目录：
  前言：
  一、毗连方式：
  1.1 控制引脚
  1.2. 显示模块
  1.3. 定时器
  1.4. 游戏逻辑与硬件结合
  1.5. 中断处理
  二、源码分析：
  2.1. 全局变量与常量定义
  2.2. 游戏初始化函数
  2.3. 游戏状态与逻辑
  2.4. 辅助功能
  2.5. 显示与输入
  2.6. 中断处理
  2.7. 主函数
  2.8. 源码整合：
  完备工程源码获取方式：
  

---

  
  前言：

51单片机自制小霸王游戏机不仅是一个布满乐趣的DIY项目，而且蕴含了深刻的教诲和技术意义。通过这一过程，可以加深对嵌入式系统原理的明确，锻炼实践操作本领，同时也是一种对经典电子游戏文化的致敬和传承。

起首，这一项目使得制作者能够深入明确51单片机的内部结构和工作原理。51单片机作为一种基础的微控制器，其编程和硬件接口设计对于电子工程的学习者来说是基础且关键的。在自制游戏机的实践中，制作者必要对51单片机的I/O端口、定时器、中断系统等有深入的了解和运用，这有助于提升对微控制器应用的熟练度。
其次，自制小霸王游戏机的过程是对电子电路设计本领的考验和提升。从电路板的布局设计到元件的选择，再到焊接和调试，每一步都必要精细的操作和严谨的思考。这不仅能够锻炼动手本领，还能培养解决现实题目的本领。

此外，该项目具有浓重的文化意义。小霸王游戏机是很多80后乃至70后的童年影象，通过自制游戏机，可以体验复古游戏带来的乐趣，同时也是对谁人期间电子游戏文化的一种纪念和传承。
这一项目能够引发创新头脑和独立解决题目的本领。在制作过程中，可能会遇到各种预料之外的挑战，好比如何优化电路设计以减小体积，如何编写更高效的代码来提升游戏性能，如何使游戏机界面更友好等。这些题目的解决，都必要制作者发挥创新头脑，探求最佳解决方案。
末了，自制小霸王游戏机也是一种良好的技术交换方式。制作者可以将本身的设计分享给他人，通过社区交换获取反馈和建议，从而不停提升本身的技术程度，同时也促进了技术爱好者和偕行之间的交换与合作。
一、毗连方式：

1.1 控制引脚

• P2口：用于控制方向和确认操作。
  
  
  
  • 0x04: 表示向上移动。
    
  • 0x10: 表示向下移动。
    
  • 0x01: 表示向左移动。
    
  • 0x40: 表示向右移动。
    
  • 0x80: 表示确认操作。
    
  
  
• P3口：用于控制蜂鸣器。
  
  
  
  • P3^7 (loud): 控制蜂鸣器的开关状态。
    
  
  
• P0口：用于检测键盘输入，具体检测到哪个键由P0的值决定。
  
  
  
  • P0=0xf7: 检测第一列键盘输入。
    
  • P0=0xfb: 检测第二列键盘输入。
    
  • P0=0xfd: 检测第三列键盘输入。
    
  • P0=0xfe: 检测第四列键盘输入。
    
  
  

1.2. 显示模块

相干接口

• LCD接口：用于显示游戏信息和状态。
  
  
  
  • 涉及到LCD的初始化、位置设置、数据写入等操作。
    
  • wr_i_lcd 和 wr_d_lcd 函数用于写入指令和数据到LCD。
    
  
  

该代码主要涉及对 LCD 的控制，LCD 通常通过多个引脚与微控制器毗连。在本代码中，利用了一些特定的控制信号：

• RS (Register Select)：选择寄存器信号，用于选择指令寄存器或数据寄存器。rs=0表示指令寄存器，rs=1表示数据寄存器。
  
• RW (Read/Write)：读写控制信号。rw=0表示写操作，rw=1表示读操作。
  
• E (Enable)：使能信号。LCD 在 E 由高变低的瞬间捕获数据。
  
• busy_lcd()：检查 LCD 的繁忙状态，确保在其准备好之前不会发送新的指令或数据。
  

 数据线

• lcddata：用于发送指令或数据到 LCD 的数据线。在特定指令下，将数据或命令通报给 LCD。
  

 电路接口功能

• 延时函数 (delaynms)：用于产生精确的时间延长，以满足 LCD 的指令和数据处理的时间要求。通过软件延时的方式确保 LCD 在指令或数据写入后有充足的时间来完成操作。
  
• 初始化函数 (init_lcd)：对 LCD 举行初始化设置，包括配置 LCD 的指令集、显示控制和清屏等操作。
  
• 图像处理函数 (img_disp, lcd_set_dot, clear_pic)：这些函数用于在 LCD 上绘制图像或图形，通过操控特定的寄存器和位来改变显示内容。
  

硬件毗连

• 接口引脚：通常 LCD 与微控制器之间会有多个 GPIO 口毗连，上述信号（RS, RW, E, lcddata）都必要毗连到微控制器的相应引脚。
  
• 电源与接地：LCD 显示屏必要毗连合适的电源和接地，以确保稳定工作。
  

工作原理

• 指令与数据传输：通过上述信号的组合，微控制器可以发送差别的命令和数据到 LCD，实现各种显示结果。
  
• 繁忙检测：在执行新的指令或写入数据之前，通过 busy_lcd() 检测 LCD 的繁忙状态，以防止由于过快的指令发送导致的数据丢失或指令失效。
  

1.3. 定时器

• 定时器设置：
  
  
  
  • 利用定时器（如T1）来产生随机数，用于游戏逻辑中的随机天生（如食物位置的随机天生）。
    
  • TH1 和 TL1 分别用于设置定时器高位和低位。
    
  
  

1.4. 游戏逻辑与硬件结合

• 游戏状态：通过变量flag来控制差别的游戏状态，如贪吃蛇、飞机大战等。
  
• 随机数天生：利用定时器的计数值来随机天生游戏中的元素位置。
  

1.5. 中断处理

• 中断服务程序：负责处理按键输入。
  
  
  
  • 对应的中断例程负责检测按键输入，并根据输入修改游戏状态或控制动作（如改变方向、选择菜单选项等）。
    
  
  

电路接口主要包括按键检测、LCD显示、蜂鸣器控制等部分。通过这些硬件接口，代码实现了一个简单的游戏控制系统。每个硬件接口的功能都通过相应的端口和位定义清晰地映射到特定的操作上，如移动、选择、确认等。

二、源码分析：

2.1. 全局变量与常量定义

代码开头定义了一些全局变量和常量，用于控制游戏的状态和举动。

• 字符串常量：用于显示在 LCD 上的差别游戏名称和提示信息，如 name、game1、loser 等。
  
• 全局变量：如 p、px、length、flag、slect 等，这些变量用于控制菜单选择、游戏状态、长度计数等。
  
• 硬件接口：loud 是一个特别位（sbit），用于控制蜂鸣器的开关。
  

1. #include "includes.h"
2. #include "intrins.h"
3. #include "stdlib.h"
5. /*fx=0 ÓÒ
6.   fx=1 ×ó
7.   fx=2 ÉÏ
8.   fx=3 ÏÂ*/
9. /*P2 ÉÏ 0x04 ÏÂ 0x10 ×ó 0x01 ÓÒ 0x40 È·ÈÏ 0x80 */
10. uchar code name[]={"С°ÔÍõÓÎÏ·»ú"};
11. uchar code game1[]={"Ì°³ÔÉß"};
12. uchar code game2[]={"´òµØÊó"};
13. uchar code game3[]={"·É»ú´óÕ½"};
14. uchar code game4[]={"ͼƬ"};
15. uchar code loser[]={"ÄãÊäÁË"};
16. uchar code lxy1[]={"¼ÌÐø"};
17. uchar code lxy2[]={"·µ»Ø"};
18. uchar code cj[]={"³¤¶È: "};
19. uchar code fjs[]={"·É»ú: "};
20. char code  mouse[]={"ÀÏÊó: "};
21. uchar p=1,px=1;
22. uchar length=9;       
23. uchar flag=0,slect=0,choose=0;
24. uchar ran1,ran2,food=0;
25. uchar planex[3]={28,30,0};
26. uchar zidan_x[10]={0},zidan_y[10]={0};
27. uchar boom_x[10]={0},boom_y[10]={0};
28. char dishu=0;
29. sbit loud=P3^7;                                       
30. struct xx
31. {
32.     char x[22];
33.         char y[22];
34.         char head;
35.         char tail;
36.         char dir;
37. }snake;

复制代码

 
2.2. 游戏初始化函数

• snake_init()：初始化贪吃蛇游戏的状态，在 LCD 上绘制初始蛇的形状，并设置蛇的坐标、头尾指针和方向。
  

1. void snake_init(void)
2. {
3.    lcd_set_dot(1,1,0);
4.    lcd_set_dot(2,1,0);
5.    lcd_set_dot(3,1,0);
6.    lcd_set_dot(4,1,0);
7.    lcd_set_dot(5,1,0);
8.    lcd_set_dot(6,1,0);
9.    snake.x[0]=1;snake.y[0]=1;
10.    snake.x[1]=2;snake.y[1]=1;
11.    snake.x[2]=3;snake.y[2]=1;
12.    snake.x[3]=4;snake.y[3]=1;
13.    snake.x[4]=5;snake.y[4]=1;
14.    snake.x[5]=6;snake.y[5]=1;
15.    snake.head=5;
16.    snake.tail=0;
17.    snake.dir=0;       
18. }

复制代码

2.3. 游戏状态与逻辑

• die()：处理游戏失败的情况，显示失败信息并等候用户选择继续或返回。
  
• cata()：菜单选择功能，显示可选游戏列表，并根据用户输入更新选择。
  
• game_snake()：贪吃蛇游戏的焦点逻辑，包括蛇的移动、食物天生、碰撞检测等。
  
• game_plane()：飞机大战游戏的逻辑，处理子弹和敌机的碰撞、飞机的移动等。
  
• game_mouse()：打地鼠游戏逻辑，随机天生地鼠位置，并检测玩家是否成功击中。
  

1. void die(void)
2. {
3.         uchar i;
4.         loud=0;
5.         flag=5;
6.         clear_pic();
7.         wr_i_lcd(0x30);
8.         wr_i_lcd(0x01);
9.         i=0;
10.         lcd_pos(0,2);
11.         while(loser[i]!='\0')
12.         {
13.                 wr_d_lcd(loser[i]);
14.                 i++;
15.         }
16.         i=0;
17.         lcd_pos(2,0);
18.         while(lxy1[i]!='\0')
19.         {
20.                 wr_d_lcd(lxy1[i]);
21.                 i++;       
22.         }
23.         i=0;
24.         lcd_pos(2,5);
25.         while(lxy2[i]!='\0')
26.         {
27.                 wr_d_lcd(lxy2[i]);
28.                 i++;       
29.         }
30.         lcd_pos(3,0); wr_d_lcd('o');
31.         delay(1000);
32.         loud=1;
33.         while(flag==5);       
34. }
35. uchar cata(void)
36. {
37.         uchar i;
38.         i=0;
39.         slect=0;
40.         lcd_pos(0,0);
41.         wr_d_lcd('o');
42.         lcd_pos(0,1);
43.         while(game1[i]!='\0')
44.         {
45.                  wr_d_lcd(game1[i]);
46.                  i++;
47.         }
48.         lcd_pos(1,1);
49.         i=0;
50.         while(game3[i]!='\0')
51.         {
52.                  wr_d_lcd(game2[i]);
53.                  i++;
54.         }
55.         lcd_pos(2,1);
56.         i=0;
57.         while(game3[i]!='\0')
58.         {
59.                  wr_d_lcd(game3[i]);
60.                  i++;
61.         }
62.         lcd_pos(3,1);
63.         i=0;
64.         while(game4[i]!='\0')
65.         {
66.                  wr_d_lcd(game4[i]);
67.                  i++;
68.         }
69.         while(flag==0);       
70. }
71. void game_snake(void)
72. {
73.         uchar i,k,j;
74.         k=0;
75.         food=0;
76.         length=6;
77.         lcd_pos(3,0);
78.                 i=0;
79.                 while(cj[i]!='\0')
80.                 {
81.                          wr_d_lcd(cj[i]);
82.                         i++;       
83.                 }
84.                 wr_d_lcd(length+48);
85.                 while(1)
86.            {
87.                            if(food==0)
88.                         {
89.                                
90.                                 while(1)//·ÀÖ¹²úÉúµÄʳÎï³öÏÖÔÚÉß×Ô¼ºÉíÉÏ
91.                                 {
92.                                         ran1=TH1%59+1;
93.                                         ran2=TL1%30+1;
94.                                         food=1;
95.                                         i=snake.tail;
96.                                         while(i!=snake.head)
97.                                         {
98.                                                 if(snake.x[i]==ran1&&snake.y[i]==ran2)
99.                                                 {
100.                                                         break;
101.                                                 }
102.                                                 i++;
103.                                                 if(i==22) i=0;
104.                                                 if(i==snake.head)
105.                                                 {
106.                                                         if(snake.x[i]==ran1&&snake.y[i]==ran2)
107.                                                         {
108.                                                                 i=snake.head-1;
109.                                                                 break;
110.                                                         }
111.                                                 }       
112.                                         }
113.                                         if(i==snake.head) break;       
114.                                 }
115.                                 lcd_set_dot(ran1,ran2,0);
116.                         }
117.                         i=snake.tail;
118.                         while(i!=snake.head)//ÉßÒ§µ½×Ô¼º
119.                         {
120.                                 if(snake.x[i]==snake.x[snake.head]&&snake.y[i]==snake.y[snake.head])
121.                                 {
122.                                         die();       
123.                                         break;       
124.                                 }
125.                                 i++;
126.                                 if(i==22) i=0;
127.                         }
128.                         if(i!=snake.head) break;
129.                         if(snake.x[snake.head] >= 60 || snake.y[snake.head] >= 30 ||snake.x[snake.head] == 0 ||snake.y[snake.head] == 0) //ÉßÅöǽ
130.                         {
131.                                 die();       
132.                                 break;       
133.                         }
134.                            snake.head++;
135.                         if(snake.head==22)
136.                         {
137.                                 snake.head=0;
138.                                 if(snake.dir==0)         //ÓÒ
139.                                 {
140.                                         snake.x[snake.head]=snake.x[21]+1;
141.                                         snake.y[snake.head]=snake.y[21];       
142.                                 }
143.                                 else if(snake.dir==1)  //×ó
144.                                 {
145.                                         snake.x[snake.head]=snake.x[21]-1;
146.                                         snake.y[snake.head]=snake.y[21];       
147.                                 }
148.                                 else if(snake.dir==2) //ÏÂ
149.                                 {               
150.                                         snake.x[snake.head]=snake.x[21];
151.                                         snake.y[snake.head]=snake.y[21]+1;
152.                                 }
153.                                 else if(snake.dir==3) //ÉÏ
154.                                 {
155.                                         snake.x[snake.head]=snake.x[21];
156.                                         snake.y[snake.head]=snake.y[21]-1;       
157.                                 }       
158.                         }
159.                         else
160.                         {
161.                                 if(snake.dir==0)
162.                                 {
163.                                         snake.x[snake.head]=snake.x[snake.head-1]+1;
164.                                         snake.y[snake.head]=snake.y[snake.head-1];       
165.                                 }
166.                                 else if(snake.dir==1)
167.                                 {
168.                                         snake.x[snake.head]=snake.x[snake.head-1]-1;
169.                                         snake.y[snake.head]=snake.y[snake.head-1];       
170.                                 }
171.                                 else if(snake.dir==2)
172.                                 {
173.                                            snake.x[snake.head]=snake.x[snake.head-1];
174.                                         snake.y[snake.head]=snake.y[snake.head-1]+1;
175.                                 }
176.                                 else if(snake.dir==3)
177.                                 {
178.                                            snake.x[snake.head]=snake.x[snake.head-1];
179.                                         snake.y[snake.head]=snake.y[snake.head-1]-1;
180.                                 }
181.                         }
182.                         lcd_set_dot(snake.x[snake.head],snake.y[snake.head],0);
183.                         if(snake.x[snake.head]!=ran1 || snake.y[snake.head]!=ran2)//Éßû³Ôµ½Ê³Îï
184.                         {
185.                                
186.                                 lcd_set_dot(snake.x[snake.tail],snake.y[snake.tail],1);
187.                                 snake.tail++;
188.                                 if(snake.tail==22) snake.tail=0;
189.                         }
190.                         else  //Éß³Ôµ½Ê³Îï
191.                         {
192.                                 if(k<90) k+=10;
193.                                 loud=0;
194.                                 length++;
195.                                 wr_i_lcd(0x30);
196.                         //        wr_i_lcd(0x01);
197.                                 lcd_pos(3,3);
198.                                 wr_d_lcd(length/10+48);
199.                                 wr_d_lcd(length%10+48);
200.                                 food=0;
201.                         }
202.                         for(i=0;i<100;i++)
203.                                 for(j=0;j<100-k;j++)
204.                                         time_1ms(1000);
205.                        
206.                         loud=1;       
207.                    }       
208. }

复制代码

2.4. 辅助功能

• plane_init()：初始化飞机的位置和状态。
  
• back_ground()：绘制游戏背景，好比边界和初始分数。
  
• picture()：显示图片的功能，通过选择差别的图片页来更新显示内容。
  
• mouse_back()：初始化打地鼠游戏的背景。
  

1. void plane_init(void)
2. {
3.         uchar i;
4.         lcd_set_dot(29,29,0);
5.         lcd_set_dot(28,30,0);
6.         lcd_set_dot(30,30,0);
7.         lcd_set_dot(29,30,0);
8.         for(i=0;i<10;i++)
9.         {
10.                 zidan_x[i]=0;
11.                 zidan_y[i]=0;
12.                 boom_x[i]=0;
13.                 boom_y[i]=0;       
14.         }
15.         planex[0]=28;       
16.         planex[1]=30;
17. }
19. void back_ground(void)
20. {
21.         uchar i;
22.         clear_pic();
23.         wr_i_lcd(0x30);
24.         wr_i_lcd(0x01);
25.         for(i=0;i<=60;i++)
26.         {
27.                 lcd_set_dot(i,0,0);
28.                 lcd_set_dot(i,31,0);       
29.         }
30.         for(i=0;i<=32;i++)
31.         {
32.                 lcd_set_dot(0,i,0);
33.                 lcd_set_dot(60,i,0);       
34.         }
35.         if(flag==3)
36.         {
37.                 lcd_pos(3,0);
38.                 i=0;
39.                 while(fjs[i]!='\0')
40.                 {
41.                         wr_d_lcd(fjs[i]);
42.                         i++;
43.                 }
44.                 wr_d_lcd(length+48);
45.         }               
46. }
47. void game_plane(void)
48. {
49.         uchar i,t=0,j=0;
50.         while(1)
51.         {
52.                 i=0;
53.                 while(i<10)
54.                 {
55.                         j=0;
56.                         while(j<10)
57.                         {
58.                                 if(((zidan_x[i])==boom_x[j]) && ((zidan_y[i]-1==boom_y[j]) || (zidan_y[i]==boom_y[j])) && (zidan_x[i]!=0) && (zidan_y[i] != 0))
59.                                 {
60.                                         lcd_set_dot(zidan_x[i],zidan_y[i],1);
61.                                         lcd_set_dot(boom_x[j],boom_y[j],1);
62.                                         zidan_y[i]=0;
63.                                         zidan_x[i]=0;
64.                                         boom_x[j]=0;
65.                                         boom_y[j]=0;
66.                                         wr_i_lcd(0x30);
67.                                         length++;
68.                                         lcd_pos(3,3);
69.                                         if(length<10) wr_d_lcd(length+48);
70.                                         else
71.                                         {
72.                                                 wr_d_lcd(length/10+48);
73.                                                 wr_d_lcd(length%10+48);
74.                                         }
75.                                 }
76.                                 j++;
77.                         }
78.                         i++;
79.                 }
80.                 i=0;
81.                 while(i<10)
82.                 {
83.                         j=0;
84.                         while(j<10)
85.                         {
86.                                 if(((zidan_x[i])==boom_x[j]) && (zidan_y[i]-1==boom_y[j]) && (zidan_x[i]!=0) && (zidan_y[i] != 0))
87.                                 {
88.                                         lcd_set_dot(zidan_x[i],zidan_y[i],1);
89.                                         lcd_set_dot(boom_x[j],boom_y[j],1);
90.                                         zidan_y[i]=0;
91.                                         zidan_x[i]=0;
92.                                         boom_x[j]=0;
93.                                         boom_y[j]=0;
94.                                 }
95.                                 j++;
96.                         }
97.                         if((boom_x[i] ==planex[0]&& boom_y[i] ==29) || (boom_x[i] ==planex[1]&& boom_y[i] ==29) || ((boom_x[i] ==(planex[1]+planex[0])/2) && boom_y[i] ==29) )
98.                         {
99.                                 die();
100.                                 break;       
101.                         }
102.                         i++;
103.                 }
104.                 if(i!=10) break;
105.                 i=0;
106.                 t++;
107.                 ran2=TL1%59;
108.                 while(i<10)
109.                 {
110.                         if(zidan_x[i]!=0)
111.                         {
112.                                 if(zidan_y[i]==1)
113.                                 {
114.                                         lcd_set_dot(zidan_x[i],zidan_y[i],1);
115.                                         zidan_y[i]=0;
116.                                         zidan_x[i]=0;
117.                                 }
118.                                 else
119.                                 {
120.                                         lcd_set_dot(zidan_x[i],zidan_y[i],1); busy_lcd();
121.                                         zidan_y[i]--;
122.                                         lcd_set_dot(zidan_x[i],zidan_y[i],0);
123.                                 }       
124.                         }                                  
125.                         i++;
126.                 }
127.                
128.                 i=0;
129.                 while(boom_x[i]!=0) i++;
130.                 if(t==4)
131.                 {
132.                         t=0;
133.                         boom_x[i]=ran2+1;
134.                         boom_y[i]=1;
135.                 }
136.                 i=0;
137.                 while(i<10)
138.                 {
139.                         if(boom_x[i]!=0)
140.                         {
141.                                 if(boom_y[i]==30)
142.                                 {
143.                                         lcd_set_dot(boom_x[i],boom_y[i],1);
144.                                         boom_y[i]=0;
145.                                         boom_x[i]=0;               
146.                                 }
147.                                 else
148.                                 {
149.                                         lcd_set_dot(boom_x[i],boom_y[i],1); busy_lcd();
150.                                         boom_y[i]++;
151.                                         lcd_set_dot(boom_x[i],boom_y[i],0);
152.                                 }
153.                         }
154.                         i++;
155.                 }                       
156.                 for(i=0;i<200;i++)
157.                                 for(j=0;j<50;j++)
158.                                 {
159.                                 //        if(i==70) loud=1;
160.                                         time_1ms(1000);
161.                                 }        
162.         }       
163. }
164. void picture(void)
165. {
166.         img_disp(tab1);
167.         while(1)
168.         {
169.                 if(p!=px)
170.                 {
171.                         if(px==4)
172.                         {
173.                                 flag=0;
174.                                 break;
175.                         }
176.                         clear_pic();
177.                         p=px;
178.                         if(p==1) img_disp(tab1);
179.                 //        else if(p==2) img_disp(tab1);
180.                         else if(p==2) img_disp(tab3);
181.                        
182.                 }          
183.         }
184. }
185. void mouse_back(void)
186. {
187.         char i,j;
188.         clear_pic();
189.         wr_i_lcd(0x30);
190.         wr_i_lcd(0x01);       
191.         for(i=0;i<4;i++)
192.                 for(j=0;j<4;j++)
193.                 {
194.                         lcd_pos(i,j);
195.                         wr_d_lcd('o');       
196.                 }
197.         i=0;
198.         lcd_pos(1,4);
199.         while(mouse[i]!='\0')
200.         {
201.                 wr_d_lcd(mouse[i]);
202.                 i++;               
203.         }
204.         wr_d_lcd(length+48);
205. }

复制代码

 
2.5. 显示与输入

• lcd_pos()：设置 LCD 的显示位置，用于更新屏幕上的字符位置。
  
• lcd_set_dot()：在特定坐标设置点，用于绘制图形或游戏元素。
  
• clear_pic()：清除屏幕内容，为下一次显示做好准备。
  

1. void game_mouse(void)
2. {
3.         uchar i,j,k;
4.         k=0;
5.         length=0;
6.         while(1)
7.         {
8.                 ran1=TH1%4;
9.                 ran2=TL1%4;
10.                 lcd_pos(ran1,ran2);
11.                 wr_d_lcd(0x02);
12.                 dishu=1;
13.                 loud=0;
14.                 for(i=0;i<200;i++)
15.                                 for(j=0;j<200-k;j++)
16.                                 {
17.                                         if(i==70) loud=1;
18.                                         time_1ms(1000);
19.                                 }
20.                 if(k<150) k+=10;
21.                 if(dishu==1)
22.                 {
23.                         die();       
24.                         break;
25.                 }
26.                
27.                 lcd_pos(1,7);
28.                 length++;
29.                 if(length<10) wr_d_lcd(length+48);
30.                 else
31.                 {
32.                         wr_d_lcd(length/10+48); wr_d_lcd(length%10+48);       
33.                 }
34.                 lcd_pos(ran1,ran2);
35.                 wr_d_lcd('o');
36.         }
37. }

复制代码

 
2.6. 中断处理

• T0_()：中断服务程序，用于处理按键输入，根据按键的差别改变游戏状态或控制游戏举动。包括方向键和确认键的处理。
  

1. void T0_() interrupt 3
2. {
3.         /*P2 ÉÏ 0x04 ÏÂ 0x10 ×ó 0x01 ÓÒ 0x40 È·ÈÏ 0x80 */
4.         uchar temp,i,j;
5.         if(flag==1||flag==2)
6.         {
7.                 TH1=(65536-30000)/256;
8.                 TL1=(65536-30000)%256;
9.         }
10.         else
11.         {
12.                 TH1=(65536-200)/256;
13.                 TL1=(65536-200)%256;       
14.         }
15.         P2=0x00;
16.         temp=P2;
17.         if(temp!=0x00)
18.         {
19.                 time_1ms(20);
20.                 if(temp!=0x00)
21.                 {       
22.                         switch(temp)
23.                         {
24.                                 case 0x04:
25.                                 {
26.                                         loud=0;
27.                                          if(flag==0)
28.                                          {
29.                                                  lcd_pos(slect,0);
30.                                                  wr_d_lcd(' ');
31.                                                 if(slect==0) slect==3;
32.                                                 else slect--;
33.                                                 lcd_pos(slect,0);
34.                                                  wr_d_lcd('o');
35.                                                 while(P2!=0x00);
36.                                                 time_1ms(50);       
37.                                          }
38.                                          else if(flag==1)
39.                                                          if(snake.dir!=2) snake.dir=3;
40.                                         loud=1;
41.                                 }break;
42.                                 case 0x10:
43.                                 {
45.                                         loud=0;
46.                                         if(flag==0)
47.                                         {
48.                                                
49.                                                 lcd_pos(slect,0);
50.                                                  wr_d_lcd(' ');
51.                                                 if(slect==3) slect==0;
52.                                                 else slect++;
53.                                                 lcd_pos(slect,0);
54.                                                  wr_d_lcd('o');
55.                                                 while(P2!=0x00);
56.                                                 time_1ms(20);
57.                                         }
58.                                          else if(flag==1)
59.                                                  if(snake.dir!=3) snake.dir=2;
60.                                  loud=1;
61.                                 }break;
62.                                 case 0x01:
63.                                 {
64.                                         loud=0;
65.                                         if(flag==5)
66.                                         {
67.                                                 if(choose != 0)
68.                                                 {
69.                                                         lcd_pos(3,0);
70.                                                         wr_d_lcd('o');
71.                                                         lcd_pos(3,6);
72.                                                         wr_d_lcd(' ');
73.                                                         choose=0;
74.                                                         while(P2!=0x00);
75.                                                         time_1ms(20);       
76.                                                 }       
77.                                         }
78.                                          else if(flag==1)
79.                                          {
80.                                                 if(snake.dir!=0) snake.dir=1;
81.                                         }
82.                                             else if(flag==3)
83.                                          {
84.                                                  if(planex[0]>1)
85.                                                 {
86.                                                                
87.                                                         planex[0]--;
88.                                                         planex[1]--;
89.                                                         lcd_set_dot(planex[0],30,0); busy_lcd();
90.                                                         if((planex[0]-1)!=0) lcd_set_dot(planex[0]-1,30,1); busy_lcd();
91.                                                         lcd_set_dot(planex[1],30,0);  busy_lcd();
92.                                                         if((planex[1]+1)!=113) lcd_set_dot(planex[1]+1,30,1); busy_lcd();
93.                                                         lcd_set_dot((planex[0]+planex[1])/2,29,0); busy_lcd();
94.                                                         lcd_set_dot((planex[0]+planex[1])/2+1,29,1); busy_lcd();
95.                                                         while(P2!=0x00)
96.                                                         {
97.                                                                 i=0;
98.                                                                 while(i<10)
99.                                                                 {
100.                                                                         j=0;
101.                                                                         while(j<10)
102.                                                                         {
103.                                                                                 if(((zidan_x[i])==boom_x[j]) && (zidan_y[i]-1==boom_y[j]) && (zidan_x[i]!=0) && (zidan_y[i] != 0))
104.                                                                                 {
105.                                                                                         lcd_set_dot(zidan_x[i],zidan_y[i],1);
106.                                                                                         lcd_set_dot(boom_x[j],boom_y[j],1);
107.                                                                                         zidan_y[i]=0;
108.                                                                                         zidan_x[i]=0;
109.                                                                                         boom_x[j]=0;
110.                                                                                         boom_y[j]=0;
111.                                                                                         wr_i_lcd(0x30);
112.                                                                                         length++;
113.                                                                                         lcd_pos(3,3);
114.                                                                                         if(length<10) wr_d_lcd(length+48);
115.                                                                                         else
116.                                                                                         {
117.                                                                                                 wr_d_lcd(length/10+48);
118.                                                                                                 wr_d_lcd(length%10+48);
119.                                                                                         }
120.                                                                                 }
121.                                                                                 j++;
122.                                                                         }
123.                                                                         i++;
124.                                                                 }       
125.                                                         }
126.                                                         time_1ms(20);
127.                                                        
128.                                                 }
129.                                         }
130.                                         else if(flag==4)
131.                                         {
132.                                                 if(px>1) px--;
133.                                                 else if(px==1) px=2;
134.                                                 while(P2!=0x00);
135.                                                 time_1ms(20);
136.                                         }
137.                                         loud=1;               
138.                                 }break;
139.                                 case 0x40:
140.                                 {
141.                                         loud=0;
142.                                         if(flag==5)
143.                                         {
144.                                                 if(choose != 1)
145.                                                 {
146.                                                         lcd_pos(3,6);
147.                                                         wr_d_lcd('o');
148.                                                         lcd_pos(3,0);
149.                                                         wr_d_lcd(' ');
150.                                                         choose=1;
151.                                                         while(P2!=0x00);
152.                                                         time_1ms(20);       
153.                                                 }       
154.                                         }
155.                                          else if(flag==1)
156.                                          {
157.                                                 if(snake.dir!=1) snake.dir=0;
158.                                         }
159.                                          else if(flag==3)
160.                                          {
161.                                                  if(planex[1]<59)
162.                                                 {
163.                                                                                                
164.                                                         planex[1]++;
165.                                                         planex[0]++;
166.                                                         lcd_set_dot(planex[0],30,0); busy_lcd();
167.                                                         if((planex[0]-1)!=0) lcd_set_dot(planex[0]-1,30,1); busy_lcd();
168.                                                         lcd_set_dot(planex[1],30,0);  busy_lcd();
169.                                                         if((planex[1]+1)!=60) lcd_set_dot(planex[1]+1,30,1); busy_lcd();
170.                                                         lcd_set_dot((planex[0]+planex[1])/2,29,0); busy_lcd();
171.                                                         lcd_set_dot((planex[0]+planex[1])/2-1,29,1); busy_lcd();
172.                                                         while(P2!=0x00)
173.                                                         {
174.                                                                 i=0;
175.                                                                 while(i<10)
176.                                                                 {
177.                                                                         j=0;
178.                                                                         while(j<10)
179.                                                                         {
180.                                                                                 if(((zidan_x[i])==boom_x[j]) && (zidan_y[i]-1==boom_y[j]) && (zidan_x[i]!=0) && (zidan_y[i] != 0))
181.                                                                                 {
182.                                                                                         lcd_set_dot(zidan_x[i],zidan_y[i],1);
183.                                                                                         lcd_set_dot(boom_x[j],boom_y[j],1);
184.                                                                                         zidan_y[i]=0;
185.                                                                                         zidan_x[i]=0;
186.                                                                                         boom_x[j]=0;
187.                                                                                         boom_y[j]=0;
188.                                                                                         wr_i_lcd(0x30);
189.                                                                                         length++;
190.                                                                                         lcd_pos(3,3);
191.                                                                                         if(length<10) wr_d_lcd(length+48);
192.                                                                                         else
193.                                                                                         {
194.                                                                                                 wr_d_lcd(length/10+48);
195.                                                                                                 wr_d_lcd(length%10+48);
196.                                                                                         }
197.                                                                                 }
198.                                                                                 j++;
199.                                                                         }
200.                                                                         i++;
201.                                                                 }
202.                                                         }
203.                                                         time_1ms(20);
204.                                                        
206.                                                 }
207.                                          }
208.                                          else if(flag==4)
209.                                          {
210.                                                  if(px<2) px++;
211.                                                 else if(px==2) px=1;
212.                                                 while(P2!=0x00);
213.                                                 time_1ms(20);
214.                                          }
215.                                          loud=1;               
216.                                 }break;
217.                                 case 0x80:
218.                                 {
219.                                         loud=0;
220.                                         if(flag==0)
221.                                         {
222.                                                 if(slect==0) flag=1;
223.                                                 else if(slect==1) flag=2;
224.                                                 else if(slect==2) flag=3;
225.                                                 else if(slect==3) flag=4;
226.                                                 while(P2!=0x00);
227.                                                 time_1ms(20);
228.                                         }
229.                                         else if(flag==5)
230.                                         {
231.                                                 if(choose==0)
232.                                                 {
233.                                                         flag=slect+1;
234.                                                 }
235.                                                 else if(choose==1) flag=0;
236.                                                 choose=0;
237.                                                 while(P2!=0x00);
238.                                                 time_1ms(20);
239.                                         }
240.                                         else if(flag==3)
241.                                         {
242.                                                 i=0;
243.                                                 while(zidan_x[i]!=0) i++;
244.                                                 zidan_x[i]=planex[0]+1;
245.                                                 zidan_y[i]=28;
246.                                                 while(P2!=0x00);
247.                                                 time_1ms(100);       
248.                                         }               
249.                                         else if(flag==4)
250.                                         {
251.                                                 px=4;
252.                                                 while(P2!=0x00);
253.                                                 time_1ms(100);
254.                                         }
255.                                         loud=1;       
256.                                 }break;
257.                         }
258.                 }          
259.         }
260.         /*0x77           0xb7           0xd7           0xe7
261.           0x7b           0xbb           0xdb           0xeb
262.           0x7d           0xbd           0xdd           0xed
263.           0x7e     0xbe    0xde    0xee */
264.         P0=0xf7;
265.         temp=P0;
266.         if(temp!=0xf7)
267.         {
268.                
269.                 time_1ms(20);
270.                 if(temp!=0xf7)
271.                 {
272.                         switch(temp)
273.                         {
274.                                 case 0x77:
275.                                 {
276.                                         if(ran1==0&&ran2==0) dishu=0;       
277.                                 }break;
278.                                 case 0xb7:
279.                                 {
280.                                         if(ran1==0&&ran2==1) dishu=0;       
281.                                 }break;
282.                                 case 0xd7:
283.                                 {
284.                                         if(ran1==0&&ran2==2) dishu=0;
285.                                 }break;
286.                                 case 0xe7:
287.                                 {
288.                                         if(ran1==0&&ran2==3) dishu=0;       
289.                                 }break;
290.                         }
291.         //           while(P0!=0xf7);
292.                     time_1ms(20);
293.                 }
294.         }
295.         P0=0xfb;
296.         temp=P0;
297.         if(temp!=0xfb)
298.         {
299.                
300.                 time_1ms(20);
301.                 if(temp!=0xfb)
302.                 {
303.                         switch(temp)
304.                         {
305.                                 case 0x7b:
306.                                 {
307.                                         if(ran1==1&&ran2==0) dishu=0;               
308.                                 }break;
309.                                 case 0xbb:
310.                                 {
311.                                         if(ran1==1&&ran2==1) dishu=0;       
312.                                 }break;
313.                                 case 0xdb:
314.                                 {
315.                                         if(ran1==1&&ran2==2) dishu=0;
316.                                 }break;
317.                                 case 0xeb:
318.                                 {
319.                                         if(ran1==1&&ran2==3) dishu=0;       
320.                                 }break;
321.                         }
322.                 //        while(P0!=0xfb);
323.                     time_1ms(20);
324.                 }
325.         }
326.         P0=0xfd;
327.         temp=P0;
328.         if(temp!=0xfd)
329.         {
330.                
331.                 time_1ms(20);
332.                 if(temp!=0xfd)
333.                 {
334.                         switch(temp)
335.                         {
336.                                 case 0x7d:
337.                                 {
338.                                         if(ran1==2&&ran2==0) dishu=0;       
339.                                 }break;
340.                                 case 0xbd:
341.                                 {
342.                                         if(ran1==2&&ran2==1) dishu=0;                       
343.                                 }break;
344.                                 case 0xdd:
345.                                 {
346.                                         if(ran1==2&&ran2==2) dishu=0;
347.                                 }break;
348.                                 case 0xed:
349.                                 {
350.                                         if(ran1==2&&ran2==3) dishu=0;               
351.                                 }break;
352.                         }
353.         //           while(P0!=0xfd);
354.                     time_1ms(20);
355.                 }
356.         }
357.         P0=0xfe;
358.         temp=P0;
359.         if(temp!=0xfe)
360.         {
361.                
362.                 time_1ms(20);
363.                 if(temp!=0xfe)
364.                 {
365.                         switch(temp)
366.                         {
367.                                 case 0x7e:
368.                                 {       
369.                                         if(ran1==3&&ran2==0) dishu=0;       
370.                                 }break;
371.                                 case 0xbe:
372.                                 {
373.                                         if(ran1==3&&ran2==1) dishu=0;       
374.                                 }break;
375.                                 case 0xde:
376.                                 {
377.                                         if(ran1==3&&ran2==2) dishu=0;         
378.                                 }break;
379.                                 case 0xee:
380.                                 {
381.                                         if(ran1==3&&ran2==3) dishu=0;       
382.                                 }break;
383.                         }
384.                 //         while(P0!=0xfe);
385.                     time_1ms(20);
386.                 }
387.         }       
388. }

复制代码

 
2.7. 主函数

• main()：程序的入口，初始化 LCD，显示起始画面，进入主循环。根据差别的 flag 值进入相应的游戏模块或功能模块。
  

1. void main()
2. {
3.    char i=0,j;
4.    loud=1;
5.    init_lcd();     //³õʼ»¯
6.   img_disp(tab1);    //ÏÔʾͼÏñ
7.   delaynms(1000);
8.   wr_i_lcd(0x30);
9.    wr_i_lcd(0x01);
10.    lcd_pos(1,1);
11.    while(name[i]!='\0')
12.    {
13.                    wr_d_lcd(name[i]);
14.                 i++;
15.                 if(i%2!=0)loud=0;
16.                 delay(20000);
17.    }
18.    clear_pic();
19.    wr_i_lcd(0x30);
20.         wr_i_lcd(0x01);
21.         TMOD=0x10;
22.         TH1=(65536-8000)/256;
23.         TL1=(65536-8000)%256;
24.         EA=1;                 
25.         ET1=1;
26.         TR1=1;
27.         while(1)
28.         {
29.                 clear_pic();
30.                 wr_i_lcd(0x30);
31.                 wr_i_lcd(0x01);
32.                 cata();
33.                 if(flag==1)
34.                 {
35.                         while(flag==1)
36.                         {
37.                                 food=0;
38.                                 back_ground();
39.                                 snake_init();
40.                                 game_snake();
41.                         }       
42.                 }
43.                 if(flag==2)
44.                 {                       
45.                         while(flag==2)
46.                         {
47.                                 /*Ò»ÅÅ16¸öµØÊó
48.                                 00 01 02 03
49.                                 10 11 12 13
50.                                 20 21 22 23
51.                                 30 31 32 33*/
52.                                 length=0;
53.                                 mouse_back();
54.                                 game_mouse();
55.                         }               
56.                 }
57.                 if(flag==3)
58.                 {
59.                         while(flag==3)
60.                         {
61.                                 length=0;
62.                                 back_ground();
63.                                 plane_init();
64.                                 game_plane();
65.                         }       
66.                 }
67.                 if(flag==4)
68.                 {
69.                         px=1;
70.                         p=1;
71.                         clear_pic();
72.                         wr_i_lcd(0x30);
73.                         wr_i_lcd(0x01);
74.                         picture();               
75.                 }
76.         }
78.                
79. }

复制代码

2.8. 源码整合：

1. #include "includes.h"
2. #include "intrins.h"
3. #include "stdlib.h"
5. // 方向代码：0 右，1 左，2 上，3 下
6. // P2 端口：上 0x04，下 0x10，左 0x01，右 0x40，确认 0x80
8. uchar code name[] = {"小龟游戏机"};
9. uchar code game1[] = {"贪吃蛇"};
10. uchar code game2[] = {"打地鼠"};
11. uchar code game3[] = {"飞机大战"};
12. uchar code game4[] = {"图片"};
13. uchar code loser[] = {"你输了"};
14. uchar code lxy1[] = {"继续"};
15. uchar code lxy2[] = {"返回"};
16. uchar code cj[] = {"长度: "};
17. uchar code fjs[] = {"飞机: "};
18. char code mouse[] = {"老鼠: "};
20. // 全局变量定义
21. uchar p = 1, px = 1;
22. uchar length = 9;       
23. uchar flag = 0, slect = 0, choose = 0;
24. uchar ran1, ran2, food = 0;
25. uchar planex[3] = {28, 30, 0};
26. uchar zidan_x[10] = {0}, zidan_y[10] = {0};
27. uchar boom_x[10] = {0}, boom_y[10] = {0};
28. char dishu = 0;
30. sbit loud = P3^7; // 定义蜂鸣器的开关
32. // 贪吃蛇的结构体
33. struct xx {
34.     char x[22];
35.     char y[22];
36.     char head;
37.     char tail;
38.     char dir;
39. } snake;
41. // 贪吃蛇初始化函数
42. void snake_init(void) {
43.     lcd_set_dot(1, 1, 0);
44.     lcd_set_dot(2, 1, 0);
45.     lcd_set_dot(3, 1, 0);
46.     lcd_set_dot(4, 1, 0);
47.     lcd_set_dot(5, 1, 0);
48.     lcd_set_dot(6, 1, 0);
49.     snake.x[0] = 1; snake.y[0] = 1;
50.     snake.x[1] = 2; snake.y[1] = 1;
51.     snake.x[2] = 3; snake.y[2] = 1;
52.     snake.x[3] = 4; snake.y[3] = 1;
53.     snake.x[4] = 5; snake.y[4] = 1;
54.     snake.x[5] = 6; snake.y[5] = 1;
55.     snake.head = 5;
56.     snake.tail = 0;
57.     snake.dir = 0;       
58. }
60. // 游戏失败处理函数
61. void die(void) {
62.     uchar i;
63.     loud = 0; // 关闭蜂鸣器
64.     flag = 5; // 设置标志为5，表示游戏结束
65.     clear_pic();
66.     wr_i_lcd(0x30);
67.     wr_i_lcd(0x01);
68.     i = 0;
69.     lcd_pos(0, 2);
70.     while (loser[i] != '\0') {
71.         wr_d_lcd(loser[i]);
72.         i++;
73.     }
74.     i = 0;
75.     lcd_pos(2, 0);
76.     while (lxy1[i] != '\0') {
77.         wr_d_lcd(lxy1[i]);
78.         i++;       
79.     }
80.     i = 0;
81.     lcd_pos(2, 5);
82.     while (lxy2[i] != '\0') {
83.         wr_d_lcd(lxy2[i]);
84.         i++;       
85.     }
86.     lcd_pos(3, 0);
87.     wr_d_lcd('o');
88.     delay(1000);
89.     loud = 1; // 打开蜂鸣器
90.     while (flag == 5);       
91. }
93. // 游戏菜单选择
94. uchar cata(void) {
95.     uchar i;
96.     i = 0;
97.     slect = 0;
98.     lcd_pos(0, 0);
99.     wr_d_lcd('o');
100.     lcd_pos(0, 1);
101.     while (game1[i] != '\0') {
102.          wr_d_lcd(game1[i]);
103.          i++;
104.     }
105.     lcd_pos(1, 1);
106.     i = 0;
107.     while (game3[i] != '\0') {
108.          wr_d_lcd(game2[i]);
109.          i++;
110.     }
111.     lcd_pos(2, 1);
112.     i = 0;
113.     while (game3[i] != '\0') {
114.          wr_d_lcd(game3[i]);
115.          i++;
116.     }
117.     lcd_pos(3, 1);
118.     i = 0;
119.     while (game4[i] != '\0') {
120.          wr_d_lcd(game4[i]);
121.          i++;
122.     }
123.     while (flag == 0);       
124. }
126. // 贪吃蛇游戏逻辑
127. void game_snake(void) {
128.     uchar i, k, j;
129.     k = 0;
130.     food = 0;
131.     length = 6;
132.     lcd_pos(3, 0);
133.     i = 0;
134.     while (cj[i] != '\0') {
135.         wr_d_lcd(cj[i]);
136.         i++;       
137.     }
138.     wr_d_lcd(length + 48);
139.     while (1) {
140.         if (food == 0) {
141.             while (1) { // 确保生成的食物不在蛇身上
142.                 ran1 = TH1 % 59 + 1;
143.                 ran2 = TL1 % 30 + 1;
144.                 food = 1;
145.                 i = snake.tail;
146.                 while (i != snake.head) {
147.                     if (snake.x[i] == ran1 && snake.y[i] == ran2) {
148.                         break;
149.                     }
150.                     i++;
151.                     if (i == 22) i = 0;
152.                     if (i == snake.head) {
153.                         if (snake.x[i] == ran1 && snake.y[i] == ran2) {
154.                             i = snake.head - 1;
155.                             break;
156.                         }
157.                     }       
158.                 }
159.                 if (i == snake.head) break;       
160.             }
161.             lcd_set_dot(ran1, ran2, 0);
162.         }
163.         i = snake.tail;
164.         while (i != snake.head) { // 蛇碰到自己
165.             if (snake.x[i] == snake.x[snake.head] && snake.y[i] == snake.y[snake.head]) {
166.                 die();       
167.                 break;       
168.             }
169.             i++;
170.             if (i == 22) i = 0;
171.         }
172.         if (i != snake.head) break;
173.         if (snake.x[snake.head] >= 60 || snake.y[snake.head] >= 30 || snake.x[snake.head] == 0 || snake.y[snake.head] == 0) { // 蛇撞墙
174.             die();       
175.             break;       
176.         }
177.         snake.head++;
178.         if (snake.head == 22) {
179.             snake.head = 0;
180.             if (snake.dir == 0) { // 右
181.                 snake.x[snake.head] = snake.x[21] + 1;
182.                 snake.y[snake.head] = snake.y[21];       
183.             } else if (snake.dir == 1) { // 左
184.                 snake.x[snake.head] = snake.x[21] - 1;
185.                 snake.y[snake.head] = snake.y[21];       
186.             } else if (snake.dir == 2) { // 下
187.                 snake.x[snake.head] = snake.x[21];
188.                 snake.y[snake.head] = snake.y[21] + 1;
189.             } else if (snake.dir == 3) { // 上
190.                 snake.x[snake.head] = snake.x[21];
191.                 snake.y[snake.head] = snake.y[21] - 1;       
192.             }       
193.         } else {
194.             if (snake.dir == 0) {
195.                 snake.x[snake.head] = snake.x[snake.head - 1] + 1;
196.                 snake.y[snake.head] = snake.y[snake.head - 1];       
197.             } else if (snake.dir == 1) {
198.                 snake.x[snake.head] = snake.x[snake.head - 1] - 1;
199.                 snake.y[snake.head] = snake.y[snake.head - 1];       
200.             } else if (snake.dir == 2) {
201.                 snake.x[snake.head] = snake.x[snake.head - 1];
202.                 snake.y[snake.head] = snake.y[snake.head - 1] + 1;
203.             } else if (snake.dir == 3) {
204.                 snake.x[snake.head] = snake.x[snake.head - 1];
205.                 snake.y[snake.head] = snake.y[snake.head - 1] - 1;
206.             }
207.         }
208.         lcd_set_dot(snake.x[snake.head], snake.y[snake.head], 0);
209.         if (snake.x[snake.head] != ran1 || snake.y[snake.head] != ran2) { // 蛇没有吃到食物
210.             lcd_set_dot(snake.x[snake.tail], snake.y[snake.tail], 1);
211.             snake.tail++;
212.             if (snake.tail == 22) snake.tail = 0;
213.         } else {  // 蛇吃到食物
214.             if (k < 90) k += 10;
215.             loud = 0;
216.             length++;
217.             wr_i_lcd(0x30);
218.             // wr_i_lcd(0x01);
219.             lcd_pos(3, 3);
220.             wr_d_lcd(length / 10 + 48);
221.             wr_d_lcd(length % 10 + 48);
222.             food = 0;
223.         }
224.         for (i = 0; i < 100; i++)
225.             for (j = 0; j < 100 - k; j++)
226.                 time_1ms(1000);
228.         loud = 1;       
229.     }       
230. }
232. // 飞机初始化函数
233. void plane_init(void) {
234.     uchar i;
235.     lcd_set_dot(29, 29, 0);
236.     lcd_set_dot(28, 30, 0);
237.     lcd_set_dot(30, 30, 0);
238.     lcd_set_dot(29, 30, 0);
239.     for (i = 0; i < 10; i++) {
240.         zidan_x[i] = 0;
241.         zidan_y[i] = 0;
242.         boom_x[i] = 0;
243.         boom_y[i] = 0;       
244.     }
245.     planex[0] = 28;       
246.     planex[1] = 30;
247. }
249. // 游戏背景绘制
250. void back_ground(void) {
251.     uchar i;
252.     clear_pic();
253.     wr_i_lcd(0x30);
254.     wr_i_lcd(0x01);
255.     for (i = 0; i <= 60; i++) {
256.         lcd_set_dot(i, 0, 0);
257.         lcd_set_dot(i, 31, 0);       
258.     }
259.     for (i = 0; i <= 32; i++) {
260.         lcd_set_dot(0, i, 0);
261.         lcd_set_dot(60, i, 0);       
262.     }
263.     if (flag == 3) {
264.         lcd_pos(3, 0);
265.         i = 0;
266.         while (fjs[i] != '\0') {
267.             wr_d_lcd(fjs[i]);
268.             i++;
269.         }
270.         wr_d_lcd(length + 48);
271.     }               
272. }
274. // 飞机大战游戏逻辑
275. void game_plane(void) {
276.     uchar i, t = 0, j = 0;
277.     while (1) {
278.         i = 0;
279.         while (i < 10) {
280.             j = 0;
281.             while (j < 10) {
282.                 if (((zidan_x[i]) == boom_x[j]) && ((zidan_y[i] - 1 == boom_y[j]) || (zidan_y[i] == boom_y[j])) && (zidan_x[i] != 0) && (zidan_y[i] != 0)) {
283.                     lcd_set_dot(zidan_x[i], zidan_y[i], 1);
284.                     lcd_set_dot(boom_x[j], boom_y[j], 1);
285.                     zidan_y[i] = 0;
286.                     zidan_x[i] = 0;
287.                     boom_x[j] = 0;
288.                     boom_y[j] = 0;
289.                     wr_i_lcd(0x30);
290.                     length++;
291.                     lcd_pos(3, 3);
292.                     if (length < 10) wr_d_lcd(length + 48);
293.                     else {
294.                         wr_d_lcd(length / 10 + 48);
295.                         wr_d_lcd(length % 10 + 48);
296.                     }
297.                 }
298.                 j++;
299.             }
300.             i++;
301.         }
302.         i = 0;
303.         while (i < 10) {
304.             j = 0;
305.             while (j < 10) {
306.                 if (((zidan_x[i]) == boom_x[j]) && (zidan_y[i] - 1 == boom_y[j]) && (zidan_x[i] != 0) && (zidan_y[i] != 0)) {
307.                     lcd_set_dot(zidan_x[i], zidan_y[i], 1);
308.                     lcd_set_dot(boom_x[j], boom_y[j], 1);
309.                     zidan_y[i] = 0;
310.                     zidan_x[i] = 0;
311.                     boom_x[j] = 0;
312.                     boom_y[j] = 0;
313.                 }
314.                 j++;
315.             }
316.             if ((boom_x[i] == planex[0] && boom_y[i] == 29) || (boom_x[i] == planex[1] && boom_y[i] == 29) || ((boom_x[i] == (planex[1] + planex[0]) / 2) && boom_y[i] == 29)) {
317.                 die();
318.                 break;       
319.             }
320.             i++;
321.         }
322.         if (i != 10) break;
323.         i = 0;
324.         t++;
325.         ran2 = TL1 % 59;
326.         while (i < 10) {
327.             if (zidan_x[i] != 0) {
328.                 if (zidan_y[i] == 1) {
329.                     lcd_set_dot(zidan_x[i], zidan_y[i], 1);
330.                     zidan_y[i] = 0;
331.                     zidan_x[i] = 0;
332.                 } else {
333.                     lcd_set_dot(zidan_x[i], zidan_y[i], 1); busy_lcd();
334.                     zidan_y[i]--;
335.                     lcd_set_dot(zidan_x[i], zidan_y[i], 0);
336.                 }       
337.             }                                  
338.             i++;
339.         }
340.         
341.         i = 0;
342.         while (boom_x[i] != 0) i++;
343.         if (t == 4) {
344.             t = 0;
345.             boom_x[i] = ran2 + 1;
346.             boom_y[i] = 1;
347.         }
348.         i = 0;
349.         while (i < 10) {
350.             if (boom_x[i] != 0) {
351.                 if (boom_y[i] == 30) {
352.                     lcd_set_dot(boom_x[i], boom_y[i], 1);
353.                     boom_y[i] = 0;
354.                     boom_x[i] = 0;               
355.                 } else {
356.                     lcd_set_dot(boom_x[i], boom_y[i], 1); busy_lcd();
357.                     boom_y[i]++;
358.                     lcd_set_dot(boom_x[i], boom_y[i], 0);
359.                 }
360.             }
361.             i++;
362.         }                       
363.         for (i = 0; i < 200; i++)
364.             for (j = 0; j < 50; j++) {
365.                 // if (i == 70) loud = 1;
366.                 time_1ms(1000);
367.             }        
368.     }       
369. }
371. // 图片显示函数
372. void picture(void) {
373.     img_disp(tab1);
374.     while (1) {
375.         if (p != px) {
376.             if (px == 4) {
377.                 flag = 0;
378.                 break;
379.             }
380.             clear_pic();
381.             p = px;
382.             if (p == 1) img_disp(tab1);
383.             // else if (p == 2) img_disp(tab1);
384.             else if (p == 2) img_disp(tab3);
385.             
386.         }          
387.     }
388. }
390. // 打地鼠背景初始化
391. void mouse_back(void) {
392.     char i, j;
393.     clear_pic();
394.     wr_i_lcd(0x30);
395.     wr_i_lcd(0x01);       
396.     for (i = 0; i < 4; i++)
397.         for (j = 0; j < 4; j++) {
398.             lcd_pos(i, j);
399.             wr_d_lcd('o');       
400.         }
401.     i = 0;
402.     lcd_pos(1, 4);
403.     while (mouse[i] != '\0') {
404.         wr_d_lcd(mouse[i]);
405.         i++;               
406.     }
407.     wr_d_lcd(length + 48);
408. }
410. // 打地鼠游戏逻辑
411. void game_mouse(void) {
412.     uchar i, j, k;
413.     k = 0;
414.     length = 0;
415.     while (1) {
416.         ran1 = TH1 % 4;
417.         ran2 = TL1 % 4;
418.         lcd_pos(ran1, ran2);
419.         wr_d_lcd(0x02);
420.         dishu = 1;
421.         loud = 0;
422.         for (i = 0; i < 200; i++)
423.             for (j = 0; j < 200 - k; j++) {
424.                 if (i == 70) loud = 1;
425.                 time_1ms(1000);
426.             }
427.         if (k < 150) k += 10;
428.         if (dishu == 1) {
429.             die();       
430.             break;
431.         }
432.         
433.         lcd_pos(1, 7);
434.         length++;
435.         if (length < 10) wr_d_lcd(length + 48);
436.         else {
437.             wr_d_lcd(length / 10 + 48);
438.             wr_d_lcd(length % 10 + 48);       
439.         }
440.         lcd_pos(ran1, ran2);
441.         wr_d_lcd('o');
442.     }
443. }
445. // 主函数入口
446. void main() {
447.     char i = 0, j;
448.     loud = 1;
449.     init_lcd();     // 初始化LCD
450.     img_disp(tab1); // 显示图片
451.     delaynms(1000);
452.     wr_i_lcd(0x30);
453.     wr_i_lcd(0x01);
454.     lcd_pos(1, 1);
455.     while (name[i] != '\0') {
456.         wr_d_lcd(name[i]);
457.         i++;
458.         if (i % 2 != 0) loud = 0;
459.         delay(20000);
460.     }
461.     clear_pic();
462.     wr_i_lcd(0x30);
463.     wr_i_lcd(0x01);
464.     TMOD = 0x10;
465.     TH1 = (65536 - 8000) / 256;
466.     TL1 = (65536 - 8000) % 256;
467.     EA = 1;                 
468.     ET1 = 1;
469.     TR1 = 1;
470.     while (1) {
471.         clear_pic();
472.         wr_i_lcd(0x30);
473.         wr_i_lcd(0x01);
474.         cata();
475.         if (flag == 1) {
476.             while (flag == 1) {
477.                 food = 0;
478.                 back_ground();
479.                 snake_init();
480.                 game_snake();
481.             }       
482.         }
483.         if (flag == 2) {                       
484.             while (flag == 2) {
485.                 /* 一个4x4的打地鼠格子
486.                 00 01 02 03
487.                 10 11 12 13
488.                 20 21 22 23
489.                 30 31 32 33 */
490.                 length = 0;
491.                 mouse_back();
492.                 game_mouse();
493.             }               
494.         }
495.         if (flag == 3) {
496.             while (flag == 3) {
497.                 length = 0;
498.                 back_ground();
499.                 plane_init();
500.                 game_plane();
501.             }       
502.         }
503.         if (flag == 4) {
504.             px = 1;
505.             p = 1;
506.             clear_pic();
507.             wr_i_lcd(0x30);
508.             wr_i_lcd(0x01);
509.             picture();               
510.         }
511.     }
512. }
514. // 中断处理函数
515. void T0_() interrupt 3 {
516.     /* P2 上 0x04 下 0x10 左 0x01 右 0x40 确认 0x80 */
517.     uchar temp, i, j;
518.     if (flag == 1 || flag == 2) {
519.         TH1 = (65536 - 30000) / 256;
520.         TL1 = (65536 - 30000) % 256;
521.     } else {
522.         TH1 = (65536 - 200) / 256;
523.         TL1 = (65536 - 200) % 256;       
524.     }
525.     P2 = 0x00; // 初始化P2为0
526.     temp = P2;
527.     if (temp != 0x00) {
528.         time_1ms(20);
529.         if (temp != 0x00) {       
530.             switch (temp) {
531.                 case 0x04: { // 上键
532.                     loud = 0;
533.                     if (flag == 0) { // 菜单导航
534.                         lcd_pos(slect, 0);
535.                         wr_d_lcd(' ');
536.                         if (slect == 0) slect = 3;
537.                         else slect--;
538.                         lcd_pos(slect, 0);
539.                         wr_d_lcd('o');
540.                         while (P2 != 0x00);
541.                         time_1ms(50);       
542.                     } else if (flag == 1) { // 贪吃蛇游戏中
543.                         if (snake.dir != 2) snake.dir = 3;
544.                     }
545.                     loud = 1;
546.                 } break;
547.                 case 0x10: { // 下键
548.                     loud = 0;
549.                     if (flag == 0) { // 菜单导航
550.                         lcd_pos(slect, 0);
551.                         wr_d_lcd(' ');
552.                         if (slect == 3) slect = 0;
553.                         else slect++;
554.                         lcd_pos(slect, 0);
555.                         wr_d_lcd('o');
556.                         while (P2 != 0x00);
557.                         time_1ms(20);
558.                     } else if (flag == 1) { // 贪吃蛇游戏中
559.                         if (snake.dir != 3) snake.dir = 2;
560.                     }
561.                     loud = 1;
562.                 } break;
563.                 case 0x01: { // 左键
564.                     loud = 0;
565.                     if (flag == 5) { // 游戏失败后
566.                         if (choose != 0) {
567.                             lcd_pos(3, 0);
568.                             wr_d_lcd('o');
569.                             lcd_pos(3, 6);
570.                             wr_d_lcd(' ');
571.                             choose = 0;
572.                             while (P2 != 0x00);
573.                             time_1ms(20);       
574.                         }       
575.                     } else if (flag == 1) { // 贪吃蛇游戏中
576.                         if (snake.dir != 0) snake.dir = 1;
577.                     } else if (flag == 3) { // 飞机大战游戏中
578.                         if (planex[0] > 1) {
579.                             planex[0]--;
580.                             planex[1]--;
581.                             lcd_set_dot(planex[0], 30, 0); busy_lcd();
582.                             if ((planex[0] - 1) != 0) lcd_set_dot(planex[0] - 1, 30, 1); busy_lcd();
583.                             lcd_set_dot(planex[1], 30, 0);  busy_lcd();
584.                             if ((planex[1] + 1) != 113) lcd_set_dot(planex[1] + 1, 30, 1); busy_lcd();
585.                             lcd_set_dot((planex[0] + planex[1]) / 2, 29, 0); busy_lcd();
586.                             lcd_set_dot((planex[0] + planex[1]) / 2 + 1, 29, 1); busy_lcd();
587.                             while (P2 != 0x00) {
588.                                 i = 0;
589.                                 while (i < 10) {
590.                                     j = 0;
591.                                     while (j < 10) {
592.                                         if (((zidan_x[i]) == boom_x[j]) && (zidan_y[i] - 1 == boom_y[j]) && (zidan_x[i] != 0) && (zidan_y[i] != 0)) {
593.                                             lcd_set_dot(zidan_x[i], zidan_y[i], 1);
594.                                             lcd_set_dot(boom_x[j], boom_y[j], 1);
595.                                             zidan_y[i] = 0;
596.                                             zidan_x[i] = 0;
597.                                             boom_x[j] = 0;
598.                                             boom_y[j] = 0;
599.                                             wr_i_lcd(0x30);
600.                                             length++;
601.                                             lcd_pos(3, 3);
602.                                             if (length < 10) wr_d_lcd(length + 48);
603.                                             else {
604.                                                 wr_d_lcd(length / 10 + 48);
605.                                                 wr_d_lcd(length % 10 + 48);
606.                                             }
607.                                         }
608.                                         j++;
609.                                     }
610.                                     i++;
611.                                 }       
612.                             }
613.                             time_1ms(20);
614.                         }
615.                     } else if (flag == 4) { // 图片显示中
616.                         if (px > 1) px--;
617.                         else if (px == 1) px = 2;
618.                         while (P2 != 0x00);
619.                         time_1ms(20);
620.                     }
621.                     loud = 1;               
622.                 } break;
623.                 case 0x40: { // 右键
624.                     loud = 0;
625.                     if (flag == 5) { // 游戏失败后
626.                         if (choose != 1) {
627.                             lcd_pos(3, 6);
628.                             wr_d_lcd('o');
629.                             lcd_pos(3, 0);
630.                             wr_d_lcd(' ');
631.                             choose = 1;
632.                             while (P2 != 0x00);
633.                             time_1ms(20);       
634.                         }       
635.                     } else if (flag == 1) { // 贪吃蛇游戏中
636.                         if (snake.dir != 1) snake.dir = 0;
637.                     } else if (flag == 3) { // 飞机大战游戏中
638.                         if (planex[1] < 59) {
639.                             planex[1]++;
640.                             planex[0]++;
641.                             lcd_set_dot(planex[0], 30, 0); busy_lcd();
642.                             if ((planex[0] - 1) != 0) lcd_set_dot(planex[0] - 1, 30, 1); busy_lcd();
643.                             lcd_set_dot(planex[1], 30, 0);  busy_lcd();
644.                             if ((planex[1] + 1) != 60) lcd_set_dot(planex[1] + 1, 30, 1); busy_lcd();
645.                             lcd_set_dot((planex[0] + planex[1]) / 2, 29, 0); busy_lcd();
646.                             lcd_set_dot((planex[0] + planex[1]) / 2 - 1, 29, 1); busy_lcd();
647.                             while (P2 != 0x00) {
648.                                 i = 0;
649.                                 while (i < 10) {
650.                                     j = 0;
651.                                     while (j < 10) {
652.                                         if (((zidan_x[i]) == boom_x[j]) && (zidan_y[i] - 1 == boom_y[j]) && (zidan_x[i] != 0) && (zidan_y[i] != 0)) {
653.                                             lcd_set_dot(zidan_x[i], zidan_y[i], 1);
654.                                             lcd_set_dot(boom_x[j], boom_y[j], 1);
655.                                             zidan_y[i] = 0;
656.                                             zidan_x[i] = 0;
657.                                             boom_x[j] = 0;
658.                                             boom_y[j] = 0;
659.                                             wr_i_lcd(0x30);
660.                                             length++;
661.                                             lcd_pos(3, 3);
662.                                             if (length < 10) wr_d_lcd(length + 48);
663.                                             else {
664.                                                 wr_d_lcd(length / 10 + 48);
665.                                                 wr_d_lcd(length % 10 + 48);
666.                                             }
667.                                         }
668.                                         j++;
669.                                     }
670.                                     i++;
671.                                 }
672.                             }
673.                             time_1ms(20);
674.                         }
675.                     } else if (flag == 4) { // 图片显示中
676.                         if (px < 2) px++;
677.                         else if (px == 2) px = 1;
678.                         while (P2 != 0x00);
679.                         time_1ms(20);
680.                     }
681.                     loud = 1;               
682.                 } break;
683.                 case 0x80: { // 确认键
684.                     loud = 0;
685.                     if (flag == 0) { // 在菜单中选择游戏
686.                         if (slect == 0) flag = 1;
687.                         else if (slect == 1) flag = 2;
688.                         else if (slect == 2) flag = 3;
689.                         else if (slect == 3) flag = 4;
690.                         while (P2 != 0x00);
691.                         time_1ms(20);
692.                     } else if (flag == 5) { // 游戏失败后选择继续或返回
693.                         if (choose == 0) {
694.                             flag = slect + 1;
695.                         } else if (choose == 1) flag = 0;
696.                         choose = 0;
697.                         while (P2 != 0x00);
698.                         time_1ms(20);
699.                     } else if (flag == 3) { // 飞机大战游戏中
700.                         i = 0;
701.                         while (zidan_x[i] != 0) i++;
702.                         zidan_x[i] = planex[0] + 1;
703.                         zidan_y[i] = 28;
704.                         while (P2 != 0x00);
705.                         time_1ms(100);       
706.                     } else if (flag == 4) { // 图片显示中
707.                         px = 4;
708.                         while (P2 != 0x00);
709.                         time_1ms(100);
710.                     }
711.                     loud = 1;       
712.                 } break;
713.             }
714.         }          
715.     }
716.     // 检测P0口的输入，判断打地鼠游戏中的鼠标位置
717.     P0 = 0xf7;
718.     temp = P0;
719.     if (temp != 0xf7) {
720.         time_1ms(20);
721.         if (temp != 0xf7) {
722.             switch (temp) {
723.                 case 0x77: {
724.                     if (ran1 == 0 && ran2 == 0) dishu = 0;       
725.                 } break;
726.                 case 0xb7: {
727.                     if (ran1 == 0 && ran2 == 1) dishu = 0;       
728.                 } break;
729.                 case 0xd7: {
730.                     if (ran1 == 0 && ran2 == 2) dishu = 0;
731.                 } break;
732.                 case 0xe7: {
733.                     if (ran1 == 0 && ran2 == 3) dishu = 0;       
734.                 } break;
735.             }
736.             time_1ms(20);
737.         }
738.     }
739.     P0 = 0xfb;
740.     temp = P0;
741.     if (temp != 0xfb) {
742.         time_1ms(20);
743.         if (temp != 0xfb) {
744.             switch (temp) {
745.                 case 0x7b: {
746.                     if (ran1 == 1 && ran2 == 0) dishu = 0;               
747.                 } break;
748.                 case 0xbb: {
749.                     if (ran1 == 1 && ran2 == 1) dishu = 0;       
750.                 } break;
751.                 case 0xdb: {
752.                     if (ran1 == 1 && ran2 == 2) dishu = 0;
753.                 } break;
754.                 case 0xeb: {
755.                     if (ran1 == 1 && ran2 == 3) dishu = 0;       
756.                 } break;
757.             }
758.             time_1ms(20);
759.         }
760.     }
761.     P0 = 0xfd;
762.     temp = P0;
763.     if (temp != 0xfd) {
764.         time_1ms(20);
765.         if (temp != 0xfd) {
766.             switch (temp) {
767.                 case 0x7d: {
768.                     if (ran1 == 2 && ran2 == 0) dishu = 0;       
769.                 } break;
770.                 case 0xbd: {
771.                     if (ran1 == 2 && ran2 == 1) dishu = 0;                       
772.                 } break;
773.                 case 0xdd: {
774.                     if (ran1 == 2 && ran2 == 2) dishu = 0;
775.                 } break;
776.                 case 0xed: {
777.                     if (ran1 == 2 && ran2 == 3) dishu = 0;               
778.                 } break;
779.             }
780.             time_1ms(20);
781.         }
782.     }
783.     P0 = 0xfe;
784.     temp = P0;
785.     if (temp != 0xfe) {
786.         time_1ms(20);
787.         if (temp != 0xfe) {
788.             switch (temp) {
789.                 case 0x7e: {       
790.                     if (ran1 == 3 && ran2 == 0) dishu = 0;       
791.                 } break;
792.                 case 0xbe: {
793.                     if (ran1 == 3 && ran2 == 1) dishu = 0;       
794.                 } break;
795.                 case 0xde: {
796.                     if (ran1 == 3 && ran2 == 2) dishu = 0;         
797.                 } break;
798.                 case 0xee: {
799.                     if (ran1 == 3 && ran2 == 3) dishu = 0;       
800.                 } break;
801.             }
802.             time_1ms(20);
803.         }
804.     }       
805. }

复制代码

完备工程源码获取方式：毕设&课设&项目&实训-51单片机自制小霸王游戏机资源-CSDN文库

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。