标题: Proteus综合实例（基于51）---推箱子游戏(LCD+按键) [打印本页]

---

作者: redstone555    时间: 2015-8-19 16:16
标题: Proteus综合实例（基于51）---推箱子游戏(LCD+按键)
推箱子游戏(LCD+按键)，详细仿真文件和代码，见附件。

捕获.JPG (198.87 KB, 下载次数: 103)

下载附件

2015-8-19 16:13 上传

Protues资料---综合实例（基于51）---推箱子游戏(LCD 按键).rar

2015-8-19 16:14 上传

点击文件名下载附件

下载积分: 黑币 -5

67.97 KB, 下载次数: 39, 下载积分: 黑币 -5

---

作者: ice^1    时间: 2015-8-26 21:36
好像很不错的样子，把楼主的源码贴出来

1. /*获取当前行，列*/
   
2. /*设置当前行，列*/
   
3. uchar g=0;
   
4. void delay(int c){
   
5.         int i, j;
   
6.         for(i = 0; i < c; i++)
   
7.                 for(j = 0; j < 1000; j++);
   
8. }
   
9. 
   
10. /*清屏 320 = (160/8) * (128/8) = 20 * 16 = 320*/
    
11. void cls(void){
    
12.         int i;
    
13.         set_xy(0,0);
    
14.         for(i = 0; i < 320; i++)
    
15.                 write_one(0x94,INC_WR);
    
16. }
    
17. 
    
18. 
    
19. uchar curx,cury;        /*纪录当前人物所在位置*/
    
20. 
    
21. uchar level_temp[8][8]={
    
22.         0,0,0,0,0,0,0,0,
    
23.         0,0,0,0,0,0,0,0,
    
24.         0,0,0,0,0,0,0,0,
    
25.         0,0,0,0,0,0,0,0,
    
26.         0,0,0,0,0,0,0,0,
    
27.         0,0,0,0,0,0,0,0,
    
28.         0,0,0,0,0,0,0,0,
    
29.         0,0,0,0,0,0,0,0,
    
30. };
    
31. 
    
32. 
    
33. void wirte_bg(void){
    
34.         int i;
    
35.         set_adr(0x50,0x01);
    
36.         for(i = 0; i < 2560; i++)
    
37.                 write_one(bg[i],INC_WR);
    
38. }
    
39. 
    
40. void wirte_cgrom(void){
    
41.         int i;
    
42. //        set_adr(0x50,0x01);
    
43. //        for(i = 0; i < 2560; i++)
    
44. //                write_one(0xff,INC_WR);
    
45.         set_adr(0x00,0x0c);
    
46.         /*自定义字符写入CGROM*/
    
47.         for(i = 0; i < 848; i++)
    
48.                 write_one(Lattice[i],INC_WR);
    
49. }
    
50. 
    
