有关贪吃蛇的历史发展可以看一下这个网址，贪吃蛇最初的设计和现在并不相同。。http://www.techweb.com.cn/internet/2013-02-21/1278055.shtml

　　该项目设计硬件平台选择了简单易用的AT89C51单片机，显示屏选择的是AMPIRE128X64液晶屏幕显示器，按照一定顺序连接后，如下图：

　　

　　软件方面采用了C51编写代码，代码编写模块如下图：

　　除去网上已有的图形驱动代码外，其核心代码主要为游戏处理、信息处理和按键处理。

　　编写游戏的功能代码，先定义游戏的数据结构和常量。

  1. #define uchar unsigned char
  2. #define uint  unsigned int
  3.  
  4. sbit  P00 = P0 ^ ;                //    右
  5. sbit  P01 = P0 ^ ;                //    左
  6. sbit  P02 = P0 ^ ;                //    上
  7. sbit  P03 = P0 ^ ;                //    下
  8. sbit  P04 = P0 ^ ;                //    开始/暂停
  9.  
  10. #define RIGHT 1
  11. #define LEFT  2
  12. #define UP    3
  13. #define DOWN  4
  14.  
  15. #define ERASE     0
  16. #define REWRITTEN 1
  17.  
  18. #define NO  0
  19. #define YES 1
  20.  
  21. #define FALSE 0
  22. #define TRUE  1
  23.  
  24. bit ESC = TRUE;                   //    开始 暂停标志位
  25.  
  26. uchar gameSpeed = ;             //    游戏速度调节
  27. uchar level = ;                  //    难度
  28. uchar s1[] = "";                 //    保存显示难度的汉子
  29.  
  30. //    uchar = unsigned char
  31. //    食物的结构体
  32. struct Food
  33. {
  34.    uchar x;                        //    食物的横坐标
  35.    uchar y;                        //    食物的纵坐标
  36. }food;    
  37.  
  38. //    贪吃蛇主体的结构体
  39. struct Snake
  40. {
  41.    uchar x[];
  42.    uchar y[];
  43.    uchar node;                    //    蛇的节数
  44.    uchar direction;               //    蛇移动方向
  45. }snake;

　　其中食物的数据结构采用结构体定义，两个unsigned char变量分别定义为食物的横纵坐标；蛇的身体定义为长度最大值为39的数组，游戏中贪吃蛇长度达到39，游戏通关结束。

　　游戏处理模块为贪吃蛇在游玩过程中遇到的需要被处理的情况，主要实现的功能包括以下四个方面，即移动、食物、死亡和更新。

  1. 移动

    　　流程与运行仿真如上图，按下“开始”键后，游戏开始启动，初始化完毕后，屏幕会显示“贪吃蛇”、“食物”和游戏的边界框，“贪吃蛇”在固定的周期内会向前移动一格，此时“贪吃蛇”身体从尾巴至头部每一个后序节点会向前序节点移动，后序节点移动完毕后，头部会根据此时按键的方向对相应的横纵坐标进行加减。

  2. 食物

    　　“贪吃蛇”向前移动后，此时要判断蛇头是否与“食物”的横纵坐标一一对应，如果不是则退出该模块，进入下一模块；如果是，则“贪吃蛇”的节数增加一。节数增加后判断蛇的节数是否为10的倍数，如果是则提升“贪吃蛇”的等级，并对游戏增加难度，加快贪吃蛇移动的速度。退出了游戏升级的模块后将进入创建新的“食物”模块，为了避免“食物”与“贪吃蛇”的节点坐标重复，“食物”在创建后要与“贪吃蛇”的每个节点的坐标一一比较，如果重合则重新创建“食物”的坐标，直到创建成功为止。

  3. 结束

    　　“贪吃蛇”在向前移动后，有可能撞到墙壁或自己的身体，也有可能吃到食物，或者只是向前移动一格，移动完毕后如果吃到了食物，如果“贪吃蛇”的node(节数)达到了最大值（39），那么玩家将会通关游戏，并且游戏退出，此时需要判断游戏是否结束，一共有三种判别，前两种为失败结局，即撞到了墙壁或自己的身体，最后一种为通关结局，将在屏幕上打印“Congratulations”祝贺玩家成功通关游戏。

  4. 更新

    　　游戏在判断结束后，如果没有结束，那么更新屏幕上的“贪吃蛇”的状态。

　　四个模块的核心代码如下：

  1. //    运行游戏的具体实现
  2. void gamePlay(void)
  3. {
  4.     bit hero = FALSE;                   //    完成游戏
  5.  
  6.     while() {
  7.         EA = ;
  8.         if (ESC == FALSE) {
  9.             gameSpeed = ;
  10.                level = ;
  11.             s1[] = '';
  12.             start();
  13.         }
  14.  
  15.         while(ESC == FALSE) {
  16.             EA = ;            
  17.  
  18.             move();                                                               //    贪吃蛇向前移动
  19.  
  20.             if(snake.x[] == food.x && snake.y[] == food.y) {                    //    判断蛇头吃到食物以后
  21.                 RectArea(food.x, food.y, food.x + , food.y + , ERASE);          //    把画面上的食物去掉
  22.                 snake.node++;                                                     //    蛇的身体长一节
  23.  
  24.                 if (increaseLevel()) {                                            //    根据难度变化判断是否要重新开始
  25.                     restart();
  26.                     continue;
  27.                 }
  28.  
  29.                 while (!createNewFood()) {                                        //    如果创建失败则继续创建，直到成功
  30.                     ;
  31.                 }
  32.  
  33.                 RectArea(food.x, food.y, food.x + , food.y + , REWRITTEN);      //    在画面上显示食物
  34.             }
  35.  
  36.             if (isOver()) {                                                       //    判断游戏是否结束
  37.                 if(snake.node == )
  38.                     hero = TRUE;
  39.                 }
  40.                 ESC = TRUE;
  41.                 hero = gameOver(hero);
  42.                 break;
  43.             }        
  44.  
  45.             //    打印贪吃蛇
  46.             updataSnakeHead();                //    更新头部
  47.             delay(gameSpeed);                 //    速度设置
  48.             eraseSnakeTail();                 //    删除尾巴
  49.         }   //    退出循环(!ESC)
  50.     }
  51. }

