欧美极品高清xxxxhd,国产日产欧美最新,无码AV国产东京热AV无码,国产精品人与动性XXX,国产传媒亚洲综合一区二区,四库影院永久国产精品,毛片免费免费高清视频,福利所导航夜趣136

標(biāo)題: 51單片機(jī)+Proteus仿真的俄羅斯方塊游戲程序設(shè)計(jì) [打印本頁(yè)]

---

作者: futao    時(shí)間: 2019-5-9 17:09
標(biāo)題: 51單片機(jī)+Proteus仿真的俄羅斯方塊游戲程序設(shè)計(jì)
俄羅斯方塊仿真原理圖如下（proteus仿真工程文件可到本帖附件中下載）


單片機(jī)俄羅斯方塊源程序如下:

1. #include <AT89X51.H>
   
2. 
   
3. #define DOWNTIME 30
   
4. #define MAXHANG 20
   
5. #define MAXLIE  16
   
6. #define MAXPIX  3
   
7. #define PUSHON  50
   
8. 
   
9. #define LCD P2
   
10. #define EN  P3_0
    
11. #define RW  P3_1
    
12. #define RS  P3_2
    
13. #define CS1 P3_3
    
14. #define CS2 P3_4
    
15. 
    
16. #define KEYLEFT P1_0
    
17. #define KEYDOWN P1_7
    
18. #define KEYRIGH P1_6
    
19. #define KEYROTATION P1_1
    
20. 
    
21. unsigned char gkey=0xff,keystate=0,t0ms1=0,t0ms=0,downtimegap=0;
    
22. unsigned char miao=0,fen=0;
    
23. unsigned char downok;
    
24. bit keyflag,timeupdate,fashionupdate;
    
25. unsigned char idata cubeMap[MAXHANG][2];
    
26. typedef struct{
    
27.                unsigned char code * box;
    
28.                             unsigned char cube : 4;
    
29.                            unsigned char state : 4;
    
30.                            char row;
    
31.                            char column;
    
32.                            } block;
    
33. block this;
    
34. unsigned int score=0;
    
35. unsigned char speed=1;
    
36. unsigned char code bittable[8]={1,2,4,8,0x10,0x20,0x40,0x80};
    
37. unsigned char code cube[]=
    
38. {
    
39. /*  ■
    
40.   ■■■
    
41. */
    
42. 0,4,0xe,0,  0,2,6,2,     0,7,2,0,     4,6,4,0,
    
43. 
    
44. /*■
    
45.   ■■■
    
46. */
    
47. 0,8,0xe,0,  0,4,4,0xc,   0,0,0xe,2,   0,6,4,4,
    
48. /*■■■
    
49.   ■   
    
50. */
    
51. 0,0xe,8,0,  0,4,4,6,     0,1,7,0,     6,2,2,0,
    
52. /*■■
    
53.     ■■
    
54. */
    
55. 0,0xc,6,0,  0,2,6,4,     0,6,3,0,     2,6,4,0,
    
56. /*  ■■
    
57.   ■■  
    
58. */
    
59. 0,6,0xc,0,  0,4,6,2,     0,3,6,0,     4,6,2,0,
    
60. /*■■■■
    
61. */
    
62. 0,0xf,0,0,  4,4,4,4,     0,0,0xf,0,   2,2,2,2,
    
63. /*■■
    
64.   ■■
    
65. */
    
66. 0,6,6,0,    0,6,6,0,     0,6,6,0,     0,6,6,0
    
67. };
    
68. unsigned char code asii[]=
    