51. void start(void){
    
52.         uchar i;
    
53.         set_xy(0,0);
    
54.         for(i=0;i<20;i++)
    
55.                 write_one(0x95,INC_WR);
    
56.         set_xy(0,15);
    
57.         for(i=0;i<20;i++)
    
58.                 write_one(0x95,INC_WR);
    
59.         for(i=0;i<15;i++){
    
60.                 set_xy(0,i);
    
61.                 write_one(0x95,INC_WR);
    
62.                 set_xy(19,i);
    
63.                 write_one(0x95,INC_WR);
    
64.         }
    
65.         set_xy(18,1);
    
66.         write_one(0x96,INC_WR);
    
67.         set_xy(18,14);
    
68.         write_one(0x97,INC_WR);
    
69.         set_xy(1,1);
    
70.         write_one(0x98,INC_WR);
    
71.         set_xy(1,14);
    
72.         write_one(0x99,INC_WR);
    
73. 
    
74.         set_xy(7,6);
    
75.         write_one(0xaa,INC_WR);
    
76.         write_one(0xab,INC_WR);
    
77.         write_one(0xae,INC_WR);
    
78.         write_one(0xaf,INC_WR);
    
79.         write_one(0xb2,INC_WR);
    
80.         write_one(0xb3,INC_WR);
    
81.         set_xy(7,7);
    
82.         write_one(0xac,INC_WR);
    
83.         write_one(0xad,INC_WR);
    
84.         write_one(0xb0,INC_WR);
    
85.         write_one(0xb1,INC_WR);
    
86.         write_one(0xb4,INC_WR);
    
87.         write_one(0xb5,INC_WR);
    
88. 
    
89.         set_xy(6,8);
    
90.         write_one(0x9a,INC_WR);
    
91.         write_one(0x9b,INC_WR);
    
92.         write_one(0x9e,INC_WR);
    
93.         write_one(0x9f,INC_WR);
    
94.         write_one(0xa2,INC_WR);
    
95.         write_one(0xa3,INC_WR);
    
96.         write_one(0xa6,INC_WR);
    
97.         write_one(0xa7,INC_WR);
    
98.         set_xy(6,9);
    
99.         write_one(0x9c,INC_WR);
    
100.         write_one(0x9d,INC_WR);
     
101.         write_one(0xa0,INC_WR);
     
102.         write_one(0xa1,INC_WR);
     
103.         write_one(0xa4,INC_WR);
     
104.         write_one(0xa5,INC_WR);
     
105.         write_one(0xa8,INC_WR);
     
106.         write_one(0xa9,INC_WR);
     
107.         while(i){                        /*此while语句判断确定键超级技巧*/
     
108.                 switch(P1&0x1f){
     
109.                         case 0x0f:
     
110.                                 i=0;
     
111.                                 break;                               
     
112.                 }
     
113.         }
     
114. }
     
115. 
     
116. 
     
117. void guan(void){
     
118.         /*推*/       
     
119.         set_xy(16,0);
     
120.         write_one(0xaa,INC_WR);
     
121.         write_one(0xab,INC_WR);
     
122.         set_xy(16,1);
     
123.         write_one(0xac,INC_WR);
     
124.         write_one(0xad,INC_WR);
     
125.         /*箱*/
     
126.         set_xy(16,2);
     
127.         write_one(0xae,INC_WR);
     
128.         write_one(0xaf,INC_WR);
     
129.         set_xy(16,3);
     
130.         write_one(0xb0,INC_WR);
     
131.         write_one(0xb1,INC_WR);
     
132.         /*子*/
     
133.         set_xy(16,4);
     
134.         write_one(0xb2,INC_WR);
     
135.         write_one(0xb3,INC_WR);
     
136.         set_xy(16,5);
     
137.         write_one(0xb4,INC_WR);
     
138.         write_one(0xb5,INC_WR);       
     
139.         /*第*/
     
140.         set_xy(16,8);
     
141.         write_one(0xd2,INC_WR);
     
142.         write_one(0xd3,INC_WR);       
     
143.         set_xy(16,9);
     
144.         write_one(0xd4,INC_WR);
     
145.         write_one(0xd5,INC_WR);
     
146.         /*几*/       
     
147.         set_xy(16,10);
     
148.         write_one(0xd6,INC_WR);
     
149.         write_one(0xd6+2*(g+1),INC_WR);       
     
150.         set_xy(16,11);
     
151.         write_one(0xd7,INC_WR);
     
152.         write_one(0xd7+2*(g+1),INC_WR);
     
153.         /*关*/       
     
154.         set_xy(16,12);
     
155.         write_one(0xce,INC_WR);
     
156.         write_one(0xcf,INC_WR);       
     
157.         set_xy(16,13);
     
158.         write_one(0xd0,INC_WR);
     
159.         write_one(0xd1,INC_WR);
     
160.         /*阿*/
     
161.         set_xy(18,0);
     
162.         write_one(0x9a,INC_WR);
     
163.         write_one(0x9b,INC_WR);       
     
164.         set_xy(18,1);
     
165.         write_one(0x9c,INC_WR);
     
166.         write_one(0x9d,INC_WR);
     
167.         /*С*/       
     
168.         set_xy(18,2);
     
169.         write_one(0x9e,INC_WR);
     
170.         write_one(0x9f,INC_WR);       
     
171.         set_xy(18,3);
     
172.         write_one(0xa0,INC_WR);
     
173.         write_one(0xa1,INC_WR);
     
174.         /*制*/       
     
175.         set_xy(18,4);
     
176.         write_one(0xa2,INC_WR);
     
177.         write_one(0xa3,INC_WR);       
     
178.         set_xy(18,5);
     
179.         write_one(0xa4,INC_WR);
     
180.         write_one(0xa5,INC_WR);
     
181.         /*作*/       
     
182.         set_xy(18,6);
     
183.         write_one(0xa6,INC_WR);
     
184.         write_one(0xa7,INC_WR);       
     
185.         set_xy(18,7);
     
186.         write_one(0xa8,INC_WR);
     
187.         write_one(0xa9,INC_WR);
     
188. }
     
