21ic电子技术开发论坛 › 综合技术交流 › RISC-V › 【RISC-V MCU CH32V103测评】+移植一个简单的Ardunio ga ...
返回列表 发新帖我要提问

[RISC-V MCU 应用开发] 【RISC-V MCU CH32V103测评】+移植一个简单的Ardunio game

[复制链接]
 楼主| qjp1988113 发表于 2020-12-2 15:57 | 显示全部楼层 |阅读模式
MCU, ardunio, RISC-V, 移植, se
本帖最后由 qjp1988113 于 2020-12-2 16:00 编辑

前面做好了摇杆、OLED的驱动及U8GLIB库的移植，今天我们开始移植一个原来在ardunio 上运行的小游戏--《开飞机》。
ardunio的IDE，也是支持C/C++,我们稍微修改下就好了。其中给我感觉的就是新版的C支持在函数内部定义变量，
而旧版的只能在函数顶端定义。另外对于产生随机数的random也有少许差异，废话不说了，上代码：
game.h
复制
  1. /*
    

  2.  * game.h
    

  3.  *
    

  4.  *  Created on: Nov 30, 2020
    

  5.  *      Author: Administrator
    

  6.  */
    


  7. 

  8. #ifndef USER_GAME_H_
    

  9. #define USER_GAME_H_
    


  10. 

  11. #include "joy.h"
    

  12. #include "adc_timtrig.h"
    

  13. #include "u8g_arm.h"
    

  14. #include "u8g.h"
    


  15. 

  16. <font color="#ff0000">extern u8g_t u8g;//定义OLED对象</font>
    

  17. extern u8 reset**;
    


  18. 

  19. void loop(void);
    

  20. void setup(void);
    

  21. void draw(void);
    


  22. 


  23. 


  24. 

  25. #endif /* USER_GAME_H_ */