69. {
    
70.     0x3E,0x51,0x49,0x45,0x3E, // -0-
    
71.     0x00,0x42,0x7F,0x40,0x00, // -1-
    
72.     0x62,0x51,0x49,0x49,0x46, // -2-
    
73.     0x21,0x41,0x49,0x4D,0x33, // -3-
    
74.     0x18,0x14,0x12,0x7F,0x10, // -4-
    
75.     0x27,0x45,0x45,0x45,0x39, // -5-
    
76.     0x3C,0x4A,0x49,0x49,0x31, // -6-
    
77.     0x01,0x71,0x09,0x05,0x03, // -7-
    
78.     0x36,0x49,0x49,0x49,0x36, // -8-
    
79.     0x46,0x49,0x49,0x29,0x1E, // -9-
    
80.     0x00,0x36,0x36,0x00,0x00, // -:-10
    
81. //next
    
82.     0x7F,0x04,0x08,0x10,0x7F, // -N-11
    
83.     0x7F,0x49,0x49,0x49,0x41, // -E-12
    
84.     0x63,0x14,0x08,0x14,0x63, // -X-13
    
85.     0x01,0x01,0x7F,0x01,0x01, // -T-14
    
86. //speed
    
87.     0x26,0x49,0x49,0x49,0x32, // -S-15
    
88.     0x7F,0x09,0x09,0x09,0x06, // -P-16
    
89.     0x7F,0x49,0x49,0x49,0x41, // -E-17
    
90.     0x7F,0x41,0x41,0x41,0x3E, // -D-18
    
91. //score
    
92.     0x3E,0x41,0x41,0x41,0x22, // -C-19   
    
93.     0x3E,0x41,0x41,0x41,0x3E, // -O-20
    
94.     0x7F,0x09,0x19,0x29,0x46, // -R-21
    
95.     0x00,0x00,0x00,0x00,0x00,  // - -22
    
96. //GAME OVER
    
97.     0x3E,0x41,0x51,0x51,0x72, // -G-23
    
98.     0x7C,0x12,0x11,0x12,0x7C, // -A-24
    
99.     0x7F,0x02,0x0C,0x02,0x7F, // -M-25
    
100.     0x1F,0x20,0x40,0x20,0x1F, // -V-26
     
101. //TIME
     
102. //  0x00,0x41,0x7F,0x41,0x00  // -I-27
     
103. };
     
104. ////////////////////////////////////////////////////////////////////////////////
     
105. void lcdCmd(unsigned char cmd)
     
106. {
     
107. bit ea;
     
108. ea=EA;
     
109. EA=0;
     
110. EN=0;
     
111. RW=0;
     
112. RS=0;
     
113. LCD=cmd;
     
114. EN=1;
     
115. EN=1;
     
116. EN=0;
     
117. EA=ea;
     
118. }
     
119. //-------------------------------------------------------------------------------
     
120. void lcdWriteByte(unsigned char ch)
     
121. {
     
122. EN=0;
     
123. RS=1;
     
124. RW=0;
     
125. LCD=ch;
     
126. EN=1;
     
127. EN=1;
     
128. EN=0;
     
129. }
     
130. //--------------------------------------------------------------------------------
     
131. void lcdSetPage(unsigned char page)
     
132. {
     
133.   page &=0x7;
     
134.   page +=0xb8;
     
135.   lcdCmd(page);
     
136. }
     
137. //--------------------------------------------------------------------------------
     
138. void lcdSetColumn(unsigned char column)
     
139. {
     
140.   column &=0x3f;
     
141.   column +=0x40;
     
142.   lcdCmd(column);
     
143. }
     
144. //--------------------------------------------------------------------------------
     
145. //character fron=5*8
     
146. void lcdPlayChar(unsigned char index,unsigned char page,unsigned char colume)
     
147. {
     
148. unsigned char i,temp;
     
149. unsigned int p;
     
150. p=5*index;
     
151. for(i=colume;i<colume+5;i++)
     
152.   {
     
153.     if(i<64)
     
154.          {
     
155.           CS1=1;
     
156.           CS2=0;
     
157.           temp=i;
     
158.          }
     
159.         else
     
160.          {
     
161.           CS1=0;
     
162.           CS2=1;
     
163.           temp=i-64;
     
164.          }
     
165.         lcdSetPage(page);
     
166.         lcdSetColumn(temp);
     
167.         lcdWriteByte(asii[p++]);
     
168.   }
     
169. }
     
170. //---------------------------------------------------------------------------------
     
171. //rectangle(3,0,50,60)
     
172. void rectangle(void)
     
