基于STC15系列的3D立体数字滑块推盘游戏 软串口版

LscmunaixMG

1. 
   
2. /*
   
3. 基于STC15系列的3D立体数字滑块推盘游戏 软串口版
   
4. 以下源码用Keil4编译后直接烧写到STC单片机内即可运行，根据晶振频率修改串口位延时时间即可。
   
5. 使用XP自带的超级终端进行即可，其他系统可能需要下载安装包。
   
6. By:LscmunaixMG 2017-07-03
   
7. */
   
8. 
   
9. #include "reg51.h" //定义头文件reg51.h
   
10. #include "intrins.h" //定义头文件intrins.h
    
11. 
    
12. sbit rxd=P3^0; //数据接收口
    
13. sbit txd=P3^1; //数据发送口
    
14. 
    
15. //--------4层 推盘层数据--------
    
16. unsigned char l1[16]={ //推盘层1
    
17. 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
    
18. };
    
19. 
    
20. unsigned char l2[16]={ //推盘层2
    
21. 16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
    
22. };
    
23. 
    
24. unsigned char l3[16]={ //推盘层3
    
25. 32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47
    
26. };
    
27. 
    
28. unsigned char l4[16]={ //推盘层4
    
29. 48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63
    
30. };
    
31. 
    
32. /*
    
33. 通过获取0的坐标和被移动的坐标交换数值实现移动的功能以及判断数字是否能被移动。
    
34. 若没有任何不能正常移动数字的现象，严禁修改任何1字节否则会导致某些位置的数字跳格或者无法移动还会导致数组越界等严重后果。
    
35. 每4字节表示4个移动方向的与0的坐标与其他坐标进行交换实现移动。
    
36.         0的坐标从左上到右下排序：
    
37.         0 1 2 3
    
38.         4 5 6 7
    
39.         8 9 A B
    
40.         C D E F
    
41.         前4字节：0x04, 0x10, 0x01, 0x10
    
42.         比如数值0在坐标0的位置上，
    
43.                 上移将坐标4的值移入坐标0。
    
44.                 下移为0x10，不能被移动。
    
45.                 左移将坐标1的值移入坐标0。
    
46.                 右移同样为0x10，不能被移动。
    
47.                 移入的方法则是与数值0的坐标进行数值交换而实现移动。
    
48.         数值0在坐标1的位置上，则获取后面的4字节进行判断，以此类推。
    
49. 
    
50. */
    
51. unsigned char code xyd[64] = { //拼图板移动方向与0(空白)交换坐标数据，请勿修改否则数字会跳格或无法正常移动。
    
52.         0x04, 0x10, 0x01, 0x10, 0x05, 0x10, 0x02, 0x00, 0x06, 0x10, 0x03, 0x01, 0x07, 0x10, 0x10, 0x02,
    
53.         0x08, 0x00, 0x05, 0x10, 0x09, 0x01, 0x06, 0x04, 0x0A, 0x02, 0x07, 0x05, 0x0B, 0x03, 0x10, 0x06,
    
54.         0x0C, 0x04, 0x09, 0x10, 0x0D, 0x05, 0x0A, 0x08, 0x0E, 0x06, 0x0B, 0x09, 0x0F, 0x07, 0x10, 0x0A,
    
55.         0x10, 0x08, 0x0D, 0x10, 0x10, 0x09, 0x0E, 0x0C, 0x10, 0x0A, 0x0F, 0x0D, 0x10, 0x0B, 0x10, 0x0E
    
56. };
    
57. 
    
58. 
    
59. sfr AUXR   = 0x8E; //定义AUXR寄存器
    
60. sfr INT_CLKO = 0x8F; //定义下降沿中断寄存器
    
61. 
    
62. 
    
63. //------------------------软串口驱动程序------------------------
    
64.         /*
    
65.         void init_uart(){ //初始化串口 使用硬件下降沿中断必须初始化
    
66.                     AUXR |= 0x80;                      //设置AUXR寄存器
    
67.                     INT_CLKO |= 0x40;           //开串口中断 (允许串口接收数据)
    
68.                      EA = 1;                      //启用I/O口外部中断功能
    
69. 
    
70.         }
    
71.         */
    