　　其余的函数代码编写如下：

  1. //    随机数产生
  2. int rand(void)
  3. {
  4.     int i;
  5.     i = ((TH0 << ) | TL0) & 0x7fff;
  6.     return(i);
  7. }
  8.  
  9. //    延时
  10. void delay(uchar ms)       //    10毫秒
  11. {
  12.     uchar i, j, k;
  13.  
  14.     while(ms--) {
  15.         for(i = ; i > ; i--) {
  16.             for(j = ; j > ; j--) {
  17.                 for(k = ; k > ; k--)
  18.                     ;
  19.             }
  20.         }
  21.     }
  22. }
  23.  
  24. void mulDelay(int s)     //    1秒
  25. {
  26.     int i;
  27.     uchar j;
  28.  
  29.     for (i = ; i < s; ++i) {
  30.         for (j = ; j < ; ++j) {
  31.             delay();
  32.         }
  33.     }
  34. }
  35.  
  36. //    键扫描函数
  37. void KeyScan()
  38. {
  39.     P0 = 0xff;
  40.  
  41.     if(P00 ==  && snake.direction != LEFT) {
  42.         snake.direction = RIGHT;
  43.     }
  44.  
  45.     if(P01 ==  && snake.direction != RIGHT) {
  46.         snake.direction = LEFT;
  47.     }
  48.  
  49.     if(P02 ==  && snake.direction != DOWN) {
  50.         snake.direction = UP;
  51.     }         
  52.  
  53.     if(P03 ==  && snake.direction != UP) {
  54.         snake.direction = DOWN;
  55.     }
  56.  
  57.     if(P04 == ) {
  58.         ESC = ~ESC;
  59.     }
  60. }
  61.  
  62. void int_0(void) interrupt
  63. {
  64.     EA = ;
  65.     KeyScan();
  66. }
  67.  
  68. void snakeInit()
  69. {
  70.     snake.direction = RIGHT;            //    方向往右
  71.  
  72.     snake.x[] = ;                     //    蛇头坐标
  73.     snake.y[] = ;    
  74.  
  75.     snake.x[] = ;                     //    蛇尾坐标
  76.     snake.y[] = ;
  77.  
  78.     snake.node = ;                     //    节数
  79. }
  80.  
  81. void init(void)
  82. {
  83.     EX0 = ;                            //    开中断
  84.     IT0 = ;                            //    设置电平触发方式
  85.     EA = ;                             //    开所有中断
  86.     TMOD = 0x01;
  87.     TH0 =  / ;
  88.     TL0 =  % ;
  89.     TR0 = ;
  90.  
  91.     hz_disp(, , , snaker, );
  92.     snakeInit();
  93. }
  94.  
  95. //    需要出现新食物
  96. bit createNewFood()
  97. {
  98.     uchar i;
  99.     uchar size = snake.node;
  100.     bit flag = TRUE;                         //    标记创建的新事物与贪吃蛇的身体冲突
  101.  
  102.     food.x = rand() %  + ;
  103.     food.y = rand() %  + ;
  104.  
  105.     //    食物的坐标必须为3的倍数才会在显示屏先被显示
  106.     for (; food.x %  != ; ++food.x) {
  107.         ;
  108.     }
  109.  
  110.     for (; food.y %  != ; ++food.y) {
  111.         ;
  112.     }
  113.  
  114.     for (i = ; i < size; ++i) {
  115.         if (food.x == snake.x[i] && food.y == snake.y[i]) {
  116.             flag = FALSE;
  117.             break;
  118.         }
  119.     }    
  120.  
  121.     return flag;
  122. }
  123.  
  124. void start()
  125. {
  126.     ClearLCD();
  127.     hz_disp(, , , gameLevel, REWRITTEN);                         //    显示汉子“难度”
  128.     en_disp(, , , Asc, s1, REWRITTEN);                           //    显示s1数组的内容
  129.     delay();
  130.     ClearLCD();
  131.  
  132.     rectBoundary(, , , , REWRITTEN);                          //    显示边框
  133.  
  134.     while (!createNewFood()) {                                       //    如果创建失败则继续创建，直到成功
  135.         ;
  136.     }
  137.  
  138.     RectArea(food.x, food.y, food.x + , food.y + , REWRITTEN);     //    在画面上显示食物
  139. }
  140.  
  141. //    重新开始
  142. void restart()
  143. {
  144.     start();
  145. }
  146.  
  147. //    是否增加难度
  148. //    如果是，那么要重新开始
  149. bit increaseLevel()
  150. {
  151.     bit res = NO;
  152.     //    每次蛇的长度超过10个增加一次难度，level最高4级
  153.     if(snake.node %  == ) {
  154.         level += ;
  155.         switch (level) {
  156.             case :
  157.                 s1[] = '';
  158.                 gameSpeed = ;
  159.                 break;
  160.             case :
  161.                 s1[] = '';
  162.                 gameSpeed = ;
  163.                 break;
  164.             case :
  165.                 s1[] = '';
  166.                 gameSpeed = ;
  167.                 break;
  168.         }
  169.         res = YES;
  170.     }
  171.  
  172.     return res;
  173. }
  174.  
  175. //    贪吃蛇移动
  176. void move()
  177. {
  178.     uchar i;
  179.  
  180.     //    将蛇从最后个节点向前一个节点移动
  181.     for(i = snake.node - ; i > ; i--) {
  182.         snake.x[i] = snake.x[i - ];
  183.         snake.y[i] = snake.y[i - ];
  184.     }
  185.  
  186.     //    根据此时贪吃蛇的方向，设置蛇头的位置
  187.     switch(snake.direction)    {
  188.         case RIGHT:
  189.             snake.x[] += ;
  190.             break;
  191.         case LEFT:
  192.             snake.x[] -= ;
  193.             break;
  194.         case UP:
  195.             snake.y[] -= ;
  196.             break;
  197.         case DOWN:
  198.             snake.y[] += ;
  199.             break;
  200.     }
  201. }
  202.  
  203. //    游戏是否结束
  204. bit isOver()
  205. {
  206.     bit overFlag = ;
  207.     uchar i;
  208.  
  209.     //    判断蛇是否吃到自己了
  210.     //    从蛇的第四节开始判断是否撞到自己了
  211.     for (i = ; i < snake.node; i++)    {
  212.         if (snake.x[i] == snake.x[] && snake.y[i] == snake.y[]) {
  213.             overFlag = ;
  214.             break;
  215.         }
  216.     }
  217.  
  218.     if(snake.x[] <  || snake.x[] >
  219.     || snake.y[] <  || snake.y[] > ) {                //    判断蛇是否撞到墙壁
  220.         overFlag = ;
  221.     }
  222.  
  223.     if(snake.node == ) {
  224.         overFlag = ;
  225.     }
  226.  
  227.     return overFlag;
  228. }
  229.  
  230. void congratulations()
  231. {
  232.     idata uchar str[] = "Congratulations";
  233.     uchar tmp[];
  234.     uchar len = ;
  235.     uchar i;
  236.     s1[] = 's';
  237.     for (i = ; i < ; ++i) {
  238.         tmp[] = str[i];
  239.         en_disp(, i *  + , , Asc, tmp, REWRITTEN);
  240.         //    en_disp(3, 80, 1, Asc, s1, REWRITTEN);
  241.     }
  242. }
  243.  
  244. //    游戏结束后的画面
  245. void theEndGraph()
  246. {
  247.     uchar i, j;
  248.  
  249.     for (i = ; i < ; ++i) {
  250.         for (j = ; j < ; ++j) {
  251.             hz_disp(i * , j * , , mySchool[i*+j], );
  252.         }
  253.     }
  254.  
  255.     for (i = ; i < ; ++i) {
  256.         hz_disp(, i * , , myName[i], );
  257.     }
  258. }
  259.  
  260. //    游戏结束
  261. bit gameOver(bit hero)
  262. {
  263.     //    ClearLCD();
  264.  
  265.     if (hero == TRUE) {                    //    当玩家贪吃蛇的节点达到了39个后显示恭喜通关画面
  266.         hero = FALSE;
  267.         congratulations();
  268.         mulDelay();
  269.     } else {
  270.         hz_disp(, , , theEnd, );
  271.         mulDelay();
  272.     }
  273.  
  274.     ClearLCD();
  275.     theEndGraph();                        //    打印“毕业设计“
  276.     snakeInit();                          //    重新初始化游戏的参数
  277.     return hero;
  278. }
  279.  
  280. //    更新贪吃蛇的头部
  281. void updataSnakeHead()
  282. {
  283.     RectArea(snake.x[], snake.y[], snake.x[] + , snake.y[] + , REWRITTEN);         //    绘制当前的头部
  284.     RectArea(snake.x[], snake.y[], snake.x[] + , snake.y[] + , REWRITTEN);         //    将上一次的头部重新绘制以补全边角
  285.  
  286.     //    根据蛇的方向擦除蛇的头部中间的一点以确认贪吃蛇的头部
  287.     switch (snake.direction) {
  288.         case RIGHT:
  289.             Dot(snake.x[] + , snake.y[] + , ERASE);
  290.             break;
  291.  
  292.         case LEFT:
  293.             Dot(snake.x[], snake.y[] + , ERASE);
  294.             break;
  295.  
  296.         case UP:
  297.             Dot(snake.x[] + , snake.y[], ERASE);
  298.             break;
  299.  
  300.         case DOWN:
  301.             Dot(snake.x[] + , snake.y[] + , ERASE);
  302.             break;
  303.     }
  304. }
  305.  
  306. //    去除蛇的的最后一节
  307. void eraseSnakeTail()
  308. {
  309.      RectArea(snake.x[snake.node - ], snake.y[snake.node - ], snake.x[snake.node - ] + , snake.y[snake.node - ] + , ERASE);
  310. }

　　

　　测试函数放在最后

  1. void main (void)
  2. {
  3.     LCD12864_init();
  4.     ClearLCD();
  5.     init();
  6.  
  7.     gamePlay();
  8.     while() {
  9.         ;
  10.     }
  11. }