173. {
     
174.   unsigned char i,page;
     
175.   CS1=1;
     
176.   CS2=0;
     
177.   lcdSetPage(0);  
     
178.   lcdSetColumn(2);
     
179.   EN=0;
     
180.   RS=1;
     
181.   RW=0;
     
182.   LCD=0xff;
     
183.   EN=1;
     
184.   EN=1;
     
185.   EN=0;
     
186.   for(i=3;i<51;i++)
     
187.    {
     
188.      EN=0;
     
189.      RS=1;
     
190.      RW=0;
     
191.      LCD=0x1;
     
192.      EN=1;
     
193.      EN=1;
     
194.      EN=0;   
     
195.    }
     
196.   EN=0;
     
197.   RS=1;
     
198.   RW=0;
     
199.   LCD=0xff;
     
200.   EN=1;
     
201.   EN=1;
     
202.   EN=0;
     
203. //---------------------------
     
204. for(page=1;page<7;page++)
     
205. {
     
206.   lcdSetPage(page);  
     
207.   lcdSetColumn(2);
     
208.   EN=0;
     
209.   RS=1;
     
210.   RW=0;
     
211.   LCD=0xff;
     
212.   EN=1;
     
213.   EN=1;
     
214.   EN=0;
     
215.   for(i=3;i<51;i++)
     
216.    {
     
217.      EN=0;
     
218.      RS=1;
     
219.      RW=0;
     
220.      LCD=0x0;
     
221.      EN=1;
     
222.      EN=1;
     
223.      EN=0;   
     
224.    }
     
225.   EN=0;
     
226.   RS=1;
     
227.   RW=0;
     
228.   LCD=0xff;
     
229.   EN=1;
     
230.   EN=1;
     
231.   EN=0;
     
232. }
     
233. //---------------------------
     
234.   lcdSetPage(7);  
     
235.   lcdSetColumn(2);
     
236.   EN=0;
     
237.   RS=1;
     
238.   RW=0;
     
239.   LCD=0x1f;
     
240.   EN=1;
     
241.   EN=1;
     
242.   EN=0;
     
243.   for(i=3;i<51;i++)
     
244.    {
     
245.      EN=0;
     
246.      RS=1;
     
247.      RW=0;
     
248.      LCD=0x10;
     
249.      EN=1;
     
250.      EN=1;
     
251.      EN=0;   
     
252.    }
     
253.   EN=0;
     
254.   RS=1;
     
255.   RW=0;
     
256.   LCD=0x1f;
     
257.   EN=1;
     
258.   EN=1;
     
259.   EN=0;
     
260. }
     
261. //--------------------------------------------------------------------
     
262. //x:列；y行，頁(yè) 3*3
     
263. void lcdPutPix(unsigned char x, unsigned char y,unsigned char flag)
     
264. {
     
265.   unsigned char i,dat,bitmask,nextbit;
     
266.   bit bflag,pflag,ea;
     
267.   x=x*MAXPIX;
     
268.   y=y*MAXPIX;
     
269.   bflag=0;
     
270.   pflag=0;
     
271.   i=y%8;
     
272.   if(i==0)
     
273.    bitmask=0x7;
     
274.   else if(i==1)
     
275.    bitmask=0xe;
     
276.   else if(i==2)
     
277.    bitmask=0x1c;
     
278.   else if(i==3)
     
279.    bitmask=0x38;
     
280.   else if(i==4)
     
281.    bitmask=0x70;
     
282.   else if(i==5)
     
283.    bitmask=0xe0;
     
284.   else if(i==6)
     
285.    {
     
286.     bflag=1;
     
287.     bitmask=0xc0;
     
288.     nextbit=1;
     
289.    }
     
290.   else if(i==7)
     
291.    {
     
292.     bflag=1;
     
293.     bitmask=0x80;
     
294.     nextbit=3;
     
295.    }
     
296.   if(x<62)
     
297.    {
     
298.     CS1=1;
     
299.     CS2=0;
     
300.    }
     
301.   else if(x>63)
     
302.    {
     
303.     x-=64;
     
304.     CS1=0;
     
305.     CS2=1;
     
306.    }
     
307.   else
     
308.    pflag=1;
     
309.   lcdSetPage(y/8);
     
310.   for(i=x;i<x+MAXPIX;i++)
     
311.    {
     
312.     if(pflag)
     
313.      {
     
314.       if(i==62 || i==63)
     
315.        {
     
316.          CS1=1;
     
317.          CS2=0;
     
318.          lcdSetPage(y/8);
     
319.         }
     
320.       else if(pflag && i==64)
     
321.        {
     
322.         CS1=0;
     
323.         CS2=1;
     
324.         lcdSetPage(y/8);
     
325.        }
     
326.       }
     
327.      lcdSetColumn(i);
     
328.      ea=EA;
     
329.      EA=0;
     
330.      EN=0;
     
331.      LCD=0xff;
     
332.      RS=1;
     
333.      RW=1;
     
334.      EN=1;
     
335.      EN=0;
     
336. 
     
337.      EN=1;
     
338.      dat=LCD;
     
339.      EN=0;
     
340.      if(flag==1)
     
341.        dat|=bitmask;
     
342.      else
     
343.        dat&=~bitmask;
     
344.      lcdSetColumn(i);  
     
345. 
     
346.      EN=0;
     
347.      RW=0;
     
348.      RS=1;
     
349.      LCD=dat;
     
350.      EN=1;
     
351.      EN=1;
     
352.      EN=0;
     
353.      EA=ea;
     
354.    }
     
355. if(bflag)
     
356.   {
     
357.    lcdSetPage(y/8+1);
     
358.    for(i=x;i<x+MAXPIX;i++)
     
359.    {
     
360.     if(pflag)
     
361.      {
     
362.       if(i==62 || i==63)
     
363.        {
     
364.         CS1=1;
     
365.         CS2=0;
     
366.         lcdSetPage(y/8+1);
     
367.        }
     
368.       else if(pflag && i==64)
     
369.        {
     
370.         CS1=0;
     
371.         CS2=1;
     
372.         lcdSetPage(y/8+1);
     
373.        }
     
374.       }
     
375.      lcdSetColumn(i);
     
376.      ea=EA;
     
377.      EA=0;
     
378.      EN=0;
     
379.      LCD=0xff;
     
380.      RS=1;
     
381.      RW=1;
     
382.      EN=1;
     
383.      EN=0;
     
384. 
     
385.      EN=1;
     
386.      dat=LCD;
     
387.      EN=0;
     
388.      if(flag==1)
     
389.        dat|=nextbit;
     
390.      else
     
391.        dat&=~nextbit;
     
392.      lcdSetColumn(i);  
     
393. 
     
394.      EN=0;
     
395.      RW=0;
     
396.      RS=1;
     
397.      LCD=dat;
     
398.      EN=1;
     
399.      EN=1;
     
400.      EN=0;
     
401.      EA=ea;  
     
402.   }
     
403. }
     
404. }
     