72. 
    
73. void delay_uart(){ //延时时间1除以波特率秒 1/9600秒
    
74.     unsigned char a,b;
    
75.     for(b=114;b>0;b--)
    
76.         for(a=1;a>0;a--);
    
77. }
    
78.         void txd_data(unsigned char i){  //软串口发送数据
    
79.         unsigned char j=1;//控制移位
    
80.         unsigned char k=8;//控制循环次数
    
81.                 delay_uart();//延时时间
    
82.                 txd=0; //发送起始位，低电平
    
83.                 while(k--){ //下面循环8次
    
84.                 delay_uart();//延时时间
    
85.                 txd=(i&j)/j; //发送数据
    
86.                 j<<=1; //左移1位，发送下1位数据
    
87.                 }
    
88.                 delay_uart();//延时时间
    
89.                 txd=1;  //发送停止位
    
90.         }
    
91. 
    
92.         unsigned char rxd_data(){ //软串口接收数据
    
93.         unsigned char j=1;//控制移位
    
94.         unsigned char k=8;//控制循环次数
    
95.         unsigned char d=0;//存放数据
    
96.                 while(rxd == 1); //等待起始位低电平
    
97.                 while(k--){//下面循环8次
    
98.                 delay_uart(); //延时时间
    
99.                 d|=(rxd*j); //存入数据
    
100.                 j<<=1;  //左移1位，接收下1位数据
     
101.                 }
     
102.                 delay_uart();//延时时间
     
103.                 if(rxd == 1){ //停止位为高电平
     
104.                 return d; //返回数据
     
105.                 } else {
     
106.                 return 0; //无效数据 返回0
     
107.                 }
     
108.         }
     
109. 
     
110. void send_text(unsigned char *text){ //发送一段字符串
     
111.         for(;*text!=0;text++){  //遇到停止符0结束发送
     
112.                 txd_data(*text); //发送数据
     
113.         }
     
114. }
     
115. void send_enter(){ //发送换行(回车)
     
116.                 txd_data(0x0D);
     
117.                 txd_data(0x0A);
     
118.         }
     
119. 
     
120. //------------------------3D推盘驱动程序------------------------
     
121. 
     
122. //0的坐标:0~15 移动方向:1234 表示上下左右
     
123. unsigned char get_adj_coo(unsigned char zero_adj,unsigned char mov_dir){ //获取相邻坐标
     
124.         return xyd[zero_adj*4+mov_dir-1];
     
125. }
     
126. 
     
127. unsigned char get_0_lay(){ //获取0(空白)所在的层数 返回1~4
     
128. unsigned char add=0;
     
129.         for(add=0;add<16;add++){
     
130.                 if(l1[add] == 0){
     
131.                         return 1;
     
132.                         }
     
133. 
     
134.                 if(l2[add] == 0){
     
135.                         return 2;
     
136.                         }
     
137. 
     
138.                 if(l3[add] == 0){
     
139.                         return 3;
     
140.                         }
     
141. 
     
142.                 if(l4[add] == 0){
     
143.                         return 4;
     
144.                         }
     
145. 
     
146.         }
     
147.         return 0;
     
148. }
     
149. 
     
150. unsigned char get_0_pla(){ //获取0(空白)的平面坐标 返回0~15
     
151. unsigned char lay=0;
     
152. unsigned char add=0; //当前扫描的坐标
     
153.         lay=get_0_lay(); //获取0所在的层数
     
154.         for(add=0;add<16;add++){
     
155.                 if(lay == 1){
     
156.                         if(l1[add] == 0){
     
157.                         return add;
     
158.                         }
     
159.                 }
     
160. 
     
161.                 if(lay == 2){
     
162.                         if(l2[add] == 0){
     
163.                         return add;
     
164.                         }
     
165.                 }
     
166. 
     
167.                 if(lay == 3){
     
168.                         if(l3[add] == 0){
     
169.                         return add;
     
170.                         }
     
171.                 }
     
172. 
     
173.                 if(lay == 4){
     
174.                         if(l4[add] == 0){
     
175.                         return add;
     
176.                         }
     
177.                 }
     
178. 
     
179. 
     
180. 
     
181. 
     
182.         }
     
183. return 0;
     
184. }
     