game.c
复制
  1. /*
    

  2.  * game.c
    

  3.  *
    

  4.  *  Created on: Nov 30, 2020
    

  5.  *      Author: Administrator
    

  6.  */
    


  7. 

  8. #include "game.h"
    

  9. #include "debug.h"
    

  10. #include "u8g.h"
    

  11. #include "stdlib.h"
    

  12. #include "time.h"
    

  13. #include "string.h"
    


  14. 

  15. u8g_t u8g;
    


  16. 

  17. u8 reset**=0;
    

  18. //初始化变量
    

  19. //声明变量很多地方用了byte类型不用int类型，可以节约内存
    

  20. char wait=40;//延迟
    

  21. int HP=20;//HP
    

  22. char PPX=4;//初始化玩家X位置
    

  23. char PPY=2;//初始化玩家Y位置
    

  24. char PX=0;//初始化玩家X轴坐标
    

  25. char PY=0;//初始化玩家Y轴坐标
    

  26. //int RT=1;//初始化运行周期
    

  27. int RT=1;//初始化运行周期
    

  28. int S=0;//分数
    

  29. char ObjA;//障碍物
    

  30. char ObjB;//障碍物
    

  31. char ObjC;//障碍物
    

  32. char ObjD;//障碍物
    

  33. //int Atmp=0;//缓存A
    

  34. //int Btmp;//缓存B
    


  35. 

  36. //下面湿障碍物的数据，我们把障碍物数据保存在数组里，由运行内存显示，每隔20次运行周期会重新覆盖，保存内存不溢出
    

  37. char CA[50];//障碍物A的位置
    

  38. char CB[50];//障碍物B的位置
    

  39. char CC[50];//障碍物C的位置
    

  40. char CD[50];//障碍物D的位置
    


  41. 

  42. //下面湿障碍物A、B、C、D的坐标信息
    

  43. char CAX[50];//障碍物A_X轴
    

  44. char CBX[50];//障碍物B_X轴
    

  45. char CCX[50];//障碍物C_X轴
    

  46. char CDX[50];//障碍物D_X轴
    

  47. char CAY[50];//障碍物A_Y轴
    

  48. char CBY[50];//障碍物B_Y轴
    

  49. char CCY[50];//障碍物C_Y轴
    

  50. char CDY[50];//障碍物D_Y轴
    


  51. 

  52. //载入位图
    

  53. const uint8_t title[] PROGMEM = {
    

  54.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
    

  55.   0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
    

  56.   0x98, 0x81, 0x31, 0xF3, 0x20, 0x45, 0x1F, 0x44, 0x8A, 0x00, 0xA0, 0x00, 0x00, 0x81, 0x00, 0x00,
    

  57.   0x68, 0x41, 0x4A, 0x92, 0x20, 0x45, 0x04, 0x44, 0x8A, 0x00, 0xB0, 0x01, 0x00, 0x40, 0x01, 0x00,
    

  58.   0x14, 0x02, 0x49, 0xF2, 0xE0, 0x45, 0xC4, 0xC4, 0x8B, 0x00, 0x4E, 0x06, 0x00, 0x80, 0x00, 0x00,
    

  59.   0x14, 0x82, 0x48, 0x92, 0x20, 0x55, 0xC4, 0x44, 0xAA, 0x00, 0xB0, 0x01, 0x00, 0x00, 0x00, 0x00,
    

  60.   0x68, 0x41, 0x48, 0x92, 0x20, 0x29, 0x04, 0x44, 0x52, 0x08, 0xA8, 0x00, 0x3E, 0x00, 0x00, 0x00,
    

  61.   0x98, 0xC1, 0x33, 0xF7, 0x20, 0x29, 0x04, 0x5C, 0x52, 0x00, 0x40, 0xC0, 0x61, 0x00, 0x00, 0x30,
    

  62.   0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x38, 0xC3, 0x00, 0x00, 0x0C,
    

  63.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xE7, 0xC6, 0xFF, 0x07, 0x03,
    

  64.   0x00, 0x40, 0x00, 0x04, 0x52, 0x00, 0x00, 0x00, 0x00, 0x02, 0xE0, 0x0C, 0xFE, 0xFF, 0xF9, 0x00,
    

  65.   0xC0, 0xF3, 0x1D, 0x04, 0x12, 0x00, 0x08, 0x00, 0x00, 0x00, 0x30, 0xE8, 0x81, 0x0F, 0xFC, 0x40,
    

  66.   0x00, 0x42, 0x94, 0x3F, 0x7E, 0x00, 0x14, 0x40, 0x00, 0x00, 0x1C, 0x1F, 0x00, 0x8E, 0x7F, 0x00,
    

  67.   0x00, 0xE5, 0x14, 0x04, 0x12, 0x00, 0x08, 0x00, 0x00, 0x00, 0xF6, 0x00, 0x00, 0xFC, 0x1F, 0x08,
    

  68.   0x00, 0xE3, 0x14, 0x0A, 0x57, 0x01, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x00, 0x00, 0xFC, 0x0F, 0x00,
    

  69.   0x00, 0xE5, 0x14, 0x0A, 0x25, 0x00, 0x00, 0x00, 0x20, 0x00, 0x76, 0x00, 0x00, 0xF8, 0x03, 0x00,
    

  70.   0x00, 0x51, 0x15, 0x11, 0x55, 0x00, 0x00, 0x00, 0x00, 0x80, 0xF1, 0x00, 0x00, 0xF6, 0x01, 0x00,
    

  71.   0x00, 0x52, 0xA3, 0x20, 0x47, 0x00, 0x02, 0x20, 0x00, 0x60, 0xFC, 0x00, 0x80, 0x79, 0x00, 0x00,
    

  72.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x18, 0xFA, 0x01, 0x60, 0x36, 0x10, 0x14,
    

  73.   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x38, 0x84, 0xF1, 0x03, 0x90, 0x09, 0x00, 0x02,
    

  74.   0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x1D, 0x00, 0x76, 0x43, 0xF0, 0x03, 0x7C, 0x07, 0x00, 0x54,
    

  75.   0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x07, 0x80, 0xCD, 0x00, 0xF8, 0x07, 0x9B, 0x01, 0x20, 0x00,
    

  76.   0x00, 0xE6, 0x00, 0x00, 0x00, 0x00, 0x02, 0x60, 0x33, 0x00, 0xEA, 0xC3, 0x44, 0x00, 0x02, 0x05,
    

  77.   0x00, 0x11, 0x03, 0x00, 0x00, 0x40, 0x02, 0xD8, 0x0C, 0x00, 0xE5, 0x31, 0x33, 0x00, 0x00, 0x28,
    

  78.   0xC0, 0xCC, 0x1C, 0x00, 0x00, 0x00, 0x70, 0x36, 0x03, 0x40, 0xDA, 0xC8, 0x1E, 0x00, 0x40, 0x75,
    

  79.   0x20, 0x32, 0x61, 0x80, 0x00, 0x00, 0x88, 0x8F, 0x00, 0xB0, 0x36, 0x36, 0x03, 0x00, 0x00, 0x20,
    

  80.   0x98, 0x0A, 0x81, 0x03, 0x00, 0x00, 0xE8, 0x70, 0x00, 0xE8, 0x8D, 0xC9, 0x20, 0x10, 0x50, 0x14,
    

  81.   0x64, 0x0C, 0x02, 0x1C, 0x00, 0x00, 0x78, 0x18, 0x00, 0x5E, 0x63, 0x36, 0x00, 0x02, 0x00, 0x00,
    

  82.   0x13, 0x08, 0x04, 0xE0, 0x00, 0x00, 0x08, 0x06, 0x80, 0xE7, 0x90, 0x19, 0x00, 0x00, 0x15, 0x75,
    

  83.   0x08, 0x08, 0x04, 0x00, 0x1F, 0x00, 0x90, 0x01, 0x40, 0x31, 0x6C, 0x06, 0x06, 0x00, 0x00, 0x20,
    

  84.   0x06, 0x10, 0x08, 0x00, 0xE0, 0xFF, 0x5F, 0x00, 0xF0, 0x10, 0x9B, 0x01, 0x00, 0x44, 0x50, 0x55,
    

  85.   0x01, 0x10, 0x10, 0x00, 0x00, 0x00, 0x30, 0x00, 0x28, 0xC8, 0x64, 0x00, 0x00, 0x00, 0x00, 0x20,
    

  86.   0x80, 0x10, 0x10, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x1E, 0x38, 0x13, 0x00, 0x00, 0x11, 0x75, 0x65,
    

  87.   0x00, 0x20, 0x20, 0x00, 0x00, 0x00, 0x03, 0x80, 0x07, 0xCC, 0x0C, 0x00, 0x00, 0x00, 0x02, 0xA0,
    

  88.   0x00, 0x20, 0x40, 0x00, 0x00, 0xC0, 0x00, 0x40, 0x01, 0x34, 0x03, 0x00, 0x44, 0x55, 0x55, 0x5D,
    

  89.   0x00, 0x40, 0x40, 0x00, 0x00, 0x20, 0x00, 0xF0, 0x00, 0xCE, 0x00, 0x00, 0x00, 0x80, 0x82, 0x28,
    

  90.   0x04, 0x50, 0x80, 0x00, 0x00, 0x18, 0x00, 0x38, 0x00, 0x23, 0x00, 0x00, 0x11, 0x15, 0x57, 0x65,
    

  91.   0x00, 0x40, 0x00, 0x01, 0x00, 0x06, 0x00, 0x0E, 0x00, 0x19, 0x20, 0x00, 0x00, 0x8A, 0x08, 0x20,
    

  92.   0x00, 0x80, 0x00, 0x01, 0x80, 0x01, 0x80, 0x07, 0x80, 0x06, 0x00, 0x44, 0xD1, 0x25, 0x44, 0x15,
    

  93.   0x00, 0x80, 0x00, 0x03, 0x60, 0x00, 0xC0, 0x01, 0xC0, 0x81, 0x00, 0x00, 0xA8, 0x60, 0xA0, 0x22,
    

  94.   0x00, 0x80, 0xC0, 0x00, 0x18, 0x00, 0x70, 0x00, 0x40, 0x00, 0x00, 0x45, 0x76, 0xC7, 0x30, 0x03,
    

  95.   0x00, 0x00, 0x31, 0x00, 0x04, 0x00, 0x78, 0x00, 0x20, 0x00, 0x00, 0x00, 0x22, 0xCA, 0x81, 0x00,
    

  96.   0x40, 0x00, 0x8D, 0x00, 0x03, 0x00, 0x4E, 0x00, 0x20, 0x00, 0x40, 0x00, 0x10, 0x80, 0x41, 0x05,
    

  97.   0x00, 0x80, 0xE3, 0xC0, 0x00, 0x80, 0x27, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x14,
    

  98.   0x00, 0x80, 0x18, 0x31, 0x00, 0xC0, 0x21, 0x00, 0xC8, 0x4B, 0x8F, 0x17, 0x66, 0x3A, 0x06, 0x04,
    

  99.   0x00, 0x20, 0x07, 0x0D, 0x00, 0x40, 0x20, 0x00, 0x08, 0x49, 0x81, 0x14, 0xA9, 0x0A, 0x1E, 0x04,
    

  100.   0x00, 0x00, 0x00, 0x02, 0x00, 0x20, 0x10, 0x00, 0x04, 0x79, 0x87, 0x17, 0xAF, 0x3A, 0xFF, 0xE4,
    

  101.   0x00, 0x00, 0xC0, 0x03, 0x00, 0x20, 0x10, 0x00, 0x04, 0x49, 0x81, 0x10, 0x29, 0x0B, 0xFE, 0xF3,
    

  102.   0x00, 0x00, 0xC0, 0x03, 0x00, 0x2A, 0x10, 0x00, 0x02, 0x49, 0x8F, 0x70, 0x29, 0x3A, 0xBF, 0xDF,
    

  103.   0x20, 0x00, 0xF0, 0x03, 0x00, 0x15, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7E, 0x0C,
    

  104.   0x00, 0x80, 0xF8, 0x07, 0xA0, 0x1E, 0x08, 0x00, 0x01, 0x00, 0x88, 0xCC, 0x01, 0xC0, 0x7F, 0x44,
    

  105.   0x00, 0x40, 0x79, 0x07, 0x54, 0x13, 0x08, 0x80, 0x00, 0x00, 0x88, 0x52, 0x21, 0xC4, 0x5B, 0x34,
    

  106.   0x00, 0x80, 0xA8, 0xA7, 0xEA, 0x1C, 0x04, 0x80, 0x00, 0xFE, 0x88, 0x5E, 0x71, 0x97, 0x9F, 0x39,
    

  107.   0x00, 0x18, 0xD8, 0x5F, 0x35, 0x0B, 0x04, 0x5F, 0x80, 0xF9, 0xA8, 0xD2, 0xA8, 0x8A, 0x17, 0xE0,
    

  108.   0x00, 0x86, 0xD8, 0xBC, 0xFE, 0x0C, 0xE4, 0x30, 0x60, 0xF8, 0x50, 0x52, 0xD1, 0x45, 0x07, 0x90,
    

  109.   0x80, 0xAA, 0xD8, 0xFA, 0x13, 0x0B, 0x1E, 0x3C, 0x18, 0xF0, 0x50, 0x52, 0xA9, 0x08, 0xA7, 0x86,
    

  110.   0xF0, 0xCF, 0xF1, 0xFF, 0xD0, 0x04, 0xE2, 0x13, 0x06, 0x60, 0x00, 0x00, 0x74, 0x01, 0x07, 0x05,
    

  111.   0xAC, 0x72, 0xF7, 0x1F, 0x30, 0x04, 0x1E, 0x90, 0x01, 0x18, 0x00, 0x00, 0xA8, 0x86, 0x85, 0x22,
    

  112.   0x57, 0xDD, 0xE1, 0x07, 0x10, 0x04, 0x01, 0x68, 0x00, 0x06, 0x00, 0xC0, 0x5D, 0xFE, 0x49, 0x05,
    

  113.   0xAA, 0x8A, 0xC0, 0x00, 0x08, 0xFE, 0x01, 0x04, 0x80, 0x01, 0x28, 0xA8, 0x0A, 0x18, 0xC9, 0xA3,
    

  114.   0x77, 0xBF, 0x34, 0x00, 0x04, 0x02, 0x01, 0x04, 0x70, 0x00, 0x76, 0x76, 0x77, 0xE3, 0x50, 0x01,
    

  115.   0xAA, 0x0A, 0x17, 0x00, 0x04, 0x82, 0x00, 0x02, 0x0C, 0x07, 0xA2, 0x8A, 0xAA, 0x42, 0xE1, 0x02,
    

  116.   0xD5, 0xC1, 0x16, 0x00, 0x04, 0x82, 0x00, 0x01, 0xC3, 0x08, 0xD1, 0xC5, 0xD5, 0x45, 0x40, 0x47,
    

  117.   0xAA, 0xB8, 0x08, 0x00, 0x02, 0x81, 0x80, 0xC1, 0x30, 0x06, 0xAA, 0x0A, 0x80, 0x4A, 0xF2, 0x2F,
    

  118. };
    

  119. const uint8_t QR[] PROGMEM = {
    

  120.   0x7F, 0xAD, 0x41, 0x4C, 0x0D, 0xFD, 0x01, 0x41, 0x6D, 0x9D, 0x01, 0xCD, 0x05, 0x01, 0x5D, 0x3F,
    

  121.   0xC9, 0xFE, 0xB2, 0x75, 0x01, 0x5D, 0x9F, 0xA3, 0x2A, 0x9B, 0x74, 0x01, 0x5D, 0xCE, 0xE7, 0x8F,
    

  122.   0x14, 0x74, 0x01, 0x41, 0x57, 0x49, 0x0C, 0x5B, 0x04, 0x01, 0x7F, 0x55, 0x55, 0x55, 0x55, 0xFD,
    

  123.   0x01, 0x00, 0x04, 0x7A, 0x24, 0xF6, 0x01, 0x00, 0x73, 0x3A, 0xD1, 0xCF, 0x00, 0xE9, 0x01, 0x10,
    

  124.   0x16, 0x49, 0xA2, 0x1F, 0x2B, 0x00, 0x67, 0x7C, 0xB5, 0x7E, 0xC2, 0x5F, 0x01, 0xB2, 0x41, 0xB6,
    

  125.   0x49, 0xFB, 0x32, 0x00, 0xC6, 0x88, 0xB2, 0x3C, 0x4E, 0xBE, 0x00, 0xB0, 0x61, 0x1C, 0xA7, 0x16,
    

  126.   0x23, 0x00, 0xEF, 0x55, 0x6D, 0x65, 0xCB, 0x47, 0x01, 0x96, 0xB6, 0x65, 0x6A, 0xBC, 0x34, 0x00,
    

  127.   0x50, 0x22, 0x81, 0xC7, 0xEA, 0xCA, 0x00, 0x23, 0x23, 0xC9, 0x99, 0x35, 0xB9, 0x00, 0xF3, 0x09,
    

  128.   0x6B, 0x54, 0xE5, 0xBC, 0x01, 0x22, 0x36, 0x89, 0x19, 0x29, 0x39, 0x01, 0xD2, 0x6D, 0x5C, 0x96,
    

  129.   0x26, 0x2F, 0x00, 0x02, 0xD9, 0xE7, 0x07, 0xB4, 0x71, 0x00, 0xFB, 0x93, 0xD0, 0xC7, 0x39, 0xBF,
    

  130.   0x01, 0x1B, 0x17, 0x78, 0x1C, 0x6F, 0x31, 0x00, 0x52, 0x1B, 0x6B, 0x75, 0x42, 0x75, 0x01, 0x1A,
    

  131.   0xB5, 0x61, 0x94, 0xA5, 0xF1, 0x01, 0xFD, 0x7D, 0xE4, 0x97, 0xBF, 0xFF, 0x01, 0xB8, 0xCB, 0x7E,
    

  132.   0x61, 0x50, 0x0C, 0x00, 0xE2, 0x88, 0x72, 0xD5, 0xE0, 0xDB, 0x01, 0x8A, 0x76, 0x7C, 0x1B, 0x35,
    

  133.   0x2C, 0x01, 0x43, 0x66, 0xE9, 0xC4, 0x06, 0xBE, 0x01, 0x9E, 0xE4, 0xE1, 0x92, 0xE2, 0x8B, 0x01,
    

  134.   0x53, 0xA5, 0x98, 0x90, 0xE4, 0xD8, 0x01, 0xB9, 0x17, 0x4D, 0x36, 0x09, 0x4D, 0x00, 0x41, 0x9A,
    

  135.   0xE2, 0xF4, 0x43, 0x4E, 0x01, 0x1B, 0xAF, 0xB8, 0x69, 0xF9, 0xAB, 0x01, 0x5C, 0x76, 0xBC, 0x5B,
    

  136.   0xA8, 0x0B, 0x00, 0xBD, 0xCB, 0x27, 0x3F, 0x9F, 0x45, 0x00, 0x62, 0xFD, 0x56, 0x64, 0x53, 0x6C,
    

  137.   0x01, 0x0E, 0x17, 0x1E, 0x8C, 0xDF, 0xA7, 0x01, 0x47, 0x28, 0xE0, 0x9F, 0xEA, 0x7F, 0x00, 0x00,
    

  138.   0x61, 0x69, 0x8C, 0x39, 0x91, 0x00, 0x7F, 0x6A, 0x7D, 0xCD, 0x02, 0xF5, 0x01, 0x41, 0x47, 0x5F,
    

  139.   0x9C, 0x32, 0xB1, 0x00, 0x5D, 0x99, 0xF2, 0x97, 0x00, 0x3F, 0x00, 0x5D, 0x74, 0x1C, 0x06, 0xBC,
    

  140.   0xAB, 0x01, 0x5D, 0x60, 0x2F, 0xAD, 0xB9, 0xFA, 0x01, 0x41, 0x8B, 0x47, 0x09, 0x8F, 0xB5, 0x00,
    

  141.   0x7F, 0x05, 0xEB, 0x76, 0x60, 0xC9, 0x01,
    

  142. };
    

  143. const uint8_t pause[] PROGMEM = {
    

  144.   0xA7, 0xAA, 0xAA, 0xAA, 0x3A, 0x55, 0x55, 0x55, 0x55, 0x29, 0x07, 0x00, 0x00, 0x00, 0x38, 0xF0,
    

  145.   0xF7, 0xFB, 0xF7, 0x03, 0x19, 0x1C, 0x8E, 0x1C, 0x26, 0x8A, 0xCF, 0x04, 0xC8, 0x14, 0x89, 0x08,
    

  146.   0x24, 0x09, 0x24, 0x8A, 0x08, 0x24, 0xC9, 0x17, 0x89, 0xC9, 0x24, 0x09, 0x24, 0x1A, 0xCC, 0x24,
    

  147.   0x19, 0x16, 0xF1, 0xFF, 0xFF, 0xFF, 0x23, 0x0A, 0x86, 0x4C, 0x18, 0x16, 0xC9, 0x34, 0x4D, 0xC8,
    

  148.   0x24, 0x0A, 0x04, 0x4D, 0x0E, 0x14, 0x09, 0x02, 0xCD, 0xD9, 0x27, 0xCA, 0x33, 0x41, 0x10, 0x14,
    

  149.   0xC9, 0x33, 0x21, 0x18, 0x26, 0xFA, 0xFF, 0xFF, 0xFF, 0x17, 0x70, 0xFC, 0xDE, 0xEF, 0x03, 0x07,
    

  150.   0x00, 0x00, 0x00, 0x38, 0x55, 0x55, 0x55, 0x55, 0x29, 0xA7, 0xAA, 0xAA, 0xAA, 0x3A,
    

  151. };
    

  152. const uint8_t plane[] PROGMEM = {0x8, 0xC, 0x8C, 0xFF, 0xFF, 0x8C, 0xC, 0x8};
    

  153. const uint8_t BOA[] PROGMEM = {0xCC, 0xCC, 0x33, 0x33, 0xCC, 0xCC, 0x33, 0x33};
    

  154. const uint8_t BOB[] PROGMEM = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
    

  155. const uint8_t BOC[] PROGMEM = {0x18, 0x66, 0x7E, 0xBD, 0xBD, 0x7E, 0x66, 0x18};
    

  156. const uint8_t BOD[] PROGMEM = {0x0, 0x7E, 0x42, 0x5A, 0x5A, 0x42, 0x7E, 0x0};
    

  157. const uint8_t life[] PROGMEM = {0x0, 0x66, 0xFF, 0xCF, 0xDF, 0x7E, 0x3C, 0x18};
    


  158. 

  159. /********************************************************/
    


  160. 

  161. void setup() {
    

  162.     // put your setup code here, to run once:
    

  163.     char key_value=0;
    

  164.     //初始化按钮
    

  165.     srand((unsigned)time(NULL));//伪随机数PIN
    

  166.     reset**=0;
    


  167. 

  168.     u8g_FirstPage(&u8g);
    

  169.     do
    

  170.     {
    

  171.         u8g_DrawXBMP(&u8g,0,0,128,64,title);
    

  172.     }
    

  173.     while(u8g_NextPage(&u8g));
    

  174.     u8g_Delay(1024);
    

  175.     u8g_Delay(1024);
    

  176.     u8g_Delay(1024);
    


  177. 

  178.     GET_KEY_Basedata();
    

  179.     key_value = GET_KEY_VALUE(JOY_X, JOY_Y, JOY_Z);
    

  180.     while(key_value!=LEFT_UP)
    

  181.     {
    

  182.         //显示
    

  183.         u8g_FirstPage(&u8g);
    

  184.         do
    

  185.         {
    

  186.           u8g_DrawXBMP(&u8g,0,0,128,64,title);
    

  187.         }
    

  188.         while(u8g_NextPage(&u8g));
    


  189. 


  190. 

  191.         GET_KEY_Basedata();
    

  192.         key_value = GET_KEY_VALUE(JOY_X, JOY_Y, JOY_Z);
    

  193.         printf("SETUP: x:%d   y:%d  z:%d\n", JOY_X,JOY_Y,JOY_Z);
    


  194. 

  195.        switch(key_value)
    

  196.        {
    

  197.            case UP :
    

  198.                printf("UP\n");
    

  199.                break ;
    


  200. 

  201.            case DOWN :
    

  202.                printf("DOWN\n");
    

  203.                break ;
    


  204. 

  205.            case LEFT :
    

  206.                printf("LEFT\n");
    

  207.                break ;
    


  208. 

  209.            case RIGHT  :
    

  210.                printf("RIGHT\n");
    

  211.                break ;
    


  212. 

  213.            case LEFT_UP:
    

  214.                printf("LEFT_UP\n");
    

  215.                break ;
    


  216. 

  217.            case LEFT_DOWN:
    

  218.                printf("LEFT_DOWN\n");
    

  219.                break ;
    


  220. 

  221.            case RIGHT_UP:
    

  222.                printf("RIGHT_UP\n");
    

  223.                break ;
    


  224. 

  225.            case RIGHT_DONW :
    

  226.                printf("RIGHT_DONW\n");
    

  227.                break ;
    


  228. 

  229.            case ENTER :
    

  230.                printf("ENTER\n");
    

  231.                break ;
    


  232. 

  233.            default:
    

  234.                break ;
    

  235.        }
    

  236.     }
    

  237. }
    

  238. /**********************************************************/
    

  239. void(* resetFunc)(void)=0;//制造从起命令的函数，下面会用到
    


  240. 


  241. 

  242. void loop() {
    

  243.     int  i=0;
    


  244. 

  245.     int  tmprand=0;  //随机数缓存
    

  246.     char key_value=0;
    

  247.     int Atmp=0;//缓存A
    

  248.     int Btmp=0;//缓存B
    


  249. 

  250.     //下面是GAME OVER或胜利后的处理
    

  251.     if(HP<0||S>30000)
    

  252.     {
    

  253.         //循环检测按钮
    

  254.         while(1)
    

  255.         {
    

  256.             //如果GAME OVER就等待按下A键复位游戏
    

  257.             GET_KEY_Basedata();
    

  258.             key_value = GET_KEY_VALUE(JOY_X, JOY_Y, JOY_Z);
    

  259.             printf("x:%d   y:%d  z:%d\n", JOY_X,JOY_Y,JOY_Z);
    


  260. 

  261.              switch(key_value)
    

  262.              {
    

  263.                  case UP :
    

  264.                      printf("UP\n");
    

  265.                      break ;
    


  266. 

  267.                  case DOWN :
    

  268.                      printf("DOWN\n");
    

  269.                      break ;
    


  270. 

  271.                  case LEFT :
    

  272.                      printf("LEFT\n");
    

  273.                      break ;
    


  274. 

  275.                  case RIGHT  :
    

  276.                      printf("RIGHT\n");
    

  277.                      break ;
    


  278. 

  279.                  case LEFT_UP:
    

  280.                      printf("LEFT_UP\n");
    

  281.                      break ;
    


  282. 

  283.                  case LEFT_DOWN:
    

  284.                      printf("LEFT_DOWN\n");
    

  285.                      break ;
    


  286. 

  287.                  case RIGHT_UP:
    

  288.                      printf("RIGHT_UP\n");
    

  289.                      break ;
    


  290. 

  291.                  case RIGHT_DONW :
    

  292.                      printf("RIGHT_DONW\n");
    

  293.                      break ;
    


  294. 

  295.                  case ENTER :
    

  296.                      printf("ENTER\n");
    

  297.                      break ;
    


  298. 

  299.                  default:
    

  300.                      break ;
    

  301.              }
    

  302.             //ENTER 代表A键
    

  303.             if(key_value==ENTER)//复位
    

  304.             {
    

  305.                 printf("I'm in ENTER\n");
    

  306.                 if(HP<0)
    

  307.                 {
    

  308.                     printf("I'm in HP<0 ENTER\n");
    


  309. 

  310.                     //resetFunc();//调用前面的软复位函数，达到软件重启Arduino的目的
    

  311.                     NVIC_SystemReset();
    

  312.                     //复位初始数据
    

  313.                     wait=40;//延迟
    

  314.                     HP=20;//HP
    

  315.                     PPX=4;//初始化玩家X位置
    

  316.                     PPY=2;//初始化玩家Y位置
    

  317.                     PX=0;//初始化玩家X轴坐标
    

  318.                     PY=0;//初始化玩家Y轴坐标
    

  319.                     //int RT=1;//初始化运行周期
    

  320.                     RT=1;//初始化运行周期
    

  321.                     S=0;//分数
    

  322.                     ObjA=0;//障碍物
    

  323.                     ObjB=0;//障碍物
    

  324.                     ObjC=0;//障碍物
    

  325.                     ObjD=0;//障碍物
    

  326.                     //int Atmp=0;//缓存A
    

  327.                     //int Btmp;//缓存B
    

  328.                     //////////memset(arr, 0, 1024); //清零
    

  329.                     //下面湿障碍物的数据，我们把障碍物数据保存在数组里，由运行内存显示，每隔20次运行周期会重新覆盖，保存内存不溢出
    

  330.                     memset(CA,0,50);//障碍物A的位置
    

  331.                     memset(CB,0,50);//障碍物B的位置
    

  332.                     memset(CC,0,50);//障碍物C的位置
    

  333.                     memset(CD,0,50);//障碍物D的位置
    


  334. 

  335.                     //下面湿障碍物A、B、C、D的坐标信息
    

  336.                     memset(CAX,0,50);//障碍物A_X轴
    

  337.                     memset(CBX,0,50);//障碍物B_X轴
    

  338.                     memset(CCX,0,50);//障碍物C_X轴
    

  339.                     memset(CDX,0,50);//障碍物D_X轴
    

  340.                     memset(CAY,0,50);//障碍物A_Y轴
    

  341.                     memset(CBY,0,50);//障碍物B_Y轴
    

  342.                     memset(CCY,0,50);//障碍物C_Y轴
    

  343.                     memset(CDY,0,50);//障碍物D_Y轴
    


  344. 

  345.                     printf("RESTORE DATA\n");
    

  346.                 }
    

  347.                // break;
    

  348.             }
    


  349. 

  350.             //如果检测到分数大于3万，就判断赢了游戏，放出二维码彩蛋
    

  351.             if(S>=30000){
    

  352.                 while(1)
    

  353.                 {
    

  354.                     u8g_SetColorIndex(&u8g,1);
    

  355.                     u8g_FirstPage(&u8g);
    

  356.                     do
    

  357.                     {
    

  358.                         u8g_DrawXBMP(&u8g,40,8,56,49,QR);
    

  359.                     }
    

  360.                     while(u8g_NextPage(&u8g));
    

  361.                 }
    

  362.             }
    

  363.         }
    

  364.     }
    


  365. 

  366.     GET_KEY_Basedata();
    

  367.     key_value = GET_KEY_VALUE(JOY_X, JOY_Y, JOY_Z);
    

  368.     if(key_value==UP)
    

  369.     {
    

  370.         //u8g_Delay(10);
    

  371.         if(key_value==UP)
    

  372.         {
    

  373.             if(PPY>1) PPY-=1;
    

  374.         }
    

  375.     }
    


  376. 

  377.     if(key_value==DOWN)
    

  378.     {
    

  379.         //u8g_Delay(10);
    

  380.         if(key_value==DOWN)
    

  381.         {
    

  382.             if(PPY<4) PPY+=1;
    

  383.         }
    

  384.     }
    


  385. 

  386.     if(key_value==LEFT)
    

  387.     {
    

  388.         //u8g_Delay(10);
    

  389.         if(key_value==LEFT)
    

  390.         {
    

  391.             if(PPX>1) PPX-=1;
    

  392.         }
    

  393.     }
    

  394.     if(key_value==RIGHT)
    

  395.     {
    

  396.         //u8g_Delay(10);
    

  397.         if(key_value==RIGHT)
    

  398.         {
    

  399.             if(PPX<15) PPX+=1;
    

  400.         }
    

  401.     }
    

  402.     //LEFT_UP代表B键
    

  403.     if(key_value==LEFT_UP)
    

  404.     {
    

  405.         //u8g_Delay(10);
    

  406.         if(key_value==LEFT_UP)
    

  407.         {
    

  408.             //u8g_Delay(200);
    

  409.             u8g_FirstPage(&u8g);
    

  410.             do
    

  411.             {
    

  412.                 draw();
    

  413.                 u8g_SetColorIndex(&u8g,0);
    

  414.                 u8g_DrawBox(&u8g,42,10,46,28);//先覆盖掉原屏幕，避免下面的图片变透明
    

  415.                 u8g_SetColorIndex(&u8g,1);
    

  416.                 u8g_DrawXBMP(&u8g,45,13,40,22,pause);
    

  417.             }
    

  418.             while(u8g_NextPage(&u8g));
    

  419.             while(1)
    

  420.             {
    

  421.                 GET_KEY_Basedata();
    

  422.                 key_value = GET_KEY_VALUE(JOY_X, JOY_Y, JOY_Z);
    

  423.                 if(key_value==LEFT_UP)
    

  424.                 {
    

  425.                     u8g_Delay(10);
    

  426.                     if(key_value==LEFT_UP)
    

  427.                     {
    

  428.                         u8g_Delay(200);
    

  429.                         break;
    

  430.                     }
    

  431.                 }
    

  432.             }
    

  433.         }
    

  434.     }
    

  435.     /**************************************/
    

  436.     //计算
    

  437.     S+=1;
    

  438.     PX=PPX*8;
    

  439.     PY=PPY*8;
    

  440.     ObjA=9;
    

  441.     ObjB=9;
    

  442.     ObjC=9;
    

  443.     ObjD=9;
    

  444.     if(RT<16)
    

  445.     {
    

  446.         //srand((unsigned)time(NULL));
    

  447.         tmprand= random();
    

  448.         Atmp=1+tmprand%100;//1~100
    

  449.         if(Atmp<=70)
    

  450.         {
    

  451.             //srand((unsigned)time(NULL));
    

  452.             tmprand= random();
    

  453.             ObjA=tmprand%5;
    

  454.         }
    

  455.         //乌云
    


  456. 

  457.         //srand((unsigned)time(NULL));
    

  458.         tmprand= random();
    

  459.         Atmp=1+tmprand%100;//1~100
    

  460.         if(Atmp<=30)
    

  461.         {
    

  462.             //srand((unsigned)time(NULL));
    

  463.             tmprand= random();
    

  464.             ObjB=tmprand%5;
    

  465.         }
    


  466. 

  467.         //加油机
    

  468.         //srand((unsigned)time(NULL));
    

  469.         tmprand= random();
    

  470.         Atmp=1+tmprand%100;//1~100
    

  471.         if(Atmp<=5)
    

  472.         {
    

  473.             //srand((unsigned)time(NULL));
    

  474.             tmprand= random();
    

  475.             ObjC=tmprand%5;
    

  476.         }
    


  477. 

  478.         //其他飞机
    

  479.         //srand((unsigned)time(NULL));
    

  480.         tmprand= random();
    

  481.         Atmp=1+tmprand%100;//1~100
    

  482.         if(Atmp<=50)
    

  483.         {
    

  484.             //srand((unsigned)time(NULL));
    

  485.             tmprand= random();
    

  486.             ObjD=tmprand%5;
    

  487.         }
    

  488.     }
    


  489. 

  490.     if(HP>12)HP=12;
    

  491.     //保存障碍物位置
    

  492.     CAY[RT]=ObjA*8;
    

  493.     CBY[RT]=ObjB*8;
    

  494.     CCY[RT]=ObjC*8;
    

  495.     CDY[RT]=ObjD*8;
    

  496.     CA[RT]=ObjA;
    

  497.     CB[RT]=ObjB;
    

  498.     CC[RT]=ObjC;
    

  499.     CD[RT]=ObjD;
    

  500.     CAX[RT]=120;
    

  501.     CBX[RT]=120;
    

  502.     CCX[RT]=120;
    

  503.     CDX[RT]=120;
    

  504.     //判断伤害
    

  505.     Btmp=15-PPX;
    

  506.     if(RT>Btmp)
    

  507.     {
    

  508.         Atmp=RT-Btmp;
    

  509.         if(PPY==CA[Atmp])
    

  510.         {
    

  511.             HP-=1;
    

  512.         }
    


  513. 


  514. 

  515.         if(PPY==CB[Atmp])
    

  516.         {
    

  517.             HP-=2;
    

  518.         }
    


  519. 

  520.         if(PPY==CC[Atmp])
    

  521.         {
    

  522.             //Atmp=random(1,3);
    

  523.             //srand((unsigned)time(NULL));
    

  524.             tmprand= random();
    

  525.             Atmp=1+tmprand%3;
    


  526. 

  527.             HP+=Atmp;
    

  528.             S+=30;
    

  529.         }
    


  530. 

  531.         if(PPY==CD[Atmp])
    

  532.         {
    

  533.             //Atmp=random(1,100);
    


  534. 

  535.             //srand((unsigned)time(NULL));
    

  536.             tmprand= random();
    

  537.             Atmp=1+tmprand%100;
    


  538. 

  539.             if(Atmp<50)
    

  540.             {
    

  541.                 HP+=1;
    

  542.                 S+=15;
    

  543.             }
    

  544.             else
    

  545.             {
    

  546.                 HP-=1;
    

  547.             }
    

  548.         }
    

  549.     }
    


  550. 

  551.     /*******************************华丽的分割线*******************/
    

  552.     u8g_FirstPage(&u8g);
    

  553.     do
    

  554.     {
    

  555.         draw();
    

  556.     }
    

  557.     while(u8g_NextPage(&u8g));
    

  558.     //障碍物往下移
    

  559.     Atmp=RT-16;
    

  560.     if(Atmp<1)
    

  561.     {
    

  562.         Atmp=1;
    

  563.     }
    


  564. 

  565.     for(Atmp;Atmp<=RT;Atmp++)
    

  566.     {
    

  567.         CAX[Atmp]-=8;//把障碍物的数组下移
    

  568.         CBX[Atmp]-=8;
    

  569.         CCX[Atmp]-=8;
    

  570.         CDX[Atmp]-=8;
    

  571.     }
    

  572.     RT+=1;
    

  573.     if(RT>=32)
    

  574.     {
    

  575.         RT=1;
    

  576.     }
    


  577. 


  578. 

  579.     u8g_Delay(wait);//防止游戏运行到不能玩的级别
    


  580. 

  581. }
    

  582. void draw()
    

  583. {
    

  584.     int Atmp=0;
    

  585.     int Btmp=0;
    


  586. 

  587.     char tmpbuf[500]={0};
    

  588.     //障碍物循环码初始化计算
    

  589.     Atmp=RT-16;
    

  590.     if(Atmp<1)
    

  591.     {
    

  592.         Atmp=1;
    

  593.     }
    

  594.     //障碍物显示
    

  595.     for(Atmp;Atmp<=RT;Atmp++)
    

  596.     {
    

  597.         if(CCX[Atmp]>0)
    

  598.         {
    

  599.             u8g_DrawBitmapP(&u8g,CCX[Atmp],CCY[Atmp],1,8,BOC);
    


  600. 

  601.         }
    

  602.         if(CDX[Atmp]>0)
    

  603.         {
    

  604.             u8g_DrawBitmapP(&u8g,CDX[Atmp],CDY[Atmp],1,8,BOD);
    

  605.         }
    

  606.         if(CAX[Atmp]>0)
    

  607.         {
    

  608.             u8g_DrawBitmapP(&u8g,CAX[Atmp],CAY[Atmp],1,8,BOA);
    

  609.         }
    

  610.         if(CBX[Atmp]>0)
    

  611.         {
    

  612.             u8g_DrawBitmapP(&u8g,CBX[Atmp],CBY[Atmp],1,8,BOB);
    

  613.         }
    

  614.     }
    


  615. 

  616.     //显示玩家
    

  617.     u8g_DrawBitmapP(&u8g,PX,PY,1,8,plane);
    

  618.     //生命及分数
    

  619.     u8g_SetFont(&u8g,u8g_font_profont10);
    

  620.     u8g_SetColorIndex(&u8g,255);
    

  621.     if(HP>0)
    

  622.     {
    

  623.         u8g_DrawStr(&u8g, 8, 54, "HP:");
    

  624.         for(Atmp=1;Atmp<=HP;Atmp++)
    

  625.         {
    

  626.             Btmp=Atmp*8+20;
    

  627.             u8g_DrawBitmapP(&u8g,Btmp,45,1,8,life);
    

  628.         }
    

  629.     }
    


  630. 

  631.     sprintf(tmpbuf,"score: %d",S);
    

  632.     u8g_DrawStr(&u8g, 8, 62,tmpbuf);
    


  633. 

  634.     if(HP<0||S>=30000)
    

  635.     {
    

  636.         u8g_SetColorIndex(&u8g,255);
    

  637.         u8g_DrawBox(&u8g,0,0,128,64);
    

  638.         //打印结果
    

  639.         u8g_SetFont(&u8g,u8g_font_profont10);
    

  640.         u8g_SetColorIndex(&u8g,0);
    

  641.         if(HP<0)
    

  642.             u8g_DrawStr(&u8g, 4, 10,"GAME OVER");
    

  643.         if(S>=30000)
    

  644.             u8g_DrawStr(&u8g, 4, 10,"You Win");
    

  645.         //打印分数
    

  646.         u8g_SetFont(&u8g,u8g_font_profont10);
    

  647.         u8g_SetColorIndex(&u8g,0);
    

  648.         if(HP<0)
    

  649.         {
    

  650.             sprintf(tmpbuf,"score: %d",S);
    

  651.             u8g_DrawStr(&u8g, 4, 30,tmpbuf);
    

  652.         }
    

  653.         if(S>=30000)
    

  654.         {
    

  655.             u8g_DrawStr(&u8g, 4, 30,"score: 30000");
    

  656.         }
    


  657. 

  658.         if(HP<0)
    

  659.             u8g_DrawStr(&u8g, 2, 62,"please push A to RESET");
    

  660.         if(S>=30000)
    

  661.             u8g_DrawStr(&u8g, 2, 62,"A to QR code");
    


  662. 

  663.     }
    

  664. }
    


  665.
