• 02 贪吃蛇

    前言

    呵呵 这是不知道 在哪里看到的 别人做的一个贪吃蛇 

    因此 也把我 之前的 贪吃蛇 移植上来了 

    当然 这个不过是为了 简单的入门了解, 呵呵 

    然后 c++版本的贪吃蛇 需要先移植成 c 版本, 然后 再根据 单片机相关 设计调整

    比如 led 点阵的输出, 比如 c99 语法的一些不兼容 

    主控制程序

    整体程序的结构如下, Test02Snake 是主控制程序, utils 是公共的东西 

    snake 是贪吃蛇的相关实现 

    Test02Snake.c

    1.  
    2. #include "utils.h"
    3. #include "snake.h"
    4.  
    5.  
    6. /**
    7.  * main related
    8.  */
    9. long counter = 1;
    10.  
    11. u8 gled_end[8] = {0x38,0x7C,0x7E,0x3F,0x3F,0x7E,0x7C,0x38};
    12.  
    13. void main() {
    14.  
    15.     int i;
    16.     u8 xList[8] = {1, 2, 3, 4, 6}, yList[8] = {1, 2, 3, 4, 7};
    17.     u8 word[8];
    18.  
    19. 	Snake snakeIns;
    20.  
    21. 	Snake *snake = &snakeIns;
    22.     // snake = snakeInit();
    23.  
    24. 	snakeInit(snake);
    25.     snake->init(snake);
    26.     snake->setMap(snake);
    27.     snake->createFood(snake);
    28. 	ledToggle(6);
    29. 			   
    30.  
    31.     while (1) {
    32.  
    33. //  		snake->print(snake);
    34.         snake->running(snake, counter);
    35.         if (snake->isOver(snake))
    36.             break;
    37.  
    38. 		delay_ms(5);
    39.         counter++;
    40.  
    41.     }
    42.  
    43.     while(1) {
    44.         lightTubeByInt(snake->grade);
    45.         printLedWord(8, gled_end);
    46.     }
    47.  
    48. }
    49.  
    50.

    utils.h

    1. #ifndef _utils_H
    2. #define _utils_H
    3.  
    4. #include "reg52.h"
    5. #include "stdlib.h"
    6.  
    7.  
    8. typedef unsigned int u16;
    9. typedef unsigned char u8;
    10. typedef unsigned long u32;
    11.  
    12. // led dot related 
    13. sbit SHIFT_REG_INPUT = P3 ^6;
    14. sbit STORE_REG_INPUT = P3 ^5;
    15. sbit SERIAL_PORT_INPUT = P3 ^4;
    16. #define LEDDZ_COL_PORT P0
    17.  
    18.  
    19. // tube related 
    20. sbit LSA=P2^2;
    21. sbit LSB=P2^3;
    22. sbit LSC=P2^4;
    23. #define SMG_A_DP_PORT	P0
    24.  
    25.  
    26. // keyboard matrix related
    27. #define KEY_MATRIX_PORT	P1
    28.  
    29.  
    30. /**
    31.  * delay $delayIn10Us us
    32.  * @param ten_us
    33.  */
    34. void delay_10us(u16 ten_us);
    35.  
    36. /**
    37.  * delay $delayInMs ms
    38.  * @param ms
    39.  */
    40. void delay_ms(u16 ms);
    41.  
    42. /**
    43.  * control led[pos] on/off
    44.  * @param pos
    45.  * @param on
    46.  */
    47. void ledCtl(u8 pos, u8 on);
    48.  
    49. /**
    50.  * toggle led[pos] on/off
    51.  * @param pos
    52.  * @param on
    53.  */
    54. void ledToggle(u8 pos);
    55.  
    56. /**
    57.  * random number 
    58.  * @param seed
    59.  * @param max
    60.  * @param min
    61.  */
    62. unsigned int randomInt(unsigned int seed, unsigned int max, unsigned int min);
    63.  
    64. /**
    65.  * printLedWord
    66.  *
    67.  * @param wordLength
    68.  * @param word
    69.  */
    70. void printLedWord(int wordLength, u8 *word);
    71.  
    72. /**
    73.  * lightTube
    74.  * @param word
    75.  */
    76. void lightTube(u8 *word);
    77.  
    78. /**
    79.  * lightTubeByInt
    80.  * @param word
    81.  */
    82. void lightTubeByInt(u16 value);
    83.  
    84. /**
    85.  * lightTubeByIntNTimes
    86.  * @param word
    87.  */
    88. void lightTubeByIntSeconds(u16 value, u16 s);
    89.  
    90. /**
    91.  * keyboardMatrixFlipScan
    92.  * @return
    93.  */
    94. u8 keyboardMatrixFlipScan(void);
    95.  
    96. #endif

    utils.c

    1.  
    2.  
    3. #include "utils.h"
    4.  
    5.  
    6.  
    7. u8 gled_col[8] = {0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xfe};
    8.  
    9. u8 gsmg_code[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
    10.  
    11.  
    12. void hc595_write_data(u8 dat);
    13.  
    14.  
    15. void delay_10us(u16 ten_us) {
    16.     while (ten_us--);
    17. }
    18.  
    19.  
    20. void delay_ms(u16 ms) {
    21.     u16 i, j;
    22.     for (i = ms; i > 0; i--)
    23.         for (j = 110; j > 0; j--);
    24. }
    25.  
    26.  
    27. void ledCtl(u8 pos, u8 on) {
    28.     if(on == 0) {
    29.         P2 |= (1 << pos);
    30.         return;
    31.     }
    32.     P2 &= (~(1 << pos));
    33. }
    34.  
    35.  
    36. void ledToggle(u8 pos) {
    37.     P2 ^= (1 << pos);
    38. }
    39.  
    40.  
    41. unsigned int randomInt(unsigned int seed, unsigned int min, unsigned int max) {
    42.  
    43.     return rand() % (max + 1 - min) + min;
    44. }
    45.  
    46. void printLedWord(int wordLength, u8 *word) {
    47.     u8 i;
    48.     for (i = 0; i < wordLength; i++) {
    49.         LEDDZ_COL_PORT = gled_col[i];
    50.         hc595_write_data(word[i]);
    51.         delay_10us(10);
    52.         hc595_write_data(0x00);
    53.     }
    54. }
    55.  
    56. void hc595_write_data(u8 dat) {
    57.     u8 i = 0;
    58.  
    59.     for (i = 0; i < 8; i++) {
    60.         SERIAL_PORT_INPUT = dat >> 7;
    61.         dat <<= 1;
    62.         SHIFT_REG_INPUT = 0;
    63.         delay_10us(1);
    64.         SHIFT_REG_INPUT = 1;
    65.         delay_10us(1);
    66.     }
    67.     STORE_REG_INPUT = 1;
    68.     delay_10us(1);
    69.     STORE_REG_INPUT = 0;
    70. }
    71.  
    72.  
    73. void lightTube(u8 *word) {
    74.     u8 i=0;
    75.     for(i=0;i<8;i++) {
    76.         switch(i) {
    77.             case 0: LSC=1;LSB=1;LSA=1;break;
    78.             case 1: LSC=1;LSB=1;LSA=0;break;
    79.             case 2: LSC=1;LSB=0;LSA=1;break;
    80.             case 3: LSC=1;LSB=0;LSA=0;break;
    81.             case 4: LSC=0;LSB=1;LSA=1;break;
    82.             case 5: LSC=0;LSB=1;LSA=0;break;
    83.             case 6: LSC=0;LSB=0;LSA=1;break;
    84.             case 7: LSC=0;LSB=0;LSA=0;break;
    85.         }
    86.         SMG_A_DP_PORT = gsmg_code[word[i]];
    87.         delay_10us(10);
    88.         SMG_A_DP_PORT=0x00;
    89.     }
    90. }
    91.  
    92.  
    93. void lightTubeByInt(u16 value) {
    94. 	u16 i;
    95. 	u8 idx = 7;
    96. 	u8 word[8];
    97.  
    98. 	for(i=0; i<8; i++) {
    99. 	    word[i] = 0;
    100. 	}
    101.     i = value;
    102. 	while(i > 0) {
    103. 	    word[idx --] = i % 10;
    104. 	    i = i / 10;
    105. 	}
    106.     lightTube(word);
    107. }
    108.  
    109. void lightTubeByIntSeconds(u16 value, u16 s) {
    110.     u16 i, j;
    111.     for (i = s * 8; i > 0; i--)
    112.         for (j = 110; j > 0; j--)
    113.         	lightTubeByInt(value);
    114. }
    115.  
    116. u8 keyboardMatrixFlipScan(void) {
    117.     static u8 result = 0;
    118.  
    119.     KEY_MATRIX_PORT=0x0f;
    120.     if(KEY_MATRIX_PORT!=0x0f) {
    121.         delay_10us(1000);
    122.         if(KEY_MATRIX_PORT!=0x0f) {
    123.             KEY_MATRIX_PORT=0x0f;
    124.             switch(KEY_MATRIX_PORT) {
    125.                 case 0x07: result=1;break;
    126.                 case 0x0b: result=2;break;
    127.                 case 0x0d: result=3;break;
    128.                 case 0x0e: result=4;break;
    129.             }
    130.  
    131.             KEY_MATRIX_PORT=0xf0;
    132.             switch(KEY_MATRIX_PORT) {
    133.                 case 0x70: result=result;break;
    134.                 case 0xb0: result=result+4;break;
    135.                 case 0xd0: result=result+8;break;
    136.                 case 0xe0: result=result+12;break;
    137.             }
    138.             while(KEY_MATRIX_PORT!=0xf0);
    139.         }
    140.     }
    141.     else
    142.         result=0;
    143.  
    144.     return result;
    145. }

    贪吃蛇的实现

    snake.h 

    1. #ifndef _snake_H
    2. #define _snake_H
    3.  
    4.  
    5. #include "utils.h"
    6.  
    7. typedef struct Node {
    8.     int x;
    9.     int y;
    10. } Node;
    11.  
    12.  
    13. typedef struct Snake {
    14.     struct Node *head;        
    15.     struct Node *food;        
    16.     int flag;        
    17.     int grade;        
    18.     int level;        
    19.     int direction;
    20.  
    21.     void (*setMap)(struct Snake *snake);          
    22.     int (*isOver)(struct Snake *snake);            
    23.     void (*go)(struct Snake *snake);                
    24.     void (*running)(struct Snake *snake, int counter);
    25.     void (*isKeyPressed)(struct Snake *snake);
    26.     void (*init)(struct Snake *snake);
    27.     void (*addNode)(struct Snake *snake, int x, int y);            
    28. 	void (*moveTo)(struct Snake *snake, int direction);            
    29.     void (*createFood)(struct Snake *snake);        
    30.     int (*getFood)(struct Snake *snake);            
    31.     int (*isFoodCover)(struct Snake *snake);        
    32.     int (*isSuccess)(struct Snake *snake);        
    33.     void (*print)(struct Snake *snake);            
    34. } Snake;
    35.  
    36.  
    37. void snakeInit(struct Snake *snake);
    38.  
    39.  
    40. #endif

    snake.c 

    如下 就是 贪吃蛇的初始化, 生成食物, 运行, 等等 相关 

    1.  
    2. #include "snake.h"
    3.  
    4.  
    5. void position(int, int);
    6.  
    7. struct Node *nodeInit(int, int y);
    8.  
    9. void snakeInit(Snake *snake);
    10.  
    11. void setMap(struct Snake *snake);
    12.  
    13. int isOver(struct Snake *snake);
    14.  
    15. void go(struct Snake *snake);
    16.  
    17. void running(struct Snake *snake, int counter);
    18.  
    19. void isKeyPressed(struct Snake *snake);
    20.  
    21. void init(struct Snake *snake);
    22.  
    23. void addNode(struct Snake *snake, int x, int y);
    24.    
    25. void moveTo(struct Snake *snake, int direction);
    26.  
    27. void createFood(struct Snake *snake);
    28.  
    29. int getFood(struct Snake *snake);
    30.  
    31. int isFoodCover(struct Snake *snake);
    32.  
    33. int isSuccess(struct Snake *snake);
    34.  
    35. void print(struct Snake *snake);
    36.  
    37. int snakeHeadInitX = 2;
    38. int snakeHeadInitY = 2;
    39. int gameRangeXMax = 8;
    40. int gameRangeYMax = 8;
    41. int snakeNodeXOffset = 1;
    42. int snakeNodeYOffset = 1;
    43.  
    44. Node nodeList[100];
    45. Node foodNodeIns;
    46. Node *foodNode = &foodNodeIns;
    48.  
    49. void snakeInit(struct Snake *snake) {
    50.     // struct Snake *result = malloc(sizeof(struct Snake));
    51. //    snake->head = nodeInit(snakeHeadInitX, snakeHeadInitY);
    52.     snake->head = &nodeList[0];
    53.     snake->level = 0;
    54.     addNode(snake, snakeHeadInitX, snakeHeadInitY);
    55.  
    56.  
    57.     snake->flag = 0;
    58.     snake->direction = 2;
    59.     snake->grade = 0;
    60.  
    61.     snake->setMap = setMap;
    62.     snake->isOver = isOver;
    63.     snake->go = go;
    64.     snake->running = running;
    65.     snake->isKeyPressed = isKeyPressed;
    66.     snake->init = init;
    67.     snake->addNode = addNode;
    68. 	snake->moveTo = moveTo;
    69.     snake->createFood = createFood;
    70.     snake->getFood = getFood;
    71.     snake->isFoodCover = isFoodCover;
    72.     snake->isSuccess = isSuccess;
    73.     snake->print = print;
    74. }
    75.  
    76.  
    77. void setMap(struct Snake *snake) {
    78.  
    79. }
    80.  
    81.  
    82. void init(struct Snake *snake) {
    83. 	int i;
    84.     struct Node *p = snake->head;
    85.     for (i = 1; i <= 2; i++) {
    86.         addNode(snake, p->x - (i * snakeNodeXOffset), p->y);
    87.     }
    88. }
    89.  
    90. void addNode(struct Snake *snake, int x, int y) {
    91.     nodeList[snake->level].x = x;
    92.     nodeList[snake->level].y = y;
    93.     snake->level ++;
    94.     snake->grade = snake->grade + 5 * (snake->level + 1);
    95. }
    96.  
    97. void moveTo(struct Snake *snake, int direction) {
    98.     u8 i;
    99.     for(i = snake->level - 1; i > 0; i--) {
    100.         nodeList[i].x = nodeList[i-1].x;
    101.         nodeList[i].y = nodeList[i-1].y;
    102.     }
    103.  
    104. 	snake->direction = direction;
    105.     if ((snake->direction + 2) % 2 == 1) {
    106.         snake->head->y -= snake->direction;
    107.     } else {
    108.         snake->head->x += (snake->direction / 2);
    109.     }
    110. }
    111.  
    112. int isOver(struct Snake *snake) {
    113.     struct Node *head = snake->head;
    114.     struct Node *p;
    115. 	u8 i;
    116.     if (head->x >= (gameRangeXMax * snakeNodeXOffset) || head->x < 0
    117.         || head->y >= (gameRangeYMax * snakeNodeYOffset) || head->y < 0)
    118.         return 1;
    119.     for(i=2; i<snake->level; i++) {
    120.         p = &nodeList[i];
    121.         if (head->x == p->x && head->y == p->y) return 1;
    122.     }
    123.     if (snake->level >= 10) return 1;
    124.     return 0;
    125. }
    126.  
    127.  
    128. void createFood(struct Snake *snake) {
    129.     do {
    130.         foodNode->x = randomInt(0, 0, (gameRangeXMax-1) * snakeNodeXOffset);
    131.         foodNode->y = randomInt(0, 0, (gameRangeYMax-1) * snakeNodeYOffset);
    132.     } while (snake->isFoodCover(snake));
    133. }
    134.  
    135.  
    136. int getFood(struct Snake *snake) {
    137.     struct Node *head = snake->head;
    138.     struct Node *p;
    139.  
    140.     if (head->x == foodNode->x && head->y == foodNode->y) {
    141.         p = &nodeList[snake->level-1];
    142.         addNode(snake, p->x, p->y);
    143.         return 1;
    144.     }
    145.     return 0;
    146. }
    147.  
    148.  
    149. int isFoodCover(struct Snake *snake) {
    150. 	u8 i;
    151.     struct Node *p = snake->head;
    152.     struct Node *food = foodNode;
    153.     for(i=0; i<snake->level; i++) {
    154.         p = &nodeList[i];
    155.         if (food->x == p->x && food->y == p->y) return 1;
    156.     }
    157.     return 0;
    158. }
    159.  
    160.  
    161. void go(struct Snake *snake) {
    162.     struct Node *head = snake->head;
    163.     struct Node *p;
    164.  
    165.     snake->moveTo(snake, snake->direction);
    166.     snake->print(snake);
    167. }
    168.  
    169.  
    170. long snakeTurnNextThreshold = 1;
    171. int snakeMaxRowCount = 50;
    172. int snakeCurrentRowIdx = 1;
    173.  
    174.  
    175. void running(struct Snake *snake, int counter) {
    176.     struct Node *p;
    177.     if (counter % snakeTurnNextThreshold == 0) {
    178.         snakeCurrentRowIdx = (snakeCurrentRowIdx + 1) % snakeMaxRowCount;
    179.     }
    180.  
    181. 	snake->isKeyPressed(snake);
    182.     if(snakeCurrentRowIdx > 0) {
    183.         snake->print(snake);
    184.         return ;
    185.     }
    186.  
    187.     snake->print(snake);
    188.     snake->go(snake);
    189.     if (snake->getFood(snake)) {
    190.         snake->createFood(snake);
    191.     }
    192.  
    193. }
    194.  
    195. void isKeyPressed(struct Snake *snake) {
    196. 	u8 keyPressed = 0;
    197.     keyPressed = keyboardMatrixFlipScan();
    198.     // UP
    199.     if (keyPressed == 2 && snake->direction != 1) snake->direction = -1;
    200.         // LEFT
    201.     else if (keyPressed == 5 && snake->direction != 2) snake->direction = -2;
    202.         // DOWN
    203.     else if (keyPressed == 6 && snake->direction != -1) snake->direction = 1;
    204.         // RIGHT
    205.     else if (keyPressed == 7 && snake->direction != -2) snake->direction = 2;
    206.     if (keyPressed == 16) {
    207.         while (1) {
    208.             keyPressed = keyboardMatrixFlipScan();
    209.             snake->print(snake);
    210.             if (keyPressed == 16) break;
    211.         }
    212.     }
    213. }
    214.  
    215. int isSuccess(struct Snake *snake) {
    216.     if (snake->level >= 10) return 1;
    217.     return 0;
    218. }
    219.  
    220.  
    221. void print(struct Snake *snake) {
    222.     struct Node *p;
    223.     u8 word[8];
    224.     u8 i;
    225.  
    226.     for(i=0; i<8; i++) {
    227.         word[i] = 0;
    228.     }
    229.     for(i=0; i<snake->level; i++) {
    230.         p = &nodeList[i];
    231.         word[p->x] |= (1 << p->y);
    232.     }
    233.     p = foodNode;
    234.     word[p->x] |= (1 << p->y);
    235.  
    236.     printLedWord(8, word);
    237. }
    238.

    实际效果如下图 

    游戏结束效果如下

    完

  • 相关阅读:
    Java Spring Redis实现过期键监听回调
    SpringBoot整合WebService（服务端+客户端）
    程序员开发必备，开发资源资料分享【4】
    DevOps（九）Selenium 介绍和Jenkins集成
    大数据学习之Spark基础
    Java数据审计工具：Envers and JaVers比较
    NetCore使用Dapper查询数据
    MySQL explain SQL分析工具详解与最佳实践
    【计算机网络笔记】网络层服务模型——虚电路网络
    FF14 XIVLauncher 启动器与 Dalamud 卫月框架使用教程
  • 原文地址：https://blog.csdn.net/u011039332/article/details/130784012