185. //平面交换数字位置 层数:1~4 坐标A 坐标B
     
186. void pec(unsigned char s,unsigned char a,unsigned char b){
     
187. unsigned char ad=0; //坐标A数据
     
188. unsigned char bd=0; //坐标B数据
     
189.         if(a > 15 || b > 15) {
     
190.                 return;
     
191.                 }
     
192.                 if(s == 1){ad=l1[a];bd=l1[b];l1[a]=bd;l1[b]=ad;return;}
     
193.                 if(s == 2){ad=l2[a];bd=l2[b];l2[a]=bd;l2[b]=ad;return;}
     
194.                 if(s == 3){ad=l3[a];bd=l3[b];l3[a]=bd;l3[b]=ad;return;}
     
195.                 if(s == 4){ad=l4[a];bd=l4[b];l4[a]=bd;l4[b]=ad;return;}
     
196.         return;
     
197. }
     
198. void up_mov(){ //拼图上移
     
199. unsigned char lay0=0;
     
200. unsigned char pla0=0;
     
201. unsigned char adj=0;
     
202.         lay0=get_0_lay(); //获取0的坐标所在层数
     
203.         pla0=get_0_pla(); //获取0的平面坐标
     
204.         adj=get_adj_coo(pla0,1); //获取相邻坐标
     
205.         pec(lay0,pla0,adj); //平面交换数字位置
     
206. 
     
207. 
     
208. }
     
209. 
     
210. void down_mov(){ //拼图下移
     
211. unsigned char lay0=0;
     
212. unsigned char pla0=0;
     
213. unsigned char adj=0;
     
214.         lay0=get_0_lay(); //获取0的坐标所在层数
     
215.         pla0=get_0_pla(); //获取0的平面坐标
     
216.         adj=get_adj_coo(pla0,2); //获取相邻坐标
     
217.         pec(lay0,pla0,adj); //平面交换数字位置
     
218. 
     
219. 
     
220. }
     
221. 
     
222. void left_mov(){ //拼图左移
     
223. unsigned char lay0=0;
     
224. unsigned char pla0=0;
     
225. unsigned char adj=0;
     
226.         lay0=get_0_lay(); //获取0的坐标所在层数
     
227.         pla0=get_0_pla(); //获取0的平面坐标
     
228.         adj=get_adj_coo(pla0,3); //获取相邻坐标
     
229.         pec(lay0,pla0,adj); //平面交换数字位置
     
230. 
     
231. 
     
232. }
     
233. 
     
234. void right_mov(){ //拼图右移
     
235. unsigned char lay0=0;
     
236. unsigned char pla0=0;
     
237. unsigned char adj=0;
     
238.         lay0=get_0_lay(); //获取0的坐标所在层数
     
239.         pla0=get_0_pla(); //获取0的平面坐标
     
240.         adj=get_adj_coo(pla0,4); //获取相邻坐标
     
241.         pec(lay0,pla0,adj); //平面交换数字位置
     
242. 
     
243. 
     
244. }
     
245. 
     
246. void in_mov(){ //拼图里移
     
247. unsigned char lay0=0; //0的坐标所在层数
     
248. unsigned char pla0=0; //0的平面坐标
     
249. 
     
250. unsigned char add=0; //累加计数
     
251. 
     
252. 
     
253. 
     
254.         lay0=get_0_lay(); //获取0的坐标所在层数
     
255.         pla0=get_0_pla(); //获取0的平面坐标
     
256.                 if(lay0 < 4){
     
257.                         if(lay0 == 3){l3[pla0]=l4[pla0];l4[pla0]=0;}
     
258.                         if(lay0 == 2){l2[pla0]=l3[pla0];l3[pla0]=0;}
     
259.                         if(lay0 == 1){l1[pla0]=l2[pla0];l2[pla0]=0;}
     
260.                 }
     
261. 
     
262. }
     
263. 
     