　　以上是贪吃蛇游戏的实现snake.c，游戏的图形驱动12864.h和打印的字符代码asc.h如下：

  1. //    12864.h
  2. /*-----------------------------------------------------------*/
  3. #define LCD_OFF 0x3E
  4. #define LCD_ON  0x3F
  5. #define Add_X     0xB8     //    the start address of the page 0 ;(0~7)
  6. #define Add_Y     0x40     //    the start address of the Y counter ; (0~64)
  7. #define Add_Z     0xC0     //    the start address of the DDRAM ; (0~64)
  8. /*-----------------------------------------------------------*/
  9. #define  LCD12864_DATA_PORT  P1
  10. typedef unsigned char uchar;
  11.  
  12. sbit  LCD12864_EN         = P2 ^ ;
  13. sbit  LCD12864_RW         = P2 ^ ;       //    0:write ; 1:read
  14. sbit  LCD12864_RS         = P2 ^ ;       //    0:the command .1:the data
  15. sbit  LCD12864_CS_L       = P2 ^ ;       //    select the left of the lcd when 1
  16. sbit  LCD12864_CS_R       = P2 ^ ;  
  17.  
  18. /*--------------------------函数列表-------------------------*/
  19. void LCDSel(uchar sel);                        //    片选 0全选 1左 2右
  20. void WaitLCD();                                //    忙等待
  21. void WriteDatToLCD12864(uchar dat);            //    写数据
  22. void WriteCmdToLCD12864(uchar cmd);            //    写命令
  23. uchar ReadDatFromLCD12864(void);               //    读数据
  24.  
  25. void SetX(uchar x);                            //    设置页地址0 - 7
  26. void SetY(uchar y);                            //    设置列地址0 - 127
  27. void SetZ(uchar z);                            //    设置首地址0-63
  28.  
  29. void ClearLCD();                               //    清屏 
  30.  
  31. void Dot(char x, char y, bit flag);            //    x:0~63~127    y:0~63    flag :0：擦除某个点 1：显示某个点
  32. void Line(uchar x1, uchar y1, uchar x2, uchar y2, bit flag);                           //    (x1,y1) (x2,y2)作直线   flag :0：擦除线 1：显示线
  33. void Rect(uchar x1, uchar y1, uchar x2, uchar y2, bit flag);                           //    (x1,y1) (x2,y2)作矩形框  flag :0：擦除框 1：显示框
  34. void RectArea(uchar x1, uchar y1, uchar x2, uchar y2, bit flag);                       //    (x1,y1) (x2,y2)填充矩形  flag :0：擦除矩形 1：显示矩形
  35. void hz_disp(uchar x, uchar y, uchar n, uchar code * hz, bit flag);                    //    x:行0~7  y:列0~127  显示n个汉字 flag:0 反白  16*16
  36. void en_disp(uchar x, uchar y, uchar n, uchar code *asc, uchar *string, bit flag);     //    x:行0~7  y:列0~127  asc:指向标准交换码  string:指向要显示的字符串  flag:0 反白显示
  37.  
  38. /*--------------------------select the LCD--------------------*/
  39. void LCDSel(uchar sel)
  40. {
  41.     switch(sel) {
  42.         case :
  43.             LCD12864_CS_L = ;
  44.             LCD12864_CS_R = ;
  45.             break;
  46.         case :
  47.             LCD12864_CS_L = ;
  48.             LCD12864_CS_R = ;
  49.             break;       //left
  50.         case :
  51.             LCD12864_CS_L = ;
  52.             LCD12864_CS_R = ;
  53.             break;        //right
  54.         default:
  55.             ;
  56.     }
  57. }
  58.  
  59. /*------------------------------------------------------------*/
  60. void WaitLCD()
  61. {
  62.     uchar flag;
  63.     LCD12864_DATA_PORT = 0xFF;
  64.     LCD12864_RW = ;
  65.     LCD12864_RS = ;
  66.     LCD12864_EN = ;
  67.     LCD12864_EN = ;
  68.     LCD12864_EN = ;
  69.     LCD12864_DATA_PORT = 0xFF;
  70.     LCD12864_RW = ;
  71.     LCD12864_RS = ;
  72.     LCD12864_EN=;
  73.  
  74.     do {
  75.         flag=LCD12864_DATA_PORT;
  76.     } while(!((flag & 0x80) == 0x80));
  77.  
  78.     LCD12864_EN=;
  79. }
  80.  
  81. /*-------------------------------------------------------------*/
  82. void WriteDatToLCD12864(uchar dat)
  83. {
  84.     WaitLCD();
  85.     LCD12864_RS = ;
  86.     LCD12864_RW = ;
  87.     LCD12864_DATA_PORT = dat;
  88.  
  89.     LCD12864_EN = ;
  90.     LCD12864_EN = ;
  91. }
  92.  
  93. /*-------------------------------------------------------------*/
  94. void WriteCmdToLCD12864(uchar cmd)
  95. {
  96.     WaitLCD();
  97.     LCD12864_RS = ;
  98.     LCD12864_RW = ;
  99.     LCD12864_DATA_PORT = cmd;
  100.  
  101.     LCD12864_EN = ;
  102.     LCD12864_EN = ;
  103. }
  104. /*-------------------------------------------------------------*/
  105. uchar ReadDatFromLCD12864(void)
  106. {
  107.     uchar dat;
  108.     WaitLCD();
  109.  
  110.     LCD12864_DATA_PORT = 0xFF;
  111.     LCD12864_RS = ;
  112.     LCD12864_RW = ;
  113.     LCD12864_EN = ;
  114.     LCD12864_EN = ;
  115.     LCD12864_EN = ;
  116.  
  117.     LCD12864_DATA_PORT = 0xFF;
  118.     LCD12864_RS = ;
  119.     LCD12864_RW = ;
  120.     LCD12864_EN = ;
  121.     LCD12864_EN = ;
  122.  
  123.     dat = LCD12864_DATA_PORT;
  124.     LCD12864_EN = ;
  125.  
  126.     return dat;
  127. }
  128.  
  129. //x:0~7
  130. void SetX(uchar x)
  131. {
  132.     WriteCmdToLCD12864(Add_X + x);
  133. }
  134.  
  135. //y:0~127
  136. void SetY(uchar y)
  137. {
  138.     WriteCmdToLCD12864(Add_Y + y);
  139. }
  140. /*------------------------------------------------------------*/
  141. //z:0~63
  142. void SetZ(uchar z)
  143. {
  144.     WriteCmdToLCD12864(Add_Z + z);
  145. }
  146.  
  147. //    12864显示器初始化
  148. void LCD12864_init(void)
  149. {
  150.     LCDSel();                       
  151.  
  152.     WriteCmdToLCD12864(0x3E);              //    分别初始化左半屏和右半屏
  153.     WriteCmdToLCD12864(0X3F);
  154. }
  155.  
  156. //    清屏
  157. void ClearLCD()
  158. {
  159.     int i, j;
  160.  
  161.     LCDSel();
  162.     for(j = ; j < ; j++) {
  163.         WriteCmdToLCD12864(LCD_ON);
  164.         SetX(j);
  165.         WriteCmdToLCD12864(Add_Y);
  166.         SetZ();
  167.  
  168.         for (i = ; i < ; i++) {
  169.             WriteDatToLCD12864(0x00);
  170.         }
  171.     }
  172. }
  173.  
  174. /*------------------------------------------------------------*/
  175. //左上角第一个点为原点，垂直向下为Y轴，水平向右为X轴
  176. //x:0~63~127    y:0~63
  177. //flag :  0：擦除某个点
  178. //        1：显示某个点
  179. uchar code Tab[] = {
  180.     0x01, 0x02, 0x04, 0x08,
  181.     0x10, 0x20, 0x40, 0x80
  182. };
  183.  
  184. void Dot(char x,char y,bit flag)
  185. {
  186.     unsigned char dat;
  187.     //    y=63-y;
  188.     //    坐标轴的移动和反转
  189.     if (x < ) {
  190.         LCDSel();
  191.         SetX(y / );           //    set the page address
  192.         SetY(x);               //    set the Y adress
  193.         dat = ReadDatFromLCD12864();
  194.  
  195.         if(flag) {
  196.             dat = dat | (Tab[y % ]);
  197.         } else {
  198.             dat= dat & (~(Tab[y % ]));
  199.         }
  200.  
  201.         SetX(y / );
  202.         SetY(x);         //set the Y adress
  203.         WriteDatToLCD12864(dat);
  204.     } else if (x < ) {
  205.         LCDSel();
  206.         SetX(y / );
  207.         SetY(x - );
  208.  
  209.         dat=ReadDatFromLCD12864();
  210.  
  211.         if(flag) {
  212.             dat = dat | (Tab[y % ]);
  213.         } else {
  214.              dat = dat & (~(Tab[y % ]));
  215.         }
  216.  
  217.         SetY(x - );
  218.         WriteDatToLCD12864(dat);
  219.     }
  220. }
  221.  
  222. void swap(uchar *x, uchar *y)
  223. {
  224.     uchar tmp = *x;
  225.  
  226.     *x = *y;
  227.     *y = tmp;
  228. }
  229.  
  230. //    draw a line between point(x1,y1) and point(x2,y2)
  231. //    flag       0: erase the line
  232. //            1: draw a line
  233. void Line(uchar x1, uchar y1, uchar x2, uchar y2, bit flag)
  234. {
  235.     uchar i;
  236.     float k;
  237.  
  238.     if (x1 == x2) {
  239.         if (y1 > y2) {
  240.             swap(&x1, &x2);
  241.             swap(&y1, &y2);
  242.         }
  243.         for (i = y1; i <= y2; i++) {
  244.             Dot(x1, i, flag);
  245.         }
  246.     } else {
  247.         if ( x1 > x2) {
  248.                swap(&x1, &x2);
  249.             swap(&y1, &y2);
  250.          }
  251.  
  252.         k = (float)(y2 - y1) / (float)(x2 - x1);
  253.  
  254.         for (i = ; i < x2 - x1; i++) {
  255.             Dot(x1 + i, (uchar)(y1 + k * i), flag);
  256.         }
  257.     }
  258. }       
  259.  
  260. void rectBoundary(uchar x1, uchar y1, uchar x2, uchar y2, bit flag)
  261. {
  262.        Line(x1, y1, x2, y1, flag);
  263.     Line(x1, y1, x1, y2, flag);
  264.     Line(x2, y1, x2, y2, flag);
  265.     Line(x1, y2, x2, y2, flag);
  266. } 
  267.  
  268. void RectArea(uchar x1, uchar y1, uchar x2, uchar y2, bit flag)
  269. {
  270.     uchar i;
  271.  
  272.     if (x1 > x2) {
  273.         swap(&x1, &x2);
  274.         swap(&y1, &y2);
  275.     }
  276.  
  277.     for (i = ; i <= x2 - x1; i++) {
  278.         Line(x1 + i, y1, x1 + i, y2, flag);
  279.     }
  280.  
  281. }              
  282.  
  283. //    16 * 16
  284. //    x行  0~7
  285. //    y列  0~127
  286. //    flag 0:汉字反白显示
  287. void hz_disp(uchar x, uchar y, uchar n, uchar code * hz, bit flag)
  288. {
  289.     uchar i, j;
  290.     for (j = ; j < n; j++) {
  291.         //显示上半个汉字
  292.         for (i = ; i < ; i++) {
  293.             //点的位置是在左还是右
  294.             if(y +  * j + i < ) {
  295.                 LCDSel();
  296.                 WriteCmdToLCD12864(LCD_ON);
  297.  
  298.                 SetX(x);
  299.                 SetZ();
  300.                 SetY(y+*j+i);
  301.  
  302.                 if(flag) {
  303.                      WriteDatToLCD12864(hz[ * j + i]);
  304.                 } else {
  305.                      WriteDatToLCD12864(~hz[ * j + i]);
  306.                 }
  307.             } else if(y +  * j + i < ) {
  308.                 LCDSel();
  309.                 WriteCmdToLCD12864(LCD_ON);
  310.  
  311.                 SetX(x);
  312.                 SetZ();
  313.                 SetY(y +  * j + i - );
  314.  
  315.                 if(flag) {
  316.                      WriteDatToLCD12864(hz[ * j + i]);
  317.                 } else {
  318.                      WriteDatToLCD12864(~hz[ * j + i]);
  319.                 }
  320.             }
  321.         }
  322.  
  323.         //显示下半个汉字
  324.         for (i = ; i < ; i++) {
  325.             //先判断点是在左还是在右
  326.             if(y +  * j + i -  < ) {
  327.                 if(x +  < ) {                               //最后一行显示上半个字
  328.                     LCDSel();
  329.                     WriteCmdToLCD12864(LCD_ON);
  330.  
  331.                     SetX(x + );
  332.                     SetZ();
  333.                     SetY(y +  * j + i - );
  334.  
  335.                     if(flag) {
  336.                          WriteDatToLCD12864(hz[ * j + i]);
  337.                     } else {
  338.                          WriteDatToLCD12864(~hz[ * j + i]);
  339.                     }
  340.                 }
  341.             } else if (y +  * j + i -  < ) {
  342.                 if(x +  < ) {                           //最后一行
  343.                     LCDSel();
  344.                     WriteCmdToLCD12864(LCD_ON);
  345.  
  346.                     SetX(x + );
  347.                     SetZ();
  348.                     SetY(y +  * j + i -  - );
  349.  
  350.                     if(flag) {
  351.                          WriteDatToLCD12864(hz[ * j + i]);
  352.                     } else {
  353.                          WriteDatToLCD12864(~hz[ * j + i]);
  354.                     }
  355.                 }
  356.             }
  357.         }
  358.     }
  359. }
  360.  
  361. //    x:行0~7
  362. //    y:列0~127
  363. //    asc: 指向标准交换码
  364. //    string: 指向要显示的字符串
  365. //    flag:  0 反白显示
  366. void en_disp(uchar x, uchar y, uchar n, uchar code *asc, uchar *string, bit flag)
  367. {
  368.     uchar i, j, loc;
  369.  
  370.     for (j = ; j < n; j++) {
  371.         loc = string[j] - 0x20;            //    确定要显示的字符在asc表中的位置（乘上16）
  372.  
  373.         //    显示上半个ASCII字符
  374.         for (i = ; i < ; i++) {
  375.             //     点的位置是在左还是右
  376.             if( y +  * j + i < ) {
  377.                 LCDSel();
  378.                 WriteCmdToLCD12864(LCD_ON);
  379.  
  380.                 SetX(x);
  381.                 SetZ();
  382.                 SetY(y +  * j + i);
  383.  
  384.                 if(flag) {
  385.                     WriteDatToLCD12864(asc[ * loc + i]);
  386.                 } else {
  387.                     WriteDatToLCD12864(~asc[ * loc + i]);
  388.                 }
  389.  
  390.             } else if (y +  * j + i < ) {
  391.                 LCDSel();
  392.                 WriteCmdToLCD12864(LCD_ON);
  393.  
  394.                 SetX(x);
  395.                 SetZ();
  396.                 SetY(y +  * j + i - );
  397.  
  398.                 if(flag) {
  399.                     WriteDatToLCD12864(asc[ * loc + i]);
  400.                 } else {
  401.                     WriteDatToLCD12864(~asc[ * loc + i]);
  402.                 }
  403.             }
  404.         }
  405.  
  406.         //    显示下半个ASCII字符
  407.         for (i = ; i < ; i++) {
  408.             //    先判断点是在左还是在右
  409.             if(y +  * j + i -  < ) {
  410.                 if(x +  < ) {                        //    最后一行
  411.                     LCDSel();
  412.                     WriteCmdToLCD12864(LCD_ON);
  413.  
  414.                     SetX(x + );
  415.                     SetZ();
  416.                     SetY(y +  * j + i - );
  417.  
  418.                     if(flag) {
  419.                         WriteDatToLCD12864(asc[ * loc + i]);
  420.                     } else {
  421.                         WriteDatToLCD12864(~asc[ * loc + i]);
  422.                     }
  423.                 }
  424.             } else if (y +  * j + i -  < ) {
  425.                 if(x +  < ) {                       //    最后一行
  426.                     LCDSel();
  427.                     WriteCmdToLCD12864(LCD_ON);
  428.  
  429.                     SetX(x + );
  430.                     SetZ();
  431.                     SetY(y +  * j + i -  - );
  432.  
  433.                     if(flag) {
  434.                         WriteDatToLCD12864(asc[ * loc + i]);
  435.                     } else {
  436.                         WriteDatToLCD12864(~asc[ * loc + i]);
  437.                     }
  438.                 }
  439.             }
  440.         }
  441.     }
  442. }
  1. //    asc.h
  2. //    以下均为汉子和字符的代码，感谢晓奇工作室 www.xiao-qi.com的软件
  3.  
  4. //    难度
  5. unsigned char code gameLevel[]=
  6. {
  7.       0x04,0x34,0xC4,0x04,0xC4,0x3E,0x44,0x20,
  8.       0xF8,0x4F,0x49,0xFA,0x48,0x4C,0x08,0x00,
  9.       0x20,0x10,0x0C,0x03,0x04,0x18,0x00,0x00,
  10.       0xFF,0x22,0x22,0x3F,0x22,0x32,0x20,0x00,
  11.  
  12.       0x00,0x00,0xFC,0x24,0x24,0x24,0xFC,0xA5,
  13.       0xA6,0xA4,0xFC,0x24,0x34,0x26,0x04,0x00,
  14.       0x40,0x20,0x9F,0x80,0x42,0x42,0x26,0x2A,
  15.       0x12,0x2A,0x26,0x42,0x40,0xC0,0x40,0x00
  16. };
  17.  
  18. //    贪吃蛇
  19. unsigned char code snaker[]=
  20. {
  21.       0x00,0x20,0x10,0xD8,0x88,0x8C,0x96,0x97,
  22.       0xDB,0xB2,0x94,0x9C,0xD8,0xB0,0x20,0x20,
  23.       0x00,0x00,0x00,0x9F,0x5F,0x60,0x30,0x3E,
  24.       0x1C,0x60,0xC0,0xDF,0x5F,0x00,0x00,0x00,
  25.  
  26.       0x00,0xFC,0xF8,0x08,0xF8,0xFC,0x48,0x20,
  27.       0xB8,0x9E,0x97,0x92,0x90,0xD0,0x98,0x10,
  28.       0x00,0x1F,0x1F,0x08,0x1F,0x1F,0x00,0x70,
  29.       0xF8,0xCC,0xC6,0xC2,0xC3,0xC1,0xF0,0x40,
  30.  
  31.        0x00,0xF0,0x20,0xFE,0xFC,0x20,0xF0,0x18,
  32.       0x3C,0x08,0xE9,0xCE,0x0C,0x88,0x38,0x1C,
  33.       0x00,0x23,0x62,0x3F,0x3F,0x12,0x3B,0x20,
  34.       0x10,0x08,0x7F,0xFF,0xC3,0xC3,0x79,0x20
  35. };
  36.  
  37. //    游戏结束
  38. unsigned char code theEnd[]=
  39. {
  40.       0x10,0x22,0x6C,0x00,0x08,0x08,0xF9,0x4A,
  41.       0xC8,0x18,0x28,0x27,0xA4,0x66,0x24,0x00,
  42.       0x04,0x04,0xFE,0x41,0x20,0x18,0x07,0x40,
  43.       0x7F,0x02,0x42,0x82,0x7F,0x02,0x02,0x00,
  44.  
  45.       0x00,0x14,0x24,0xC4,0x04,0xE4,0x1C,0x10,
  46.       0x10,0xFF,0x10,0x12,0x14,0xD0,0x10,0x00,
  47.       0x20,0x10,0x08,0x06,0x01,0x02,0x8C,0x40,
  48.       0x20,0x17,0x18,0x24,0x43,0x80,0xE0,0x00,
  49.  
  50.       0x00,0x30,0x28,0xA4,0x63,0x10,0x08,0x48,
  51.       0x48,0x48,0x7F,0x48,0x48,0x4C,0x08,0x00,
  52.       0x00,0x22,0x63,0x22,0x12,0x12,0x00,0xFE,
  53.       0x42,0x42,0x42,0x42,0x42,0xFF,0x02,0x00,
  54.  
  55.       0x04,0x04,0xE4,0x24,0x24,0x24,0x24,0xFF,
  56.       0x24,0x24,0x24,0x24,0xF4,0x26,0x04,0x00,
  57.       0x40,0x40,0x27,0x22,0x12,0x0A,0x06,0xFF,
  58.       0x06,0x0A,0x12,0x12,0x27,0x60,0x20,0x00
  59. };
  60.  
  61. //    成都理工大学工程技术学院
  62. unsigned char code mySchool[][] = {
  63.       0x00,0x00,0xF8,0x88,0x88,0x88,0x88,0x08,
  64.       0x08,0xFF,0x08,0x09,0x0A,0xC8,0x08,0x00,
  65.       0x80,0x60,0x1F,0x00,0x10,0x20,0x1F,0x80,
  66.       0x40,0x21,0x16,0x18,0x26,0x41,0xF8,0x00,
  67.  
  68.        0x20,0x24,0x24,0xA4,0x7F,0x24,0x34,0x28,
  69.       0x26,0x20,0xFE,0x02,0x22,0xDA,0x06,0x00,
  70.       0x04,0x02,0xFF,0x49,0x49,0x49,0x49,0xFF,
  71.       0x00,0x00,0xFF,0x08,0x10,0x08,0x07,0x00,
  72.  
  73.        0x04,0x84,0x84,0xFC,0x84,0x84,0x00,0xFE,
  74.       0x92,0x92,0xFE,0x92,0x92,0xFE,0x00,0x00,
  75.       0x20,0x60,0x20,0x1F,0x10,0x10,0x40,0x44,
  76.       0x44,0x44,0x7F,0x44,0x44,0x44,0x40,0x00,
  77.  
  78.        0x00,0x04,0x04,0x04,0x04,0x04,0x04,0xFC,
  79.       0x04,0x04,0x04,0x04,0x04,0x04,0x00,0x00,
  80.       0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x3F,
  81.       0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x00,
  82.  
  83.        0x20,0x20,0x20,0x20,0x20,0x20,0x20,0xFF,
  84.       0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x00,
  85.       0x80,0x80,0x40,0x20,0x10,0x0C,0x03,0x00,
  86.       0x03,0x0C,0x10,0x20,0x40,0x80,0x80,0x00,
  87.  
  88.        0x40,0x30,0x11,0x96,0x90,0x90,0x91,0x96,
  89.       0x90,0x90,0x98,0x14,0x13,0x50,0x30,0x00,
  90.       0x04,0x04,0x04,0x04,0x04,0x44,0x84,0x7E,
  91.       0x06,0x05,0x04,0x04,0x04,0x04,0x04,0x00,
  92.  
  93.       0x00,0x04,0x04,0x04,0x04,0x04,0x04,0xFC,
  94.       0x04,0x04,0x04,0x04,0x04,0x04,0x00,0x00,
  95.       0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x3F,
  96.       0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x00,
  97.  
  98.        0x24,0x24,0xA4,0xFE,0x23,0x22,0x00,0x3E,
  99.       0x22,0x22,0x22,0x22,0x22,0x3E,0x00,0x00,
  100.       0x08,0x06,0x01,0xFF,0x01,0x06,0x40,0x49,
  101.       0x49,0x49,0x7F,0x49,0x49,0x49,0x41,0x00,
  102.  
  103.        0x10,0x10,0x10,0xFF,0x10,0x90,0x08,0x88,
  104.       0x88,0x88,0xFF,0x88,0x88,0x88,0x08,0x00,
  105.       0x04,0x44,0x82,0x7F,0x01,0x80,0x80,0x40,
  106.       0x43,0x2C,0x10,0x28,0x46,0x81,0x80,0x00,
  107.  
  108.        0x00,0x10,0x10,0x10,0x10,0xD0,0x30,0xFF,
  109.       0x30,0xD0,0x12,0x1C,0x10,0x10,0x00,0x00,
  110.       0x10,0x08,0x04,0x02,0x01,0x00,0x00,0xFF,
  111.       0x00,0x00,0x01,0x02,0x04,0x08,0x10,0x00,
  112.  
  113.        0x40,0x30,0x11,0x96,0x90,0x90,0x91,0x96,
  114.       0x90,0x90,0x98,0x14,0x13,0x50,0x30,0x00,
  115.       0x04,0x04,0x04,0x04,0x04,0x44,0x84,0x7E,
  116.       0x06,0x05,0x04,0x04,0x04,0x04,0x04,0x00,
  117.  
  118.       0x00,0xFE,0x22,0x5A,0x86,0x10,0x0C,0x24,
  119.       0x24,0x25,0x26,0x24,0x24,0x14,0x0C,0x00,
  120.       0x00,0xFF,0x04,0x08,0x07,0x80,0x41,0x31,
  121.       0x0F,0x01,0x01,0x3F,0x41,0x41,0x71,0x00
  122. };
  123.  
  124. //    毕业设计
  125. unsigned char code myName[][] = {
  126.        0x40,0x48,0x48,0x48,0xFF,0x48,0x48,0x00,
  127.       0x04,0x08,0x30,0xC0,0x30,0x0E,0x00,0x00,
  128.       0x80,0x60,0x1F,0x20,0x7F,0x44,0x44,0x40,
  129.       0x48,0x44,0x43,0x40,0x43,0x4C,0x40,0x00,
  130.  
  131.        0x20,0xC2,0x0C,0x80,0x84,0xA4,0xA4,0xAF,
  132.       0xA4,0xF4,0xA4,0xAF,0xA4,0xE4,0x84,0x00,
  133.       0x04,0x04,0x7E,0x81,0x40,0x3A,0x22,0x1A,
  134.       0x02,0xFF,0x0A,0x32,0x02,0xFB,0x00,0x00,
  135.  
  136.       0x00,0x00,0xFF,0x88,0x88,0x48,0x48,0x00,
  137.       0x7F,0x88,0x84,0x84,0x82,0xE0,0x00,0x00,
  138.       0x04,0x04,0x05,0x04,0x04,0x04,0x04,0xFF,
  139.       0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x00,
  140.  
  141.        0x00,0x10,0x60,0x80,0x00,0xFF,0x00,0x00,
  142.       0x00,0xFF,0x00,0x00,0xC0,0x30,0x00,0x00,
  143.       0x40,0x40,0x40,0x43,0x40,0x7F,0x40,0x40,
  144.       0x40,0x7F,0x42,0x41,0x40,0x40,0x40,0x00,
  145.  
  146.        0x40,0x40,0x42,0xCC,0x00,0x40,0xA0,0x9E,
  147.       0x82,0x82,0x82,0x9E,0xA0,0x20,0x20,0x00,
  148.       0x00,0x00,0x00,0x3F,0x90,0x88,0x40,0x43,
  149.       0x2C,0x10,0x28,0x46,0x41,0x80,0x80,0x00,
  150.  
  151.        0x40,0x40,0x42,0xCC,0x00,0x40,0x40,0x40,
  152.       0x40,0xFF,0x40,0x40,0x40,0x40,0x40,0x00,
  153.       0x00,0x00,0x00,0x7F,0x20,0x10,0x00,0x00,
  154.       0x00,0xFF,0x00,0x00,0x00,0x00,0x00,0x00
  155. };
  156.  
  157. //    ASCII值
  158. unsigned char code Asc[] =
  159. {
  160.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  // - -
  161.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  162.  
  163.     0x00,0x00,0x38,0xFC,0xFC,0x38,0x00,0x00,  // -!-
  164.     0x00,0x00,0x00,0x0D,0x0D,0x00,0x00,0x00,
  165.  
  166.     0x00,0x0E,0x1E,0x00,0x00,0x1E,0x0E,0x00,  // -"-
  167.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  168.  
  169.     0x20,0xF8,0xF8,0x20,0xF8,0xF8,0x20,0x00,  // -#-
  170.     0x02,0x0F,0x0F,0x02,0x0F,0x0F,0x02,0x00,
  171.  
  172.     0x38,0x7C,0x44,0x47,0x47,0xCC,0x98,0x00,  // -$-
  173.     0x03,0x06,0x04,0x1C,0x1C,0x07,0x03,0x00,
  174.  
  175.     0x30,0x30,0x00,0x80,0xC0,0x60,0x30,0x00,  // -%-
  176.     0x0C,0x06,0x03,0x01,0x00,0x0C,0x0C,0x00,
  177.  
  178.     0x80,0xD8,0x7C,0xE4,0xBC,0xD8,0x40,0x00,  // -&-
  179.     0x07,0x0F,0x08,0x08,0x07,0x0F,0x08,0x00,
  180.  
  181.     0x00,0x10,0x1E,0x0E,0x00,0x00,0x00,0x00,  // -'-
  182.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  183.  
  184.     0x00,0x00,0xF0,0xF8,0x0C,0x04,0x00,0x00,  // -(-
  185.     0x00,0x00,0x03,0x07,0x0C,0x08,0x00,0x00,
  186.  
  187.     0x00,0x00,0x04,0x0C,0xF8,0xF0,0x00,0x00,  // -)-
  188.     0x00,0x00,0x08,0x0C,0x07,0x03,0x00,0x00,
  189.  
  190.     0x80,0xA0,0xE0,0xC0,0xC0,0xE0,0xA0,0x80,  // -*-
  191.     0x00,0x02,0x03,0x01,0x01,0x03,0x02,0x00,
  192.  
  193.     0x00,0x80,0x80,0xE0,0xE0,0x80,0x80,0x00,  // -+-
  194.     0x00,0x00,0x00,0x03,0x03,0x00,0x00,0x00,
  195.  
  196.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  // -,-
  197.     0x00,0x00,0x10,0x1E,0x0E,0x00,0x00,0x00,
  198.  
  199.     0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x00,  // ---
  200.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  201.  
  202.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  // -.-
  203.     0x00,0x00,0x00,0x0C,0x0C,0x00,0x00,0x00,
  204.  
  205.     0x00,0x00,0x00,0x80,0xC0,0x60,0x30,0x00,  // -/-
  206.     0x0C,0x06,0x03,0x01,0x00,0x00,0x00,0x00,
  207.  
  208.     0xF8,0xFC,0x04,0xC4,0x24,0xFC,0xF8,0x00,  // -0-
  209.     0x07,0x0F,0x09,0x08,0x08,0x0F,0x07,0x00,
  210.  
  211.     0x00,0x10,0x18,0xFC,0xFC,0x00,0x00,0x00,  // -1-
  212.     0x00,0x08,0x08,0x0F,0x0F,0x08,0x08,0x00,
  213.  
  214.     0x08,0x0C,0x84,0xC4,0x64,0x3C,0x18,0x00,  // -2-
  215.     0x0E,0x0F,0x09,0x08,0x08,0x0C,0x0C,0x00,
  216.  
  217.     0x08,0x0C,0x44,0x44,0x44,0xFC,0xB8,0x00,  // -3-
  218.     0x04,0x0C,0x08,0x08,0x08,0x0F,0x07,0x00,
  219.  
  220.     0xC0,0xE0,0xB0,0x98,0xFC,0xFC,0x80,0x00,  // -4-
  221.     0x00,0x00,0x00,0x08,0x0F,0x0F,0x08,0x00,
  222.  
  223.     0x7C,0x7C,0x44,0x44,0xC4,0xC4,0x84,0x00,  // -5-
  224.     0x04,0x0C,0x08,0x08,0x08,0x0F,0x07,0x00,
  225.  
  226.     0xF0,0xF8,0x4C,0x44,0x44,0xC0,0x80,0x00,  // -6-
  227.     0x07,0x0F,0x08,0x08,0x08,0x0F,0x07,0x00,
  228.  
  229.     0x0C,0x0C,0x04,0x84,0xC4,0x7C,0x3C,0x00,  // -7-
  230.     0x00,0x00,0x0F,0x0F,0x00,0x00,0x00,0x00,
  231.  
  232.     0xB8,0xFC,0x44,0x44,0x44,0xFC,0xB8,0x00,  // -8-
  233.     0x07,0x0F,0x08,0x08,0x08,0x0F,0x07,0x00,
  234.  
  235.     0x38,0x7C,0x44,0x44,0x44,0xFC,0xF8,0x00,  // -9-
  236.     0x00,0x08,0x08,0x08,0x0C,0x07,0x03,0x00,
  237.  
  238.     0x00,0x00,0x00,0x30,0x30,0x00,0x00,0x00,  // -:-
  239.     0x00,0x00,0x00,0x06,0x06,0x00,0x00,0x00,
  240.  
  241.     0x00,0x00,0x00,0x30,0x30,0x00,0x00,0x00,  // -;-
  242.     0x00,0x00,0x08,0x0E,0x06,0x00,0x00,0x00,
  243.  
  244.     0x00,0x80,0xC0,0x60,0x30,0x18,0x08,0x00,  // -<-
  245.     0x00,0x00,0x01,0x03,0x06,0x0C,0x08,0x00,
  246.  
  247.     0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x00,  // -=-
  248.     0x02,0x02,0x02,0x02,0x02,0x02,0x02,0x00,
  249.  
  250.     0x00,0x08,0x18,0x30,0x60,0xC0,0x80,0x00,  // ->-
  251.     0x00,0x08,0x0C,0x06,0x03,0x01,0x00,0x00,
  252.  
  253.     0x18,0x1C,0x04,0xC4,0xE4,0x3C,0x18,0x00,  // -?-
  254.     0x00,0x00,0x00,0x0D,0x0D,0x00,0x00,0x00,
  255.  
  256.     0xF0,0xF8,0x08,0xC8,0xC8,0xF8,0xF0,0x00,  // -@-
  257.     0x07,0x0F,0x08,0x0B,0x0B,0x0B,0x01,0x00,
  258.  
  259.     0xE0,0xF0,0x98,0x8C,0x98,0xF0,0xE0,0x00,  // -A-
  260.     0x0F,0x0F,0x00,0x00,0x00,0x0F,0x0F,0x00,
  261.  
  262.     0x04,0xFC,0xFC,0x44,0x44,0xFC,0xB8,0x00,  // -B-
  263.     0x08,0x0F,0x0F,0x08,0x08,0x0F,0x07,0x00,
  264.  
  265.     0xF0,0xF8,0x0C,0x04,0x04,0x0C,0x18,0x00,  // -C-
  266.     0x03,0x07,0x0C,0x08,0x08,0x0C,0x06,0x00,
  267.  
  268.     0x04,0xFC,0xFC,0x04,0x0C,0xF8,0xF0,0x00,  // -D-
  269.     0x08,0x0F,0x0F,0x08,0x0C,0x07,0x03,0x00,
  270.  
  271.     0x04,0xFC,0xFC,0x44,0xE4,0x0C,0x1C,0x00,  // -E-
  272.     0x08,0x0F,0x0F,0x08,0x08,0x0C,0x0E,0x00,
  273.  
  274.     0x04,0xFC,0xFC,0x44,0xE4,0x0C,0x1C,0x00,  // -F-
  275.     0x08,0x0F,0x0F,0x08,0x00,0x00,0x00,0x00,
  276.  
  277.     0xF0,0xF8,0x0C,0x84,0x84,0x8C,0x98,0x00,  // -G-
  278.     0x03,0x07,0x0C,0x08,0x08,0x07,0x0F,0x00,
  279.  
  280.     0xFC,0xFC,0x40,0x40,0x40,0xFC,0xFC,0x00,  // -H-
  281.     0x0F,0x0F,0x00,0x00,0x00,0x0F,0x0F,0x00,
  282.  
  283.     0x00,0x00,0x04,0xFC,0xFC,0x04,0x00,0x00,  // -I-
  284.     0x00,0x00,0x08,0x0F,0x0F,0x08,0x00,0x00,
  285.  
  286.     0x00,0x00,0x00,0x04,0xFC,0xFC,0x04,0x00,  // -J-
  287.     0x07,0x0F,0x08,0x08,0x0F,0x07,0x00,0x00,
  288.  
  289.     0x04,0xFC,0xFC,0xC0,0xF0,0x3C,0x0C,0x00,  // -K-
  290.     0x08,0x0F,0x0F,0x00,0x01,0x0F,0x0E,0x00,
  291.  
  292.     0x04,0xFC,0xFC,0x04,0x00,0x00,0x00,0x00,  // -L-
  293.     0x08,0x0F,0x0F,0x08,0x08,0x0C,0x0E,0x00,
  294.  
  295.     0xFC,0xFC,0x38,0x70,0x38,0xFC,0xFC,0x00,  // -M-
  296.     0x0F,0x0F,0x00,0x00,0x00,0x0F,0x0F,0x00,
  297.  
  298.     0xFC,0xFC,0x38,0x70,0xE0,0xFC,0xFC,0x00,  // -N-
  299.     0x0F,0x0F,0x00,0x00,0x00,0x0F,0x0F,0x00,
  300.  
  301.     0xF0,0xF8,0x0C,0x04,0x0C,0xF8,0xF0,0x00,  // -O-
  302.     0x03,0x07,0x0C,0x08,0x0C,0x07,0x03,0x00,
  303.  
  304.     0x04,0xFC,0xFC,0x44,0x44,0x7C,0x38,0x00,  // -P-
  305.     0x08,0x0F,0x0F,0x08,0x00,0x00,0x00,0x00,
  306.  
  307.     0xF8,0xFC,0x04,0x04,0x04,0xFC,0xF8,0x00,  // -Q-
  308.     0x07,0x0F,0x08,0x0E,0x3C,0x3F,0x27,0x00,
  309.  
  310.     0x04,0xFC,0xFC,0x44,0xC4,0xFC,0x38,0x00,  // -R-
  311.     0x08,0x0F,0x0F,0x00,0x00,0x0F,0x0F,0x00,
  312.  
  313.     0x18,0x3C,0x64,0x44,0xC4,0x9C,0x18,0x00,  // -S-
  314.     0x06,0x0E,0x08,0x08,0x08,0x0F,0x07,0x00,
  315.  
  316.     0x00,0x1C,0x0C,0xFC,0xFC,0x0C,0x1C,0x00,  // -T-
  317.     0x00,0x00,0x08,0x0F,0x0F,0x08,0x00,0x00,
  318.  
  319.     0xFC,0xFC,0x00,0x00,0x00,0xFC,0xFC,0x00,  // -U-
  320.     0x07,0x0F,0x08,0x08,0x08,0x0F,0x07,0x00,
  321.  
  322.     0xFC,0xFC,0x00,0x00,0x00,0xFC,0xFC,0x00,  // -V-
  323.     0x01,0x03,0x06,0x0C,0x06,0x03,0x01,0x00,
  324.  
  325.     0xFC,0xFC,0x00,0x80,0x00,0xFC,0xFC,0x00,  // -W-
  326.     0x03,0x0F,0x0E,0x03,0x0E,0x0F,0x03,0x00,
  327.  
  328.     0x0C,0x3C,0xF0,0xC0,0xF0,0x3C,0x0C,0x00,  // -X-
  329.     0x0C,0x0F,0x03,0x00,0x03,0x0F,0x0C,0x00,
  330.  
  331.     0x00,0x3C,0x7C,0xC0,0xC0,0x7C,0x3C,0x00,  // -Y-
  332.     0x00,0x00,0x08,0x0F,0x0F,0x08,0x00,0x00,
  333.  
  334.     0x1C,0x0C,0x84,0xC4,0x64,0x3C,0x1C,0x00,  // -Z-
  335.     0x0E,0x0F,0x09,0x08,0x08,0x0C,0x0E,0x00,
  336.  
  337.     0x00,0x00,0xFC,0xFC,0x04,0x04,0x00,0x00,  // -[-
  338.     0x00,0x00,0x0F,0x0F,0x08,0x08,0x00,0x00,
  339.  
  340.     0x38,0x70,0xE0,0xC0,0x80,0x00,0x00,0x00,  // -\-
  341.     0x00,0x00,0x00,0x01,0x03,0x07,0x0E,0x00,
  342.  
  343.     0x00,0x00,0x04,0x04,0xFC,0xFC,0x00,0x00,  // -]-
  344.     0x00,0x00,0x08,0x08,0x0F,0x0F,0x00,0x00,
  345.  
  346.     0x08,0x0C,0x06,0x03,0x06,0x0C,0x08,0x00,  // -^-
  347.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  348.  
  349.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  // -_-
  350.     0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
  351.  
  352.     0x00,0x00,0x03,0x07,0x04,0x00,0x00,0x00,  // -`-
  353.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  354.  
  355.     0x00,0xA0,0xA0,0xA0,0xE0,0xC0,0x00,0x00,  // -a-
  356.     0x07,0x0F,0x08,0x08,0x07,0x0F,0x08,0x00,
  357.  
  358.     0x04,0xFC,0xFC,0x20,0x60,0xC0,0x80,0x00,  // -b-
  359.     0x08,0x0F,0x07,0x08,0x08,0x0F,0x07,0x00,
  360.  
  361.     0xC0,0xE0,0x20,0x20,0x20,0x60,0x40,0x00,  // -c-
  362.     0x07,0x0F,0x08,0x08,0x08,0x0C,0x04,0x00,
  363.  
  364.     0x80,0xC0,0x60,0x24,0xFC,0xFC,0x00,0x00,  // -d-
  365.     0x07,0x0F,0x08,0x08,0x07,0x0F,0x08,0x00,
  366.  
  367.     0xC0,0xE0,0xA0,0xA0,0xA0,0xE0,0xC0,0x00,  // -e-
  368.     0x07,0x0F,0x08,0x08,0x08,0x0C,0x04,0x00,
  369.  
  370.     0x40,0xF8,0xFC,0x44,0x0C,0x18,0x00,0x00,  // -f-
  371.     0x08,0x0F,0x0F,0x08,0x00,0x00,0x00,0x00,
  372.  
  373.     0xC0,0xE0,0x20,0x20,0xC0,0xE0,0x20,0x00,  // -g-
  374.     0x27,0x6F,0x48,0x48,0x7F,0x3F,0x00,0x00,
  375.  
  376.     0x04,0xFC,0xFC,0x40,0x20,0xE0,0xC0,0x00,  // -h-
  377.     0x08,0x0F,0x0F,0x00,0x00,0x0F,0x0F,0x00,
  378.  
  379.     0x00,0x00,0x20,0xEC,0xEC,0x00,0x00,0x00,  // -i-
  380.     0x00,0x00,0x08,0x0F,0x0F,0x08,0x00,0x00,
  381.  
  382.     0x00,0x00,0x00,0x00,0x20,0xEC,0xEC,0x00,  // -j-
  383.     0x00,0x30,0x70,0x40,0x40,0x7F,0x3F,0x00,
  384.  
  385.     0x04,0xFC,0xFC,0x80,0xC0,0x60,0x20,0x00,  // -k-
  386.     0x08,0x0F,0x0F,0x01,0x03,0x0E,0x0C,0x00,
  387.  
  388.     0x00,0x00,0x04,0xFC,0xFC,0x00,0x00,0x00,  // -l-
  389.     0x00,0x00,0x08,0x0F,0x0F,0x08,0x00,0x00,
  390.  
  391.     0xE0,0xE0,0x60,0xC0,0x60,0xE0,0xC0,0x00,  // -m-
  392.     0x0F,0x0F,0x00,0x0F,0x00,0x0F,0x0F,0x00,
  393.  
  394.     0x20,0xE0,0xC0,0x20,0x20,0xE0,0xC0,0x00,  // -n-
  395.     0x00,0x0F,0x0F,0x00,0x00,0x0F,0x0F,0x00,
  396.  
  397.     0xC0,0xE0,0x20,0x20,0x20,0xE0,0xC0,0x00,  // -o-
  398.     0x07,0x0F,0x08,0x08,0x08,0x0F,0x07,0x00,
  399.  
  400.     0x20,0xE0,0xC0,0x20,0x20,0xE0,0xC0,0x00,  // -p-
  401.     0x40,0x7F,0x7F,0x48,0x08,0x0F,0x07,0x00,
  402.  
  403.     0xC0,0xE0,0x20,0x20,0xC0,0xE0,0x20,0x00,  // -q-
  404.     0x07,0x0F,0x08,0x48,0x7F,0x7F,0x40,0x00,
  405.  
  406.     0x20,0xE0,0xC0,0x60,0x20,0x60,0xC0,0x00,  // -r-
  407.     0x08,0x0F,0x0F,0x08,0x00,0x00,0x00,0x00,
  408.  
  409.     0x40,0xE0,0xA0,0x20,0x20,0x60,0x40,0x00,  // -s-
  410.     0x04,0x0C,0x09,0x09,0x0B,0x0E,0x04,0x00,
  411.  
  412.     0x20,0x20,0xF8,0xFC,0x20,0x20,0x00,0x00,  // -t-
  413.     0x00,0x00,0x07,0x0F,0x08,0x0C,0x04,0x00,
  414.  
  415.     0xE0,0xE0,0x00,0x00,0xE0,0xE0,0x00,0x00,  // -u-
  416.     0x07,0x0F,0x08,0x08,0x07,0x0F,0x08,0x00,
  417.  
  418.     0x00,0xE0,0xE0,0x00,0x00,0xE0,0xE0,0x00,  // -v-
  419.     0x00,0x03,0x07,0x0C,0x0C,0x07,0x03,0x00,
  420.  
  421.     0xE0,0xE0,0x00,0x00,0x00,0xE0,0xE0,0x00,  // -w-
  422.     0x07,0x0F,0x0C,0x07,0x0C,0x0F,0x07,0x00,
  423.  
  424.     0x20,0x60,0xC0,0x80,0xC0,0x60,0x20,0x00,  // -x-
  425.     0x08,0x0C,0x07,0x03,0x07,0x0C,0x08,0x00,
  426.  
  427.     0xE0,0xE0,0x00,0x00,0x00,0xE0,0xE0,0x00,  // -y-
  428.     0x47,0x4F,0x48,0x48,0x68,0x3F,0x1F,0x00,
  429.  
  430.     0x60,0x60,0x20,0xA0,0xE0,0x60,0x20,0x00,  // -z-
  431.     0x0C,0x0E,0x0B,0x09,0x08,0x0C,0x0C,0x00,
  432.  
  433.     0x00,0x40,0x40,0xF8,0xBC,0x04,0x04,0x00,  // -{-
  434.     0x00,0x00,0x00,0x07,0x0F,0x08,0x08,0x00,
  435.  
  436.     0x00,0x00,0x00,0xBC,0xBC,0x00,0x00,0x00,  // -|-
  437.     0x00,0x00,0x00,0x0F,0x0F,0x00,0x00,0x00,
  438.  
  439.     0x00,0x04,0x04,0xBC,0xF8,0x40,0x40,0x00,  // -}-
  440.     0x00,0x08,0x08,0x0F,0x07,0x00,0x00,0x00,
  441.  
  442.     0x08,0x0C,0x04,0x0C,0x08,0x0C,0x04,0x00,  // -~-
  443.     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  444.  
  445.     0x80,0xC0,0x60,0x30,0x60,0xC0,0x80,0x00,  // --
  446.     0x07,0x07,0x04,0x04,0x04,0x07,0x07,0x00,
  447. };

　　