405. //------------------------------------------------------------------
     
406. void lcdClear(void)
     
407. {
     
408.   unsigned char i,page;
     
409.   CS1=1;
     
410.   CS2=0;
     
411.   for(page=0;page<8;page++)
     
412.    {
     
413.     lcdSetPage(page);
     
414.     lcdSetColumn(0);
     
415.     for(i=0;i<64;i++)
     
416.            lcdWriteByte(0);
     
417.    }
     
418.   CS1=0;
     
419.   CS2=1;
     
420.   for(page=0;page<8;page++)
     
421.    {
     
422.     lcdSetPage(page);
     
423.     lcdSetColumn(0);
     
424.     for(i=0;i<64;i++)
     
425.            lcdWriteByte(0);
     
426.    }
     
427. }
     
428. //-----------------------------------------------------------------
     
429. #define STAR 53
     
430. #define WIDE 6
     
431. void lcdIni(void)
     
432. {
     
433. lcdCmd(0x3f);
     
434. lcdCmd(0xc0);
     
435. lcdClear();
     
436. rectangle();
     
437. //NEXT
     
438. lcdPlayChar(11,0,STAR);
     
439. lcdPlayChar(12,0,STAR+1*WIDE);
     
440. lcdPlayChar(13,0,STAR+2*WIDE);
     
441. lcdPlayChar(14,0,STAR+3*WIDE);
     
442. //SPEED
     
443. lcdPlayChar(15,3,STAR);
     
444. lcdPlayChar(16,3,STAR+1*WIDE);
     
445. lcdPlayChar(17,3,STAR+2*WIDE);
     
446. lcdPlayChar(17,3,STAR+3*WIDE);
     
447. lcdPlayChar(18,3,STAR+4*WIDE);
     
448. //01
     
449. lcdPlayChar(0,4,STAR+2*WIDE);
     
450. lcdPlayChar(1,4,STAR+3*WIDE);
     
451. 
     
452. //SCORE
     
453. lcdPlayChar(15,5,STAR);
     
454. lcdPlayChar(19,5,STAR+1*WIDE);
     
455. lcdPlayChar(20,5,STAR+2*WIDE);
     
456. lcdPlayChar(21,5,STAR+3*WIDE);
     
457. lcdPlayChar(12,5,STAR+4*WIDE);
     
458. 
     
459. lcdPlayChar(0,6,STAR+1*WIDE);
     
460. lcdPlayChar(0,6,STAR+2*WIDE);
     
461. lcdPlayChar(0,6,STAR+3*WIDE);
     
462. lcdPlayChar(0,6,STAR+4*WIDE);
     
463. //TIME
     
464. lcdPlayChar(0,7,STAR);
     
465. lcdPlayChar(0,7,STAR+1*WIDE);
     
466. lcdPlayChar(10,7,STAR+2*WIDE);
     
467. lcdPlayChar(0,7,STAR+3*WIDE);
     
468. lcdPlayChar(0,7,STAR+4*WIDE);
     
469. }
     
470. //-----------------------------------------------------------------
     
471. void showScoreSpeed(void)
     