264. void out_mov(){ //拼图外移
     
265. unsigned char lay0=0; //0的坐标所在层数
     
266. unsigned char pla0=0; //0的平面坐标
     
267. 
     
268. unsigned char add=0; //累加计数
     
269. 
     
270. 
     
271. 
     
272.         lay0=get_0_lay(); //获取0的坐标所在层数
     
273.         pla0=get_0_pla(); //获取0的平面坐标
     
274.                 if(lay0 > 1){
     
275.                         if(lay0 == 4){l4[pla0]=l3[pla0];l3[pla0]=0;}
     
276.                         if(lay0 == 3){l3[pla0]=l2[pla0];l2[pla0]=0;}
     
277.                         if(lay0 == 2){l2[pla0]=l1[pla0];l1[pla0]=0;}
     
278.                 }
     
279. 
     
280. }
     
281. 
     
282. 
     
283. void send_puzzle_l1(){       
     
284. unsigned char a=0;
     
285. 
     
286.        
     
287.         send_text("┏━┳━┳━┳━┓");send_enter(); //发送顶部表格框架
     
288.                 for(a=0;a<16;a++){ //变量a循环0~15
     
289.                 send_text("┃");
     
290.                 if(l1[a] == 0){ //读取到的数字为0则发送2个半角空格
     
291.                         txd_data(0x20);
     
292.                         txd_data(0x20);
     
293.                 } else { //不为0则发送数字
     
294.                         txd_data((l1[a]/10)|0x30);  //发送数字十位
     
295.                         txd_data((l1[a]%10)|0x30);  //发送数字个位
     
296.                 }
     
297.                
     
298.                                 if(a==3 || a==7 || a==11){ //读取到第3 7 11个数字 每列最后1个数字
     
299.                                 send_text("┃"); //发送分隔符
     
300.                                 send_enter();
     
301.                                 send_text("┣━╋━╋━╋━┫"); //发送中间表格框架
     
302.                                 send_enter();
     
303.                                 }
     
304.                 }
     
305.         send_text("┃");
     
306.         send_enter();
     
307.         send_text("┗━┻━┻━┻━┛"); //发送底部表格框架
     
308. 
     
309. 
     
310. }
     
311. void send_puzzle_l2(){       
     
312. unsigned char a=0;
     
313. 
     
314.        
     
315.         send_text("┏━┳━┳━┳━┓");send_enter(); //发送顶部表格框架
     
316.                 for(a=0;a<16;a++){
     
317.                 send_text("┃");
     
318.                 if(l2[a] == 0){ //读取到的数字为0则发送2个空格
     
319.                         txd_data(0x20);
     
320.                         txd_data(0x20);
     
321.                 } else { //不为0则发送数字
     
322.                         txd_data((l2[a]/10)|0x30);  //发送数字十位
     
323.                         txd_data((l2[a]%10)|0x30);  //发送数字个位
     
324.                 }
     
325.                
     
326.                                 if(a==3 || a==7 || a==11){ //读取到第3 7 11个数字
     
327.                                 send_text("┃"); //发送分隔符
     
328.                                 send_enter();
     
329.                                 send_text("┣━╋━╋━╋━┫"); //发送中间表格框架
     
330.                                 send_enter();
     
331.                                 }
     
332.                 }
     
333.         send_text("┃");
     
334.         send_enter();
     
335.         send_text("┗━┻━┻━┻━┛"); //发送底部表格框架
     
336. 
     
337. 
     
338. }
     
339. void send_puzzle_l3(){       
     
340. unsigned char a=0;
     
341. 
     
342.        
     
343.         send_text("┏━┳━┳━┳━┓");send_enter(); //发送顶部表格框架
     
344.                 for(a=0;a<16;a++){
     
345.                 send_text("┃");
     
346.                 if(l3[a] == 0){ //读取到的数字为0则发送2个空格
     
347.                         txd_data(0x20);
     
348.                         txd_data(0x20);
     
349.                 } else { //不为0则发送数字
     
350.                         txd_data((l3[a]/10)|0x30);  //发送数字十位
     
351.                         txd_data((l3[a]%10)|0x30);  //发送数字个位
     
352.                 }
     
353.                
     
354.                                 if(a==3 || a==7 || a==11){ //读取到第3 7 11个数字
     
355.                                 send_text("┃"); //发送分隔符
     
356.                                 send_enter();
     
357.                                 send_text("┣━╋━╋━╋━┫"); //发送中间表格框架
     
358.                                 send_enter();
     
359.                                 }
     
360.                 }
     
361.         send_text("┃");
     
362.         send_enter();
     
363.         send_text("┗━┻━┻━┻━┛"); //发送底部表格框架
     
364. 
     
365. 
     
366. }
     