189. 
     
190. 
     
191. 
     
192. 
     
193. void printc(uchar i, uchar j, uchar c){
     
194.         set_xy(i*2,j*2);
     
195.         switch(c){       
     
196.                 case 0:
     
197.                            write_one(0x94,INC_WR);
     
198.                            write_one(0x94,INC_WR);
     
199.                            set_xy(i*2,j*2+1);
     
200.                            write_one(0x94,INC_WR);
     
201.                            write_one(0x94,INC_WR);
     
202.                            break;                                          
     
203.                 case 1:                /*人物1*/
     
204.                            write_one(0x80,INC_WR);
     
205.                            write_one(0x81,INC_WR);
     
206.                            set_xy(i*2,j*2+1);
     
207.                            write_one(0x82,INC_WR);
     
208.                            write_one(0x83,INC_WR);
     
209.                            break;
     
210.                 case 2:                /*砖头2*/
     
211.                            write_one(0x84,INC_WR);
     
212.                            write_one(0x85,INC_WR);
     
213.                            set_xy(i*2,j*2+1);
     
214.                            write_one(0x86,INC_WR);
     
215.                            write_one(0x87,INC_WR);
     
216.                            break;
     
217.                 case 3:                /*箱子3*/
     
218.                            write_one(0x88,INC_WR);
     
219.                            write_one(0x89,INC_WR);
     
220.                            set_xy(i*2,j*2+1);
     
221.                            write_one(0x8a,INC_WR);
     
222.                            write_one(0x8b,INC_WR);
     
223.                            break;
     
224.                 case 4:                /*目的4*/
     
225.                            write_one(0x8c,INC_WR);
     
226.                            write_one(0x8d,INC_WR);
     
227.                            set_xy(i*2,j*2+1);
     
228.                            write_one(0x8e,INC_WR);
     
229.                            write_one(0x8f,INC_WR);
     
230.                            break;
     
231.                 case 5:                /*成功5*/
     
232.                            write_one(0x90,INC_WR);
     
233.                            write_one(0x91,INC_WR);
     
234.                            set_xy(i*2,j*2+1);
     
235.                            write_one(0x92,INC_WR);
     
236.                            write_one(0x93,INC_WR);
     
237.                            break;
     
238.         }
     
239.        
     
240. }
     
241. 
     
242. 
     
243. 
     
244. void pushbox(){
     
245.         uchar i,j;
     
246.         /*根据level.h中的值进行输出单个字符点阵为16*16，显示8*8个字符*/
     
247.         for(i = 0; i < 8; i++)
     
248.                 for(j = 0; j < 8; j++){
     
249.                         level_temp[i][j]=level[g][j][i];
     
250.                         switch(level_temp[i][j]){       
     
251.                                 case 0:
     
252.                                            printc(i,j,0);
     
253.                                            break;                                          
     
254.                                 case 1:                /*人物1*/
     
255.                                            curx=i;
     
256.                                            cury=j;
     
257.                                            printc(i,j,1);
     
258.                                            break;
     
259.                                 case 2:                /*砖头2*/
     
260.                                            printc(i,j,2);
     
261.                                            break;
     
262.                                 case 3:                /*箱子3*/
     
263.                                            printc(i,j,3);
     
264.                                            break;
     
265.                                 case 4:                /*目的4*/
     
266.                                            printc(i,j,4);
     
267.                                            break;
     
268.                                 case 5:                /*成功5*/
     
269.                                            printc(i,j,5);
     
270.                                            break;
     
271.                         }
     
272.                 }
     
273.         set_xy(curx*2,cury*2);
     
274. }
     
275. 
     