472. {
     
473.   unsigned char num[5];
     
474.   char i;
     
475.   unsigned int temp;
     
476.   temp=score;
     
477.   for(i=0;i<5;i++)
     
478.    {
     
479.      num[i]=temp%10;
     
480.          temp=temp/10;
     
481.    }
     
482.   for(i=4;i>0;i--)
     
483.    {
     
484.      if(num[i]==0)
     
485.           num[i]=22;
     
486.          else
     
487.           break;
     
488.    }
     
489.   for(i=4;i>-1;i--)
     
490.    lcdPlayChar(num[i],6,STAR+(4-i)*WIDE);
     
491. 
     
492. lcdPlayChar(speed/10,4,STAR+2*WIDE);
     
493. lcdPlayChar(speed%10,4,STAR+3*WIDE);
     
494. }
     
495. //-------------------------------------------------------------------
     
496. void timeServer(void)
     
497. {
     
498.   if(timeupdate)
     
499.    {
     
500.     timeupdate=0;
     
501.     lcdPlayChar(fen/10,7,STAR);
     
502.     lcdPlayChar(fen%10,7,STAR+1*WIDE);
     
503.     lcdPlayChar(10,7,STAR+2*WIDE);
     
504.     lcdPlayChar(miao/10,7,STAR+3*WIDE);
     
505.     lcdPlayChar(miao%10,7,STAR+4*WIDE);   
     
506.    }
     
507.   if(fashionupdate)
     
508.    {
     
509.      fashionupdate=0;
     
510.      lcdPlayChar(22,7,STAR+2*WIDE);
     
511.    }
     
512. }
     
513. //===================================================================
     
514. void t0isr(void) interrupt 1
     
515. {
     
516.   unsigned char key;
     
517.   TH0=(65536-10000)/256;
     
518.   TL0=(65536-10000)%256;
     
519.   downtimegap++;
     
520.   t0ms=++t0ms%100;
     
521.   if(t0ms==0)
     
522.    {
     
523.      timeupdate=1;
     
524.      miao=++miao%60;
     
525.          if(miao==0)
     
526.           fen=++fen%60;
     
527.    }
     
528.   if(t0ms==50)
     
529.    fashionupdate=1;
     
530. //----------------------------
     
531.   key=0xff;
     
532.   KEYLEFT=1;
     
533.   KEYRIGH=1;
     
534.   KEYROTATION=1;
     
535.   KEYDOWN=1;
     
536.   if(!KEYLEFT)
     
537.     key=0;
     
538.   if(!KEYRIGH)
     
539.     key=1;
     
540.   if(!KEYROTATION)
     
541.     key=2;
     
542.   if(!KEYDOWN)
     
543.     key=3;
     
544. 
     
545.   switch(keystate)
     
546.    {
     
547.     case 0: if(key!=gkey)
     
548.                  {
     
549.                           gkey=key;
     
550.                           keystate=1;
     
551.                          }
     
552.                         break;
     
553.    case 1: if(key==gkey)
     
554.              {
     
555.                            t0ms1=0;
     
556.                            keystate=2;
     
557.                            if(key!=0xff)
     
558.                              keyflag=1;
     
559.                          }
     
560.                    else
     
561.                      keystate=0;
     
562.                    break;
     
563.    case 2: if(key==gkey)
     
564.              {
     
565.                            if(t0ms1<PUSHON)
     
566.                              t0ms1++;
     
567.                          }
     
568.                    else
     
569.                     {
     
570.                           keystate=0;
     
571.                           keyflag=0;
     
572.                           gkey=0xff;
     
573.                         }
     
574.                    break;
     
575.    }
     
576. 
     
577. }
     
578. //===================================================================
     
579. void showNextCube(unsigned char code * p,unsigned char x,unsigned char y)
     
580. {
     
581. unsigned char i,j,temp;
     
582.   for(i=0;i<4;i++)
     
583.    {  
     
584.       temp=1;
     
585.       for(j=0;j<4;j++)
     
586.       {
     
587.         if(p[i] & temp)
     
588.          lcdPutPix(x+j,y+i,1);
     
589.         else
     
590.          lcdPutPix(x+j,y+i,0);
     
591.         temp<<=1;
     
592.       }
     
593.    }  
     
594. }
     
595. //------------------------------------------------------------------
     
596. void createCube(void)
     
597. {
     
598.   static unsigned char next;
     
599.   this.cube=next;
     
600.   next=TL0%7;
     
601.   this.row=0;
     
602.   this.column=6;
     
603.   this.state=0;
     
604.   this.box=cube+16*this.cube;
     
605.   showNextCube(cube+16*next,19,3);
     
606. }
     
607. //------------------------------------------------------------------
     
608. void showCubeMap(void)
     