367. void send_puzzle_l4(){       
     
368. unsigned char a=0;
     
369. 
     
370.        
     
371.         send_text("┏━┳━┳━┳━┓");send_enter(); //发送顶部表格框架
     
372.                 for(a=0;a<16;a++){
     
373.                 send_text("┃");
     
374.                 if(l4[a] == 0){ //读取到的数字为0则发送2个空格
     
375.                         txd_data(0x20);
     
376.                         txd_data(0x20);
     
377.                 } else { //不为0则发送数字
     
378.                         txd_data((l4[a]/10)|0x30);  //发送数字十位
     
379.                         txd_data((l4[a]%10)|0x30);  //发送数字个位
     
380.                 }
     
381.                
     
382.                                 if(a==3 || a==7 || a==11){ //读取到第3 7 11个数字
     
383.                                 send_text("┃"); //发送分隔符
     
384.                                 send_enter();
     
385.                                 send_text("┣━╋━╋━╋━┫"); //发送中间表格框架
     
386.                                 send_enter();
     
387.                                 }
     
388.                 }
     
389.         send_text("┃");
     
390.         send_enter();
     
391.         send_text("┗━┻━┻━┻━┛"); //发送底部表格框架
     
392. 
     
393. 
     
394. }
     
395. void send_3dpuzzle(){ //通过串口发送拼图数据
     
396. txd_data(0x0C); //发送 超级终端 清屏指令
     
397. send_text("基于STC15F104E的3D立体数字滑块推盘游戏 软串口版 WASD控制上下左右 Q里 E外");
     
398. send_enter();
     
399. send_text("第一层(最里层):");send_enter();
     
400. send_puzzle_l1();send_enter();send_enter();
     
401. send_text("第二层:");send_enter();
     
402. send_puzzle_l2();send_enter();send_enter();
     
403. send_text("第三层:");send_enter();
     
404. send_puzzle_l3();send_enter();send_enter();
     
405. send_text("第四层(最外层):");send_enter();
     
406. send_puzzle_l4();send_enter();send_enter();
     
407. 
     
408. }
     
409. 
     
410. void exint4() //interrupt 16{ //P3.0下降沿中断 (串口接收到数据)
     
411.         unsigned char dat=0;  //数据存放变量
     
412.         // INT_CLKO &= 0xBF;  //关闭中断，避免重复触发中断程序。
     
413.         dat=rxd_data();    //串口接收数据。
     
414.                 if(dat == 0x57 || dat == 0x77) up_mov(); //W 上
     
415.                 if(dat == 0x41 || dat == 0x61) left_mov(); //A 左
     
416.                 if(dat == 0x53 || dat == 0x73) down_mov(); //S 下
     
417.                 if(dat == 0x44 || dat == 0x64) right_mov(); //D 右
     
418.                 if(dat == 0x51 || dat == 0x71) in_mov(); //Q 里
     
419.                 if(dat == 0x45 || dat == 0x65) out_mov(); //E 外
     
420. 
     
421.                 send_3dpuzzle(); //通过串口发送拼图数据
     
422.         // INT_CLKO |= 0x40; //开启中断，允许下次接收数据。        
     
423. }
     
424. 
     
425. 
     
426. 
     
427. void main(){ //入口函数
     
428. 
     
429. 
     
430. 
     
431. //init_uart();
     
432. send_3dpuzzle(); //发送拼图数据
     
433.         while(1){ //进入死循环
     
434.                 if(rxd == 0){ //串口收到低电平
     
435.                         exint4(); //处理中断
     
436.                 }
     
437.         }
     
438. }
     
439. 
     
440. 
     
441. 
     
442. 
     

复制代码

QAQ

呵呵，这玩意还是头一次听说。。

66大顺

我也和楼上想的一样。