276. void pass(){
     
277.         uchar i,j,k=1;
     
278.         for(i = 0; i < 8; i++){
     
279.                 if(k==0) break;
     
280.                 for(j = 0; j < 8; j++)
     
281.                         if(level[g][j][i]==4||level[g][j][i]==5)
     
282.                                 if(level_temp[i][j]==5)
     
283.                                         k=1;
     
284.                                 else{
     
285.                                         k=0;
     
286.                                         break;
     
287.                                 }
     
288.         }
     
289.         if(k==1){
     
290.                 if(g<8)g+=1;
     
291.                 else g=0;
     
292.                 pushbox();
     
293.                 guan();
     
294.         }
     
295. }
     
296. 
     
297. void keyboard(){
     
298.         switch(P1&0x1f){
     
299.                 case 0x1e:                /*上 cury > 0 && */
     
300.                                   if(level_temp[curx][cury-1]==0||level_temp[curx][cury-1]==4){
     
301. 
     
302.                                       if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
303.                                               level_temp[curx][cury]=4;
     
304.                                           printc(curx,cury,4);
     
305.                                           }
     
306.                                           else{
     
307.                                               level_temp[curx][cury]=0;
     
308.                                           printc(curx,cury,0);
     
309.                                           }
     
310. 
     
311.                                       cury=cury-1;
     
312.                                           level_temp[curx][cury]=1;
     
313.                                       printc(curx,cury,1);
     
314.                                   }
     
315. 
     
316.                                   else if(level_temp[curx][cury-1]==3){
     
317. 
     
318.                                       if(level_temp[curx][cury-2]==0){
     
319. 
     
320.                                           if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
321.                                                   level_temp[curx][cury]=4;
     
322.                                               printc(curx,cury,4);
     
323.                                               }
     
324.                                                   else{
     
325.                                                   level_temp[curx][cury]=0;
     
326.                                               printc(curx,cury,0);
     
327.                                               }
     
328. 
     
329.                                                   cury=cury-1;
     
330.                                                   level_temp[curx][cury]=1;
     
331.                                                   printc(curx,cury,1);
     
332.                                                   level_temp[curx][cury-1]=3;
     
333.                                                   printc(curx,cury-1,3);
     
334.                                           }
     
335. 
     
336.                                           else if(level_temp[curx][cury-2]==4){
     
337. 
     
338.                                           if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
339.                                                   level_temp[curx][cury]=4;
     
340.                                               printc(curx,cury,4);
     
341.                                               }
     
342.                                                   else{
     
343.                                                   level_temp[curx][cury]=0;
     
344.                                               printc(curx,cury,0);
     
345.                                               }
     
346. 
     
347.                                                   cury=cury-1;
     
348.                                                   level_temp[curx][cury]=1;
     
349.                                                   printc(curx,cury,1);
     
350.                                                   level_temp[curx][cury-1]=5;
     
351.                                                   printc(curx,cury-1,5);
     
352.                                                   pass();
     
353.                                           }
     
354. 
     
355.                                   }
     
356. 
     
357.                                   else if(level_temp[curx][cury-1]==5){
     
358. 
     
359.                                       if(level_temp[curx][cury-2]==0){
     
360. 
     
361.                                           if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
362.                                                   level_temp[curx][cury]=4;
     
363.                                               printc(curx,cury,4);
     
364.                                               }
     
365.                                                   else{
     
366.                                                   level_temp[curx][cury]=0;
     
367.                                               printc(curx,cury,0);
     
368.                                               }
     
369.                                                   cury=cury-1;
     
370.                                                   level_temp[curx][cury]=1;
     
371.                                                   printc(curx,cury,1);
     
372.                                                   level_temp[curx][cury-1]=3;
     
373.                                                   printc(curx,cury-1,3);
     
374.                                                      
     
375.                                           }
     
376.                                           else if(level_temp[curx][cury-2]==4){
     
377. 
     
378.                                               if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
379.                                                   level_temp[curx][cury]=4;
     
380.                                               printc(curx,cury,4);
     
381.                                               }
     
382.                                                   else{
     
383.                                                   level_temp[curx][cury]=0;
     
384.                                               printc(curx,cury,0);
     
385.                                               }
     
386.                                              
     
387.                                                   cury=cury-1;
     