609. {
     
610. unsigned char hang,lie,temp;
     
611. for(hang=MAXHANG-1;hang>0;hang--)
     
612.   {
     
613.    if(cubeMap[hang][0]==0 && cubeMap[hang][1]==0)
     
614.      break;
     
615. 
     
616.    for(lie=0;lie<(MAXLIE/8);lie++)
     
617.     {
     
618.      temp=8*lie;
     
619.      if(cubeMap[hang][lie]&0x01)
     
620.        lcdPutPix(temp+1,hang,1);
     
621. 
     
622.      if(cubeMap[hang][lie]&0x02)
     
623.        lcdPutPix(temp+2,hang,1);
     
624. 
     
625.      if(cubeMap[hang][lie]&0x04)
     
626.        lcdPutPix(temp+3,hang,1);
     
627. 
     
628.      if(cubeMap[hang][lie]&0x08)
     
629.        lcdPutPix(temp+4,hang,1);
     
630. 
     
631.      if(cubeMap[hang][lie]&0x10)
     
632.        lcdPutPix(temp+5,hang,1);
     
633. 
     
634.      if(cubeMap[hang][lie]&0x20)
     
635.        lcdPutPix(temp+6,hang,1);
     
636. 
     
637.      if(cubeMap[hang][lie]&0x40)
     
638.        lcdPutPix(temp+7,hang,1);
     
639. 
     
640.      if(cubeMap[hang][lie]&0x80)
     
641.        lcdPutPix(temp+8,hang,1);
     
642.     }
     
643.   }
     
644. }
     
645. //-------------------------------------------------------------------
     
646. void writeCubeToMap(void)
     
647. {
     
648.   unsigned char row,column,temp;
     
649.   unsigned char hang,lie;
     
650.   for(row=0;row<4;row++)
     
651.    {
     
652.      temp=1;
     
653.      for(column=0;column<4;column++)
     
654.           {
     
655.             if(this.box[row] & temp)
     
656.                  {
     
657.                    hang=this.row+row;
     
658.                    lie=this.column+column;
     
659.            cubeMap[hang][lie/8] |=bittable[lie%8];
     
660.                lcdPutPix(lie+1,hang,1);                          
     
661.                  }
     
662.                 temp<<=1;
     
663.           }
     
664.    }
     
665. }
     
666. //-------------------------------------------------------------------
     
667. void clearCubeFromMap(void)
     
668. {
     
669.   unsigned char row,column,temp;
     
670.   unsigned char hang,lie;
     
671.   for(row=0;row<4;row++)
     
672.    {
     
673.      temp=1;
     
674.      for(column=0;column<4;column++)
     
675.           {
     
676.             if(this.box[row] & temp)
     
677.                  {
     
678.                    hang=this.row+row;
     
679.                    lie=this.column+column;
     
680.            cubeMap[hang][lie/8] &=~bittable[lie%8];
     
681.                lcdPutPix(lie+1,hang,0);                  
     
682.                  }
     
683.                 temp<<=1;
     
684.           }
     
685.    }
     
686. }
     
687. //-------------------------------------------------------------------
     
688. unsigned char checkBorder(void)
     
689. {
     
690. if(this.box[3]!=0 && this.row>(MAXHANG-4))
     
691.     return 1;
     
692.   else if(this.box[2]!=0 && this.row>(MAXHANG-3))
     
693.     return 1;
     
694.   else if(this.box[1]!=0 && this.row>(MAXHANG-2))
     
695.     return 1;
     
696.   else if(this.box[0]!=0 && this.row>(MAXHANG-1))
     
697.     return 1;
     
698. //---------------------
     
699.   if((this.box[0] & 0x01) || (this.box[1] & 0x01) || (this.box[2] & 0x01) ||(this.box[3] & 0x01) )
     
700.    {
     
701.      if(this.column<0)
     
702.       return 1;
     
703.    }   
     
704.   else if((this.box[0] & 0x02) || (this.box[1] & 0x02) || (this.box[2] & 0x02) ||(this.box[3] & 0x02) )
     
705.    {
     
706.      if(this.column<-1)
     
707.       return 1;
     
708.    }
     
709.   else if((this.box[0] & 0x04) || (this.box[1] & 0x04) || (this.box[2] & 0x04) ||(this.box[3] & 0x04) )
     
710.    {
     
711.      if(this.column<-2)
     
712.       return 1;
     
713.    }
     
714.    else if((this.box[0] & 0x08) || (this.box[1] & 0x08) || (this.box[2] & 0x08) ||(this.box[3] & 0x08) )
     
715.    {
     
716.      if(this.column<-3)
     
717.       return 1;
     
718.    }
     
719. //---------------------
     
720.   if((this.box[0] & 0x08) || (this.box[1] & 0x08) || (this.box[2] & 0x08) ||(this.box[3] & 0x08) )
     
721.    {
     
722.      if(this.column>(MAXLIE-4))
     
723.       return 1;
     
724.    }   
     
725.   else if((this.box[0] & 0x04) || (this.box[1] & 0x04) || (this.box[2] & 0x04) ||(this.box[3] & 0x04) )
     
726.    {
     
727.      if(this.column>(MAXLIE-3))
     
728.       return 1;
     
729.    }
     
730.   else if((this.box[0] & 0x02) || (this.box[1] & 0x02) || (this.box[2] & 0x02) ||(this.box[3] & 0x02) )
     
731.    {
     
732.      if(this.column>(MAXLIE-2))
     
733.       return 1;
     
734.    }
     
735.   else if((this.box[0] & 0x08) || (this.box[1] & 0x08) || (this.box[2] & 0x08) ||(this.box[3] & 0x08) )
     
736.    {
     
737.      if(this.column>(MAXLIE-1))
     
738.       return 1;
     
739.    }
     
740. //--------------------
     
741.   return 0;
     
742. }
     
