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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › Cortex M3 M0 M4开发 › 基于LPC1768的俄罗斯方块源代码，配合3.2寸TFT屏幕
返回列表 发新帖
查看: 3967|回复: 2
收起左侧

基于LPC1768的俄罗斯方块源代码，配合3.2寸TFT屏幕

[复制链接]
ID:324527 发表于 2018-5-7 20:48 | 显示全部楼层 |阅读模式
程序运行后，用板子上的五向按键控制。

单片机源程序如下:
  1. #include <stdlib.h>
  2. #include <stdint.h>
  3. #include "lcd_api.h"
  4. #include "ili_lcd_general.h"
  5. #include "LPC17xx.h"

  7. typedef struct                                                 //方块结构体，包括类型，状态，坐标，颜色
  8. {
  9. uint8_t type;                                                //方块的类型（LJITOSZ）
  10. uint8_t state;                                                //方块的状态（0、90、180、270°旋转）
  11. int16_t x,y;                                                        //方块的坐标
  12. uint8_t colorType;                                           //颜色类型
  13. }BOX;

  15. const uint8_t box[56]=                                           //方块数组，包括七种方块，每种四种状态
  16. {
  17. 0x80,0x0e,0x46,0x04,0x70,0x01,0x20,0x62,/*J*/
  18. 0x20,0x0e,0x44,0x06,0x70,0x04,0x60,0x22,/*L*/
  19. 0x60,0x0c,0x64,0x02,0x30,0x06,0x40,0x26,/*s*/
  20. 0xc0,0x06,0x62,0x04,0x60,0x03,0x20,0x46,/*z*/
  21. 0x40,0x0e,0x64,0x04,0x70,0x02,0x20,0x26,/*T*/
  22. 0x44,0x44,0xf0,0x00,0x22,0x22,0x00,0x0f,/*I*/
  23. 0xc0,0x0c,0x66,0x00,0x30,0x03,0x00,0x66,/*O*/  
  24. };

  26. uint8_t map[10][20];                                                //地图数组，包括二十行十列，存方块的颜色类型

  28. const int colors[]={0,Blue,Red,Magenta,Green,Yellow};                  //颜色数组，声明要用到的颜色
  29.        
  30. BOX this,next;                                                // 定义两个结构变量，当前方块和下个方块

  32. uint16_t score=0;                                 //全局变量总分

  34. uint8_t toButtom,downTimes;                                         //标记是否落到底

  36. void mapInit(){                                                                 //初始化地图
  37.         lcd_Initializtion();
  38.         DrawYLine(161,0,319,Red);
  39.         WriteChineseString(176,32,0,3,White,Black);
  40.         WriteChineseString(176,160,3,3,White,Black);
  41.         WriteEnglishString(176,192,"00000",White,Black);
  42. }

  44. void showScore(){                                          //显示总分函数
  45.         WriteEnglishWord(176,192,score/10000+48,White,Black);
  46.         WriteEnglishWord(184,192,(score/1000)%10+48,White,Black);
  47.         WriteEnglishWord(192,192,(score/100)%10+48,White,Black);
  48.         WriteEnglishWord(200,192,(score/10)%10+48,White,Black);
  49.         WriteEnglishWord(208,192,score%10+48,White,Black);
  50. }

  52. void delay(uint8_t k){                                                   //延时函数
  53.         int i,j;
  54.         for(j=0;j<k;j++){
  55.                 for(i=0;i<900000;i++);
  56.         }
  57. }

  59. void disBox(BOX b){                                           //显示方块函数，参数是一个BOX
  60.         uint8_t i,j,k,l;
  61.         i=b.type*8+b.state*2;
  62.         l=box[i];
  63.         for(j=0;j<2;j++){
  64.                 for(k=0;k<4;k++){
  65.                         if(l&0x01){
  66.                                 DrawBox(b.x+k,b.y+j,colors[b.colorType]);
  67.                                 if(b.x!=11){
  68.                                         map[b.x+k][b.y+j]=b.colorType;
  69.                                 }
  70.                         }
  71.                         l>>=1;
  72.                 }
  73.         }
  74.         l=box[i+1];
  75.         for(j=0;j<2;j++){
  76.                 for(k=0;k<4;k++){
  77.                         if(l&0x01){
  78.                                 DrawBox(b.x+k,b.y+j+2,colors[b.colorType]);
  79.                                 if(b.x!=11){
  80.                                         map[b.x+k][b.y+j+2]=b.colorType;
  81.                                 }
  82.                         }
  83.                         l>>=1;
  84.                 }
  85.         }
  86. }

  88. void clearBox(){                                          //清除方块函数
  89.         uint8_t i,j,k,l;
  90.         i=this.type*8+this.state*2;
  91.         l=box[i];
  92.         for(j=0;j<2;j++){
  93.                 for(k=0;k<4;k++){
  94.                         if(l&0x01){
  95.                                 CoverBox(this.x+k,this.y+j);
  96.                                 map[this.x+k][this.y+j]=0;
  97.                         }
  98.                         l>>=1;
  99.                 }
  100.         }
  101.         l=box[i+1];
  102.         for(j=0;j<2;j++){
  103.                 for(k=0;k<4;k++){
  104.                         if(l&0x01){
  105.                                 CoverBox(this.x+k,this.y+j+2);
  106.                                 map[this.x+k][this.y+j+2]=0;
  107.                         }
  108.                         l>>=1;
  109.                 }
  110.         }
  111. }

  113. void clearNext(){                                                          //清除下一个函数
  114.         uint8_t x,y;
  115.         for(x=11;x<15;x++){
  116.                 for(y=5;y<9;y++){
  117.                         CoverBox(x,y);       
  118.                 }
  119.         }
  120. }

  122. void createNext(){                                                   //创建下一个函数
  123.         clearNext();
  124.         next.x=11;
  125.         next.y=5;
  126.         next.colorType=rand()%5+1;                          //随机颜色
  127.         next.type=rand()%7;                                          //随机种类
  128.         next.state=rand()%4;                                   //随机状态
  129.         disBox(next);
  130. }

  132. int16_t checkCrack(){           //检测是否碰撞
  133.         uint8_t isCrack = 0;
  134.         uint8_t i,j,k,l;
  135.         int16_t x,y;
  136.         i=this.type*8+this.state*2;
  137.         l=box[i];
  138.         for(j=0;j<2;j++){
  139.                 for(k=0;k<4;k++){
  140.                         if(l&0x01){
  141.                                 x=this.x+k;
  142.                                 y=this.y+j;
  143.                                 if(x<0||x>9||y>19||map[x][y]!=0){           // 方块越过边界或者已经被占即为已碰撞
  144.                                         isCrack = 1;
  145.                                         break;
  146.                                 }                               
  147.                         }
  148.                         l>>=1;
  149.                 }
  150.         }
  151.         if(!isCrack){
  152.                 l=box[i+1];
  153.                 for(j=0;j<2;j++){
  154.                         for(k=0;k<4;k++){
  155.                                 if(l&0x01){
  156.                                         x=this.x+k;
  157.                                         y=this.y+j+2;
  158.                                         if(x<0||x>9||y>19||map[x][y]!=0){
  159.                                                 isCrack = 1;
  160.                                                 break;
  161.                                         }                               
  162.                                 }
  163.                                 l>>=1;
  164.                         }
  165.                 }
  166.         }
  167.         return isCrack;
  168. }

  170. void putIntoMap(){                                                  //把方块放入地图
  171.         this=next;
  172.         this.x=3;
  173.         this.y=0;
  174. }

  176. void moveLeft(){                                          //向左移动
  177.         clearBox();
  178.         this.x--;
  179.         if(checkCrack()){
  180.                 this.x++;
  181.         }
  182.         disBox(this);
  183. }

  185. void moveRight(){                                          //向右移动
  186.         clearBox();
  187.         this.x++;
  188.         if(checkCrack()){
  189.                 this.x--;
  190.         }
  191.         disBox(this);
  192. }

  194. void refreshMap(){                                                //刷新地图
  195.         uint8_t i,j;
  196.         FillRect(0,0,159,319,Black);
  197.         for(i=0;i<20;i++){
  198.                 for(j=0;j<10;j++){
  199.                         if(map[j][i]!=0){
  200.                                 DrawBox(j,i,colors[map[j][i]]);
  201.                         }
  202.                 }
  203.         }
  204. }

  206. void checkMap(){                         //检查是否需要消行
  207.         int8_t i,j,k;
  208.         for(i=19;i>=0;i--){
  209.                 k=0;
  210.                 for(j=0;j<10;j++){
  211.                         if(map[j][i]!=0){
  212.                                 k++;
  213.                         }
  214.                 }
  215.                 if(k==10){                                         //如果一行上全部被占位即为需要消行
  216.                         score++;
  217.                         showScore();
  218.                         for(j=i;j>0;j--){
  219.                                 for(k=0;k<10;k++){
  220.                                         map[k][j]=map[k][j-1];
  221.                                 }
  222.                         }
  223.                         for(k=0;k<10;k++){
  224.                                 map[k][0]=0;
  225.                         }
  226.                         i++;
  227.                         refreshMap();
  228.                 }
  229.         }
  230. }

  232. void moveDown(){                                //下移方块
  233.         clearBox();
  234.         this.y++;
  235.         if(checkCrack()){
  236.                 toButtom = 1;
  237.                 this.y--;
  238.                 disBox(this);
  239.                 checkMap();
  240.         }else{
  241.                 disBox(this);
  242.         }
  243.         downTimes=0;
  244. }

  246. void moveTurn(){                                        //翻转方块
  247.         clearBox();
  248.         this.state=(++this.state)%4;
  249.         if(checkCrack()){
  250.                 this.state=(--this.state)%4;
  251.         }
  252.         disBox(this);
  253.         delay(5);
  254. }

  256. void showMap(){                                        //显示地图函数
  257.         uint16_t key;
  258.         createNext();                                                          
  259.         while(1){
  260.                 putIntoMap();
  261.                 createNext();
  262.                 if(!checkCrack()){
  263.                         disBox(this);
  264.                 }else{
  265.                         WriteEnglishString(50,150,"GAME OVER!",White,Black);
  266.                         break;
  267.                 }
  268.                 while(1){
  269.                         key = ((LPC_GPIO1->FIOPIN >> 26)&0x0f);       
  270.                         switch(key){
  271.                                 case 0x07:                //上
  272.                                         moveTurn();
  273.                                 break;
  274.                                 case 0x0e:                 //下
  275.                                         moveDown();
  276.                                 break;
  277. ……………………

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

所有资料51hei提供下载:
【02】宝马1768_LCD俄罗斯方块(2014.05.28).rar (96.9 KB, 下载次数: 31)
回复

使用道具 举报

ID:507806 发表于 2019-4-9 14:09 | 显示全部楼层
打开程序怎么在keil中不能运行啊
回复

使用道具 举报

ID:251735 发表于 2019-4-11 18:00 | 显示全部楼层
顶一下
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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