基于AT89C51单片机的贪吃蛇电子游戏（仿真）的更多相关文章

  1. 基于EasyX库的贪吃蛇游戏——C语言实现

    接触编程有段时间了,一直想学习怎么去写个游戏来练练手.在看了B站上的教学终于可以自己试试怎么实现贪吃蛇这个游戏了.好了,废话不多说,我们来看看如何用EasyX库来实现贪吃蛇. 一.准备 工具vc++6 ...

  2. 基于spec探路者团队贪吃蛇作品的评论

    1 运动功能 由以上两图贪吃蛇的位置不同可知,运动功能实现.并且我能够通过使用键盘上的上下左右方位键控制蛇的移动方向,蛇在控制的方向上进行直线前进. 2 吃食物功能 以上两图可知吃食物功能实现.当界面 ...

  3. 基于AT89C51单片机烟雾传感器

    #include <reg51.h> #include <stdio.h> #define uchar unsigned char //宏定义无符号字符型 #define ui ...

  4. 基于NABCD评论探路者团队贪吃蛇作品及改进建议

    1.根据(不限于)NABCD评论作品的选题 N:随着人们生活压力越来越大,需要去去缓解压力,并且也需要不断进步,学习英语知识. A:它是基于java开发的一款软件,采用逐个吃字母,加长蛇身,增强记忆的 ...

  5. 基于React的贪吃蛇游戏的设计与实现

    代码地址如下:http://www.demodashi.com/demo/11818.html 贪吃蛇小游戏(第二版) 一年半前层用react写过贪吃蛇小游戏https://github.com/ca ...

  6. 小项目特供 贪吃蛇游戏（基于C语言）

    C语言写贪吃蛇本来是打算去年暑假写的,结果因为ACM集训给耽搁了,因此借寒假的两天功夫写了这个贪吃蛇小项目,顺带把C语言重温了一次. 是发表博客的前一天开始写的,一共写了三个版本,第一天写了第一版,第 ...

  7. AI贪吃蛇前瞻——基于Dijkstra算法的最短路径问题

    在贪吃蛇流程结构优化之后,我又不满足于亲自操刀控制这条蠢蠢的蛇,干脆就让它升级成AI,我来看程序自己玩,哈哈. 一.Dijkstra算法原理 作为一种广为人知的单源最短路径算法,Dijkstra用于求 ...

  8. 贪吃蛇—C—基于easyx图形库(下):从画图程序到贪吃蛇【自带穿墙术】

    上节我们用方向控制函数写了个小画图程序,它虽然简单好玩,但我们不应该止步于此.革命尚未成功,同志还需努力. 开始撸代码之前,我们先理清一下思路.和前面画图程序不同,贪吃蛇可以有很多节,可以用一个足够大 ...

  9. 贪吃蛇—C—基于easyx图形库(上)：基本控制函数实现 画图程序

    自从学了c语言,就一直想做个游戏,今天将之付之行动,第一次写的特别烂,各种bug:就不贴了.今天网上看了好几个贪吃蛇,重新写了一次,做出来的效果还可以. p.s.  easyx图形库是为了方便图形学教 ...