743. //------------------------------------------------------------------
     
744. unsigned char checkClask(void)
     
745. {
     
746.   unsigned char row,column,temp;
     
747.   unsigned char hang,lie;
     
748.   for(row=0;row<4;row++)
     
749.    {
     
750.      temp=1;
     
751.      for(column=0;column<4;column++)
     
752.           {
     
753.             if(this.box[row] & temp)
     
754.                {
     
755.                     hang=this.row+row;
     
756.                         lie=this.column+column;
     
757.                     if(cubeMap[hang][lie/8] & bittable[lie%8])
     
758.                           return 1;
     
759.                   }
     
760.                 temp<<=1;
     
761.           }
     
762.    }
     
763.   return 0;
     
764. }
     
765. //-------------------------------------------------------------------
     
766. void checkMap(void)
     
767. {
     
768.   unsigned char i,j,delete;
     
769.   bit full;
     
770.   full=0;
     
771.   delete=0;
     
772.   for(i=MAXHANG-1;i>0;i--)
     
773.    {
     
774.      if(cubeMap[i][0]==0 && cubeMap[i][1]==0)
     
775.             break;
     
776.          if(cubeMap[i][0]==0xff && cubeMap[i][1]==0xff)
     
777.            {
     
778.              delete++;
     
779.                  full=1;
     
780.                  for(j=i;j>0;j--)
     
781.                   {
     
782.                     cubeMap[j][0]=cubeMap[j-1][0];
     
783.                     cubeMap[j][1]=cubeMap[j-1][1];
     
784.                   }
     
785.                  i++;
     
786.                  cubeMap[0][0]=0;
     
787.                  cubeMap[0][1]=0;
     
788.            }
     
789.    }
     
790. if(full)
     
791.   {
     
792.     if(delete==1)
     
793.           score++;
     
794.         else if(delete==2)
     
795.           score+=4;
     
796.         else if(delete==3)
     
797.           score+=9;
     
798.         else if(delete==4)
     
799.           score+=16;
     
800.         rectangle();
     
801.         showCubeMap();
     
802.     if(score<50)
     
803.          speed=1;
     
804.         else if(score<100)
     
805.          speed=2;
     
806.         else if(score<500)
     
807.          speed=3;
     
808.         else if(score<1000)
     
809.          speed=4;
     
810.         else if(score<5000)
     
811.          speed=5;
     
812.         else if(score<10000)
     
813.          speed=6;
     
814.         else if(score<20000)
     
815.          speed=7;
     
816.         else if(score<30000)
     
817.          speed=8;
     
818.         else if(score<40000)
     
819.          speed=9;
     
820.         else if(score<50000)
     
821.          speed=10;
     
822.         else if(score<60000)
     
823.          speed=11;
     
824.         else
     
825.          speed=12;  
     
826.         showScoreSpeed();
     
827.   }
     
828. }
     
829. //-------------------------------------------------------------------
     
830. void moveLeft(void)
     
831. {
     
832.   clearCubeFromMap();
     
833.   this.column--;
     
834.   if(checkBorder() || checkClask())
     
835.     this.column++;
     
836.   writeCubeToMap();
     
837. }
     
838. //-------------------------------------------------------------------
     
839. void moveRigh(void)
     
840. {
     
841.   clearCubeFromMap();
     
842.   this.column++;
     
843.   if(checkBorder() || checkClask())
     
844.     this.column--;
     
845.   writeCubeToMap();
     
846. }
     
847. //-------------------------------------------------------------------
     
848. void moveDown(void)
     