388.                                                   level_temp[curx][cury]=1;
     
389.                                                   printc(curx,cury,1);
     
390.                                                   level_temp[curx][cury-1]=5;
     
391.                                                   printc(curx,cury-1,5);
     
392.                                                   pass();
     
393.                                           }
     
394.                                           pass();
     
395.                                   }
     
396.                                   while((P1&0x01)==0);
     
397.                                   break;
     
398.                 case 0x1d:           /*下 cury < 7 && */
     
399.                                   if(level_temp[curx][cury+1]==0||level_temp[curx][cury+1]==4){
     
400. 
     
401.                                       if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
402.                                               level_temp[curx][cury]=4;
     
403.                                           printc(curx,cury,4);
     
404.                                           }
     
405.                                           else{
     
406.                                               level_temp[curx][cury]=0;
     
407.                                           printc(curx,cury,0);
     
408.                                           }
     
409. 
     
410.                                       cury=cury+1;
     
411.                                           level_temp[curx][cury]=1;
     
412.                                       printc(curx,cury,1);
     
413.                                   }
     
414. 
     
415.                                   else if(level_temp[curx][cury+1]==3){
     
416. 
     
417.                                       if(level_temp[curx][cury+2]==0){
     
418. 
     
419.                                           if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
420.                                                   level_temp[curx][cury]=4;
     
421.                                               printc(curx,cury,4);
     
422.                                               }
     
423.                                                   else{
     
424.                                                   level_temp[curx][cury]=0;
     
425.                                               printc(curx,cury,0);
     
426.                                               }
     
427. 
     
428.                                                   cury=cury+1;
     
429.                                                   level_temp[curx][cury]=1;
     
430.                                                   printc(curx,cury,1);
     
431.                                                   level_temp[curx][cury+1]=3;
     
432.                                                   printc(curx,cury+1,3);
     
433.                                           }
     
434. 
     
435.                                           else if(level_temp[curx][cury+2]==4){
     
436. 
     
437.                                           if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
438.                                                   level_temp[curx][cury]=4;
     
439.                                               printc(curx,cury,4);
     
440.                                               }
     
441.                                                   else{
     
442.                                                   level_temp[curx][cury]=0;
     
443.                                               printc(curx,cury,0);
     
444.                                               }
     
445. 
     
446.                                                   cury=cury+1;
     
447.                                                   level_temp[curx][cury]=1;
     
448.                                                   printc(curx,cury,1);
     
449.                                                   level_temp[curx][cury+1]=5;
     
450.                                                   printc(curx,cury+1,5);
     
451.                                                   pass();
     
452.                                           }
     
453. 
     
454.                                   }
     
455. 
     
456.                                   else if(level_temp[curx][cury+1]==5){
     
457. 
     
458.                                       if(level_temp[curx][cury+2]==0){
     
459. 
     
460.                                           if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
461.                                                   level_temp[curx][cury]=4;
     
462.                                               printc(curx,cury,4);
     
463.                                               }
     
464.                                                   else{
     
465.                                                   level_temp[curx][cury]=0;
     
466.                                               printc(curx,cury,0);
     
467.                                               }
     
468.                                                   cury=cury+1;
     
469.                                                   level_temp[curx][cury]=1;
     
470.                                                   printc(curx,cury,1);
     
471.                                                   level_temp[curx][cury+1]=3;
     
472.                                                   printc(curx,cury+1,3);
     
473.                                                      
     
474.                                           }
     
475.                                           else if(level_temp[curx][cury+2]==4){
     
476. 
     
477.                                               if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
478.                                                   level_temp[curx][cury]=4;
     
479.                                               printc(curx,cury,4);
     
480.                                               }
     
481.                                                   else{
     
482.                                                   level_temp[curx][cury]=0;
     
483.                                               printc(curx,cury,0);
     
484.                                               }
     
485.                                              
     
486.                                                   cury=cury+1;
     
487.                                                   level_temp[curx][cury]=1;
     
488.                                                   printc(curx,cury,1);
     
489.                                                   level_temp[curx][cury+1]=5;
     
490.                                                   printc(curx,cury+1,5);
     
491.                                                   pass();
     
492.                                           }
     
493.                                           pass();
     
494.                                   }
     