随机推荐

  1. Node的express框架安装

    第一步:在cmd命令行下执行npm install -g express,安装全局的express. 第二步:在命令行中输入express,如果出现express不是内部命令时, 输入npm inst ...

  2. Python 实现Windows开机运行某软件

    开机运行:随系统启动的应用程序,当系统启动之后会自动加载的应用 在注册表中添加启动项便可实现开机启动. 代码如下: # -*- coding:utf-8 -*- import win32api imp ...

  3. maven权威指南学习笔记（二）——安装、运行、获取帮助

    这部分在网上很容易找到详细教程,这里就略写了. 基础:系统有配置好的jdk,通过 命令行 java -version,有类似下面的提示,表示java环境以配好 下载maven:官网 http://ma ...

  4. 数据结构0103汉诺塔&八皇后

    主要是从汉诺塔及八皇后问题体会递归算法. 汉诺塔: #include <stdio.h> void move(int n, char x,char y, char z){ if(1==n) ...

  5. Tween Animation----Translate位置移动动画

    布局: 在res/下新建一个anim文件夹用来保存动画xml文件 新建一个translate文件 代码: <?xml version="1.0" encoding=" ...

  6. spring-aop学习【基于注解】

    我个人觉得,这个好像就是用在定制日志输出上,和log4j很像. 用途: 如果业务方法调用每一步都需要详细的日志,那就用这个吧 好处就是: 方便维护,只包含业务代码 下面开始说明: 所需要的jar包: ...

  7. 转：WaitForSingleObject()函数、WaitForMultipleObject()函数

    http://blog.csdn.net/xiaobai1593/article/details/6672193 在多线程下面,有时候我们会希望等待某一线程完成了再继续做其他事情,要实现这个目的,可以 ...

  8. 最详细易懂的CRC-16校验原理（附源程序）(转)

    最详细易懂的CRC-16校验原理(附源程序) from:http://www.openhw.org/chudonganjin/blog/12-08/230184_515e6.html 最详细易懂的CR ...

  9. appzapper注册码

    Appzapper for mac是MAC OS上的一款软件,可以非常方便的卸载自己不喜欢的软件,非常的快速便捷,卸载的时候不会有残留. 下载地址:http://www.pc6.com/mac/114 ...

  10. svn客户端重新设置用户名和密码

    在第一次使用TortoiseSVN从服务器CheckOut的时候,会要求输入用户名和密码,这时输入框下面有个选项是保存认证信息,如果选了这个选项,那么以后就不用每次都输入一遍用户名密码了. 不过,如果 ...