849. {
     
850.   clearCubeFromMap();
     
851.   this.row++;
     
852.   if(checkBorder() || checkClask())
     
853.    {
     
854.     this.row--;
     
855.         downok=1;
     
856.    }
     
857.   else
     
858.    downok=0;
     
859.   writeCubeToMap();
     
860.   if(downok)
     
861.     checkMap();
     
862. }
     
863. //------------------------------------------------------------------
     
864. void cubeRotation(void)
     
865. {
     
866.   unsigned char temp;
     
867.   temp=this.state;
     
868.   clearCubeFromMap();
     
869.   this.state=++this.state%4;
     
870.   this.box=cube+16*this.cube+4*this.state;
     
871.   if(checkBorder() || checkClask())
     
872.    {
     
873.      this.state=temp;
     
874.      this.box=cube+16*this.cube+4*this.state;
     
875.    }
     
876.   writeCubeToMap();
     
877. }
     
878. /////////////////////////////////////////////////////////////////////
     
879. void main(void)
     
880. {
     
881.   TMOD=0x1;
     
882.   TH0=(65536-10000)/256;
     
883.   TL0=(65536-10000)%256;
     
884.   EA=1;
     
885.   ET0=1;
     
886.   TR0=1;
     
887.   lcdIni();
     
888.   for(t0ms=0;t0ms<MAXHANG;t0ms++)
     
889.    {
     
890.      cubeMap[t0ms][0]=0;
     
891.      cubeMap[t0ms][1]=0;
     
892.    }
     
893.   while(1)
     
894.    {
     
895.      createCube();
     
896.          if(checkClask())
     
897.           {
     
898.        rectangle();
     
899. #define SHOWSTAR 12
     
900. #define GAP 8
     
901.        lcdPlayChar(23,2,SHOWSTAR); //GAME
     
902.        lcdPlayChar(24,2,SHOWSTAR+GAP);            
     
903.        lcdPlayChar(25,2,SHOWSTAR+2*GAP);
     
904.        lcdPlayChar(12,2,SHOWSTAR+3*GAP);
     
905. 
     
906.        lcdPlayChar(20,4,SHOWSTAR); //OVER     
     
907.        lcdPlayChar(26,4,SHOWSTAR+GAP);
     
908.        lcdPlayChar(12,4,SHOWSTAR+2*GAP);
     
909.        lcdPlayChar(21,4,SHOWSTAR+3*GAP);
     
910.        t0ms=0;
     
911.        while(t0ms<95);//延時(shí)2秒
     
912.            t0ms=0;
     
913.        while(t0ms<95);
     
914.        ((void (code *) (void)) 0x0000) ( );           
     
915.           }
     
916.      while(1)
     
917.           {
     
918.                 timeServer();
     
919.             if(keyflag)
     
920.                  {
     
921.                    keyflag=0;
     
922.                    t0ms1=0;
     
923.                    if(gkey==0)
     
924.                      moveLeft();
     
925.                    if(gkey==1)
     
926.                      moveRigh();
     
927.                    if(gkey==2)
     
928.                      cubeRotation();
     
929.                    if(gkey==3)
     
930.                      moveDown();                     
     
931.                  }
     
932.        if(gkey==0 && t0ms1==PUSHON)
     
933.             {
     
934.                   t0ms1-=10;
     
935.                   moveLeft();
     
936.                 }
     
937.        if(gkey==1 && t0ms1==PUSHON)
     
938.             {
     
939.                   t0ms1-=10;
     
940.                   moveRigh();
     
941.                 }
     
942.        if(gkey==3 && t0ms1==PUSHON)
     
943.             {
     
944.                   t0ms1-=10;
     
945.                   moveDown();
     
946.                 }
     
947.            if(downtimegap>(DOWNTIME-speed))
     
948.             {
     
949.              moveDown();
     
950.                  downtimegap=0;
     
951.                 }
     
952.            if(downok)
     
953.             {
     
954.                   downok=0;
     
955.                   break;
     
956.                 }
     
957.           }
     
958.    }
     
959. }

復(fù)制代碼

全部資料51hei下載地址：
基于51單片機(jī)和Proteus仿真的俄羅斯方塊游戲設(shè)計(jì).zip (89.2 KB, 下載次數(shù): 87)

2019-5-9 17:08 上傳

點(diǎn)擊文件名下載附件
下載積分: 黑幣 -5

---

作者: 1263152934    時(shí)間: 2020-6-2 16:48
感謝樓主了

---

歡迎光臨 (http://m.raoushi.com/bbs/)

Powered by Discuz! X3.1

感谢您访问我们的网站，您可能还对以下资源感兴趣：

1024手机基地看电影