495.                                   while((P1&0x02)==0);
     
496.                                   break;
     
497.                 case 0x1b:           /*左 curx > 0 && */
     
498.                                   if(level_temp[curx-1][cury]==0||level_temp[curx-1][cury]==4){
     
499. 
     
500.                                       if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
501.                                               level_temp[curx][cury]=4;
     
502.                                           printc(curx,cury,4);
     
503.                                           }
     
504.                                           else{
     
505.                                               level_temp[curx][cury]=0;
     
506.                                           printc(curx,cury,0);
     
507.                                           }
     
508. 
     
509.                                       curx=curx-1;
     
510.                                           level_temp[curx][cury]=1;
     
511.                                       printc(curx,cury,1);
     
512.                                   }
     
513. 
     
514.                                   else if(level_temp[curx-1][cury]==3){
     
515. 
     
516.                                       if(level_temp[curx-2][cury]==0){
     
517. 
     
518.                                           if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
519.                                                   level_temp[curx][cury]=4;
     
520.                                               printc(curx,cury,4);
     
521.                                               }
     
522.                                                   else{
     
523.                                                   level_temp[curx][cury]=0;
     
524.                                               printc(curx,cury,0);
     
525.                                               }
     
526. 
     
527.                                                   curx=curx-1;
     
528.                                                   level_temp[curx][cury]=1;
     
529.                                                   printc(curx,cury,1);
     
530.                                                   level_temp[curx-1][cury]=3;
     
531.                                                   printc(curx-1,cury,3);
     
532.                                           }
     
533. 
     
534.                                           else if(level_temp[curx-2][cury]==4){
     
535. 
     
536.                                           if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
537.                                                   level_temp[curx][cury]=4;
     
538.                                               printc(curx,cury,4);
     
539.                                               }
     
540.                                                   else{
     
541.                                                   level_temp[curx][cury]=0;
     
542.                                               printc(curx,cury,0);
     
543.                                               }
     
544. 
     
545.                                                   curx=curx-1;
     
546.                                                   level_temp[curx][cury]=1;
     
547.                                                   printc(curx,cury,1);
     
548.                                                   level_temp[curx-1][cury]=5;
     
549.                                                   printc(curx-1,cury,5);
     
550.                                                   pass();
     
551.                                           }
     
552. 
     
553.                                   }
     
554. 
     
555.                                   else if(level_temp[curx-1][cury]==5){
     
556. 
     
557.                                       if(level_temp[curx-2][cury]==0){
     
558. 
     
559.                                           if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
560.                                                   level_temp[curx][cury]=4;
     
561.                                               printc(curx,cury,4);
     
562.                                               }
     
563.                                                   else{
     
564.                                                   level_temp[curx][cury]=0;
     
565.                                               printc(curx,cury,0);
     
566.                                               }
     
567.                                                   curx=curx-1;
     
568.                                                   level_temp[curx][cury]=1;
     
569.                                                   printc(curx,cury,1);
     
570.                                                   level_temp[curx-1][cury]=3;
     
571.                                                   printc(curx-1,cury,3);
     
572.                                                      
     
573.                                           }
     
574.                                           else if(level_temp[curx-2][cury]==4){
     
575. 
     
576.                                               if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
577.                                                   level_temp[curx][cury]=4;
     
578.                                               printc(curx,cury,4);
     
579.                                               }
     
580.                                                   else{
     
581.                                                   level_temp[curx][cury]=0;
     
582.                                               printc(curx,cury,0);
     
583.                                               }
     
584.                                              
     
585.                                                   curx=curx-1;
     
586.                                                   level_temp[curx][cury]=1;
     
587.                                                   printc(curx,cury,1);
     
588.                                                   level_temp[curx-1][cury]=5;
     
589.                                                   printc(curx-1,cury,5);
     
590.                                                   pass();
     
591.                                           }
     
592.                                           pass();
     
593.                                   }
     
594.                                   while((P1&0x04)==0);
     
595.                                   break;
     
596.                 case 0x17:           /*右 curx < 9 && */
     
597.                                   if(level_temp[curx+1][cury]==0||level_temp[curx+1][cury]==4){
     
598. 
     
599.                                       if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
600.                                               level_temp[curx][cury]=4;
     
601.                                           printc(curx,cury,4);
     
602.                                           }
     