在mian.c里面调用：
复制
  1.  ............


编译下载，看下运行的效果：启动画面，LEFT_UP 替代B键，启动游戏：
B.jpg
结束界面，ENTER取代A键，按下后重新开始：
A.jpg

游戏视频，要摇杆操作这游戏还是挺累的，麻蛋。还不如按键呢：
D (1).gif
ardunio平台上有个ardunio BOY的游戏机，还有好多开源的游戏，不过查看源码，好像要梯子，感兴趣可以自己去移植移植。
回复 赏

举报

相关帖子
xyz549040622 发表于 2020-12-2 19:59 | 显示全部楼层
牛X，支持下！这都可以移植过来，不过看样子V103玩游戏有点卡呀。
回复 赏

举报

740071911 发表于 2020-12-3 09:12 | 显示全部楼层
xyz549040622 发表于 2020-12-2 19:59
牛X，支持下！这都可以移植过来，不过看样子V103玩游戏有点卡呀。

应该就这样的吧，arduino是mega328p，性能应该远不如v103
回复 赏

举报

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

本版积分规则

qjp1988113

111

主题

627

帖子

2

粉丝
快速回复 在线客服 返回列表 返回顶部
qjp1988113

111

主题

627

帖子

2

粉丝
快速回复 在线客服 返回列表 返回顶部