603.                                           else{
     
604.                                               level_temp[curx][cury]=0;
     
605.                                           printc(curx,cury,0);
     
606.                                           }
     
607. 
     
608.                                       curx=curx+1;
     
609.                                           level_temp[curx][cury]=1;
     
610.                                       printc(curx,cury,1);
     
611.                                   }
     
612. 
     
613.                                   else if(level_temp[curx+1][cury]==3){
     
614. 
     
615.                                       if(level_temp[curx+2][cury]==0){
     
616. 
     
617.                                           if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
618.                                                   level_temp[curx][cury]=4;
     
619.                                               printc(curx,cury,4);
     
620.                                               }
     
621.                                                   else{
     
622.                                                   level_temp[curx][cury]=0;
     
623.                                               printc(curx,cury,0);
     
624.                                               }
     
625. 
     
626.                                                   curx=curx+1;
     
627.                                                   level_temp[curx][cury]=1;
     
628.                                                   printc(curx,cury,1);
     
629.                                                   level_temp[curx+1][cury]=3;
     
630.                                                   printc(curx+1,cury,3);
     
631.                                           }
     
632. 
     
633.                                           else if(level_temp[curx+2][cury]==4){
     
634. 
     
635.                                           if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
636.                                                   level_temp[curx][cury]=4;
     
637.                                               printc(curx,cury,4);
     
638.                                               }
     
639.                                                   else{
     
640.                                                   level_temp[curx][cury]=0;
     
641.                                               printc(curx,cury,0);
     
642.                                               }
     
643. 
     
644.                                                   curx=curx+1;
     
645.                                                   level_temp[curx][cury]=1;
     
646.                                                   printc(curx,cury,1);
     
647.                                                   level_temp[curx+1][cury]=5;
     
648.                                                   printc(curx+1,cury,5);
     
649.                                                   pass();
     
650.                                           }
     
651. 
     
652.                                   }
     
653. 
     
654.                                   else if(level_temp[curx+1][cury]==5){
     
655. 
     
656.                                       if(level_temp[curx+2][cury]==0){
     
657. 
     
658.                                           if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
659.                                                   level_temp[curx][cury]=4;
     
660.                                               printc(curx,cury,4);
     
661.                                               }
     
662.                                                   else{
     
663.                                                   level_temp[curx][cury]=0;
     
664.                                               printc(curx,cury,0);
     
665.                                               }
     
666.                                                   curx=curx+1;
     
667.                                                   level_temp[curx][cury]=1;
     
668.                                                   printc(curx,cury,1);
     
669.                                                   level_temp[curx+1][cury]=3;
     
670.                                                   printc(curx+1,cury,3);
     
671.                                                      
     
672.                                           }
     
673.                                           else if(level_temp[curx+2][cury]==4){
     
674. 
     
675.                                               if(level[g][cury][curx]==4||level[g][cury][curx]==5){
     
676.                                                   level_temp[curx][cury]=4;
     
677.                                               printc(curx,cury,4);
     
678.                                               }
     
679.                                                   else{
     
680.                                                   level_temp[curx][cury]=0;
     
681.                                               printc(curx,cury,0);
     
682.                                               }
     
683.                                              
     
684.                                                   curx=curx+1;
     
685.                                                   level_temp[curx][cury]=1;
     
686.                                                   printc(curx,cury,1);
     
687.                                                   level_temp[curx+1][cury]=5;
     
688.                                                   printc(curx+1,cury,5);
     
689.                                                   pass();
     
690.                                           }
     
691.                                           pass();
     
692.                                   }
     
693.                                   while((P1&0x08)==0);
     
694.                                   break;
     
695.             case 0x0f:           /*确定*/
     
696.                                   break;
     
697.         }
     
698. }

复制代码

---

作者: ice^1    时间: 2015-8-26 21:36
下载！~~~

---

作者: 用户2111157    时间: 2015-8-27 07:34
哇塞，学习啦

---

作者: lth0320    时间: 2015-8-27 10:41
绝对要顶！能编出游戏的都是大神！

---

作者: menwawork    时间: 2015-9-23 19:39
感谢楼主,下来研究一下..

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1