GAME - ST7565 - Game hứng trứng - phiên bản nâng cấp

Nguyễn Việt Anh 07/08/2019
game-st7565-game-hung-trung-phien-ban-nang-cap

Đây là phiên bản thứ 2 của Game hứng trứng đơn giản, cùng với sự xuất hiện của cô gà mái, hi vọng đây sẽ là sản phẩm Game mang lại nhiều niềm vui trong những ngày đầu năm Đinh Dậu.laughlaugh

1

Là phiên bản nâng cấp >++

Đây là phiên bản đơn giản trước đó:cheeky

Làm game hứng trứng đơn giản - phiên bản 1

Còn ở phiên bản thứ 2 này:laugh

Một chú gà đi trên mái kèo, là một nhân vật hư cấu, chú vừa đi vừa đẻ trứng. Để trứng không bị vỡ khi rơi, 2 nhân vật Cả Mẹo và Dần Béo sẽ phải phối hợp nhịp nhàng hứng những quả trứng vào rổ.

Phân vai:

  • Cả Mẹo – có cái đầu đinh: cẩm chiếc rổ để hứng trứng.
  • Dần Béo – mập  ú và rất vụng về là sở đoản của cậu ta: tuy nhiên vì chỉ có một chiếc rỏ , cậu ấy bèn phải dùng chiếc vợt để đỡ những quả trứng đang rơi, trứng sẽ nảy lên khi rơi vào chiếc vợt đó.  

Tính Điểm:

  • Trứng rơi thẳng vào rổ: cộng 1 điểm.
  • Trứng rơi và được Dần Béo đỡ bằng vợt rồi rơi vào rổ: cộng 2 điểm.
  • Trứng rơi và được Dần Béo đỡ bằng vợt nhưng không vào rổ: trừ 2 điểm.
  • Rơi thẳng xuống đất: Trừ 1 điểm.

Điều khiển:

  • Sử dụng 2 nút di chuyển trái phải để di chuyển nhân vật.
  • Nhấn nút ”OK” để lựa chọn nhân vật.
  • Mũi tên sẽ chỉ vào nhân vật đang được chọn.

2

Phần cứng

Tải về thư viện đồ họa

Bạn hãy tải về thư viện tại bài viết này

Chuẩn bị phần cứng

  • Arduino chip atm328 trở lên, mình sử dụng arduino uno r3
  • Lcd st7565 128x64 homephone spi
  • Nút bấm: 6 nút

Nối mạch

3

Quản lí đối tượng

Có 3 loại đối tượng cần quan tâm:

Đối tượng

Chức năng, nhiệm vụ

Thuộc tính

Gà mái

Di chuyển qua lại ở phía trên màn hình. Đẻ trứng một cách ngẫu nhiên.

Tọa độ, hướng.

Dần và Mẹo.

Hứng và đỡ trứng đang rơi.

Tọa độ, hướng nhìn.

Trứng

Rơi thẳng từ trên xuống, tọa độ bắt đầu là tọa độ của gà. Bay lên theo đường parabol khi rơi xuống chiếc vợt của Dần Béo.

Sự tồn tại, tọa độ.

 

Bạn hãy đọc các bài trước về quản lí các đối tượng này nhé  !wink

4

Di chuyển gà

  1. #include "ST7565_homephone.h"
  2. // add a bitmap library of a 16x16 fruit icon
  3. #include "bmps.h"
  4.  
  5. ST7565 lcd(3, 4, 5, 6);
  6.  
  7. const static unsigned char __attribute__((progmem)) ga_mai_16x16[] = {
  8. 0x20, 0xD8, 0x2C, 0x0C, 0x9E, 0x72, 0x42, 0xC0, 0x40, 0x40, 0x60, 0xFC, 0xCE, 0x3B, 0x7B, 0x01,
  9. 0x00, 0x06, 0x09, 0x10, 0x30, 0x48, 0x44, 0x4E, 0x59, 0x71, 0x39, 0x1F, 0x0E, 0x00, 0x00, 0x00
  10. };
  11. /* Qủa trứng (6x7) pixel
  12. * */
  13.  
  14. const static unsigned char __attribute__((progmem)) trung_6x7[] = {
  15. 0x1C, 0x22, 0x41, 0x41, 0x22, 0x1C,
  16. };
  17.  
  18. byte Xmin, Ymin, Xmax, Ymax; //biên
  19. // mảng cho 2 đối tượng gà(0) và trứng(1)
  20. byte object[2][4];
  21. //object[i][0]: tồn tại hay không
  22. //object[i][1]: tọa độ x
  23. //object[i][2]: tọa độ y
  24. //object[i][3]: hướng (1 phải, 2 trên , 3 trái, 4 dưới)
  25. //
  26. // Chương trình chạy 1 lần
  27. void setup()
  28. {
  29. lcd.ON();
  30. lcd.SET(23, 0, 0, 0, 4);
  31.  
  32. Xmin = 0;
  33. Xmax = 125;
  34. Ymin = 0;
  35. Ymax = 63;
  36. }
  37. void ve_ga_di()
  38. {
  39. byte x_cu, y_cu, huong_cu;
  40. byte x_moi;
  41. x_cu = object[0][1];
  42. y_cu = object[0][2];
  43. huong_cu = object[0][3];
  44. //lấy thông tin
  45.  
  46. if (huong_cu == 1) { //gà quay về bên phải
  47. x_moi = x_cu + 1;
  48. lcd.Plus_Bitmap(x_moi, y_cu, 16, 16, ga_mai_16x16, 0, MIRROR, BLACK);
  49. // xoay bitmap (mirror)
  50. //
  51. }
  52.  
  53. if (huong_cu == 3) { //gà quay về bên trái
  54. x_moi = x_cu - 1;
  55. lcd.Plus_Bitmap(x_moi, y_cu, 16, 16, ga_mai_16x16, 0, NO_MIRROR, BLACK);
  56. // không xoay (non mirror)
  57. }
  58. //ghi lại thông tin
  59. object[0][1] = x_moi;
  60. lcd.display();
  61.  
  62. } //vẽ gà
  63. void xoa_ga(byte x, byte y)
  64. {
  65. lcd.FillRect(x, y, 16, 16, DELETE); //
  66. lcd.display();
  67. } //xóa gà
  68. void ga_di_va_de_trung()
  69. { // gà đi và đẻ trứng
  70. //////////// XỬ LÍ GÀ////////////
  71. //b1: cấp giấy khai sinh
  72. if (object[0][0] == 0) {
  73. // nếu không tồn tại gà thì phải tạo gà
  74. // cấp thuộc tính cho đối tượng gà
  75. object[0][1] = Xmin + 5; //hoành độ ban đầu
  76. object[0][2] = Ymin; // tung độ ban đầu
  77. object[0][3] = 1; //hướng sang bên phải
  78. object[0][0] = 1; //cấp quyền tồn tại
  79. }
  80. //b2: gà đi và quay đầu
  81. //lấy thông tin;
  82. if (object[0][1] <= Xmin) {
  83. // nếu gà đến biên trái thì phải quay đầu về bên phải
  84. object[0][3] = 1;
  85. //ghi lại thông tin
  86. }
  87.  
  88. if (object[0][1] >= Xmax) {
  89. // nếu gà đến biên phải thì phải quay đầu về bên trái
  90. object[0][3] = 3;
  91. //ghi lại thông tin
  92. }
  93. ///////////GÀ ĐANG ĐI/////////
  94. // lấy tt
  95.  
  96. xoa_ga(object[0][1], object[0][2]); //xóa ảnh cũ
  97. ve_ga_di(); // vẽ ảnh mới
  98. }
  99. void loop()
  100. {
  101.  
  102. ga_di_va_de_trung();
  103. delay(100);
  104. }

Kết quả chạy thử

5

Di chuyển gà và đẻ trứng

  1. #include "ST7565_homephone.h"
  2. // add a bitmap library of a 16x16 fruit icon
  3. #include "bmps.h"
  4.  
  5. ST7565 lcd(3, 4, 5, 6);
  6.  
  7. const static unsigned char __attribute__((progmem)) ga_mai_16x16[] = {
  8. 0x20, 0xD8, 0x2C, 0x0C, 0x9E, 0x72, 0x42, 0xC0, 0x40, 0x40, 0x60, 0xFC, 0xCE, 0x3B, 0x7B, 0x01,
  9. 0x00, 0x06, 0x09, 0x10, 0x30, 0x48, 0x44, 0x4E, 0x59, 0x71, 0x39, 0x1F, 0x0E, 0x00, 0x00, 0x00
  10. };
  11. /* Qủa trứng (6x7) pixel
  12. * */
  13.  
  14. const static unsigned char __attribute__((progmem)) trung_6x7[] = {
  15. 0x1C, 0x22, 0x41, 0x41, 0x22, 0x1C,
  16. };
  17.  
  18. byte Xmin, Ymin, Xmax, Ymax; //biên
  19. // mảng cho 2 đối tượng 1 gà(0) và 3 trứng(1,2.3)
  20. byte object[1 + 3][4];
  21. //object[i][0]: tồn tại hay không
  22. //object[i][1]: tọa độ x
  23. //object[i][2]: tọa độ y
  24. //object[i][3]: hướng (1 phải, 2 trên , 3 trái, 4 dưới)
  25. //
  26. // Chương trình chạy 1 lần
  27. void setup()
  28. {
  29. lcd.ON();
  30. lcd.SET(23, 0, 0, 0, 4);
  31.  
  32. Xmin = 0;
  33. Xmax = 125;
  34. Ymin = 0;
  35. Ymax = 63;
  36. }
  37. //===========================================================
  38. ////////////////DI CHUYỂN GÀ////////////////////
  39. void di_chuyen_ga()
  40. {
  41. byte x_cu, y_cu, huong_cu;
  42. byte x_moi;
  43. x_cu = object[0][1];
  44. y_cu = object[0][2];
  45. huong_cu = object[0][3];
  46. //lấy thông tin
  47.  
  48. if (huong_cu == 1) { //gà quay về bên phải
  49. x_moi = x_cu + 1;
  50. lcd.Plus_Bitmap(x_moi, y_cu, 16, 16, ga_mai_16x16, 0, MIRROR, BLACK);
  51. // xoay bitmap (mirror)
  52. //
  53. }
  54.  
  55. if (huong_cu == 3) { //gà quay về bên trái
  56. x_moi = x_cu - 1;
  57. lcd.Plus_Bitmap(x_moi, y_cu, 16, 16, ga_mai_16x16, 0, NO_MIRROR, BLACK);
  58. // không xoay (non mirror)
  59. }
  60. //ghi lại thông tin
  61. object[0][1] = x_moi;
  62. lcd.display();
  63.  
  64. } //vẽ gà
  65. void xoa_ga(byte x, byte y)
  66. {
  67. lcd.fillrect(x, y, 18, 18, DELETE);
  68. lcd.display();
  69. } //xóa gà
  70. void ga_di_va_de_trung()
  71. { // gà đi và đẻ trứng
  72. //////////// XỬ LÍ GÀ////////////
  73. //b1: cấp giấy khai sinh
  74. if (object[0][0] == 0) {
  75. // nếu không tồn tại gà thì phải tạo gà
  76. // cấp thuộc tính cho đối tượng gà
  77. object[0][1] = Xmin + 5; //hoành độ ban đầu
  78. object[0][2] = Ymin; // tung độ ban đầu
  79. object[0][3] = 1; //hướng sang bên phải
  80. object[0][0] = 1; //cấp quyền tồn tại
  81. }
  82. //b2: gà đi và quay đầu
  83. //lấy thông tin;
  84. if (object[0][1] <= Xmin) {
  85. // nếu gà đến biên trái thì phải quay đầu về bên phải
  86. object[0][3] = 1;
  87. //ghi lại thông tin
  88. }
  89.  
  90. if (object[0][1] >= Xmax) {
  91. // nếu gà đến biên phải thì phải quay đầu về bên trái
  92. object[0][3] = 3;
  93. //ghi lại thông tin
  94. }
  95. ///////////GÀ ĐANG ĐI/////////
  96. // lấy tt
  97.  
  98. xoa_ga(object[0][1], object[0][2]); //xóa ảnh cũ
  99. di_chuyen_ga(); // vẽ ảnh mới
  100. }
  101. //===============================================================
  102. ////////////////////TRỨNG RƠI//////////////////////
  103. void ve_trung(byte x, byte y)
  104. {
  105. lcd.bitmap(x, y, 6, 7, trung_6x7, BLACK);
  106. lcd.display();
  107. }
  108. void xoa_trung(byte x, byte y)
  109. {
  110. //xóa = hình chữ nhật màu trắng
  111. lcd.fillrect(x, y, 7, 7, DELETE);
  112. lcd.display();
  113. }
  114. void di_chuyen_trung(byte huong_cu, byte i)
  115. {
  116. byte x_cu, y_cu, x_moi, y_moi, ton_tai, huong_moi;
  117. //lây tt
  118. x_cu = object[i][1];
  119. y_cu = object[i][2];
  120. ton_tai = object[i][0];
  121. if ((huong_cu == 4) && (ton_tai == 1)) {
  122. //trứng rơi xuống dưới;
  123. y_moi = y_cu + 1;
  124. x_moi = x_cu;
  125. huong_moi = huong_cu;
  126. ve_trung(x_moi, y_moi);
  127. }
  128. //ghi tt
  129. object[i][1] = x_moi;
  130. object[i][2] = y_moi;
  131. object[i][3] = huong_moi;
  132. }
  133. void ve_trung_roi()
  134. {
  135. for (byte i = 1; i <= 3; i++) { // xét lần lượt 3 quả trứng
  136.  
  137. /*
  138. if((object[i][3]==3)||(object[i][3]==1)){
  139. // nếu trứng i này đang bay theo parabol
  140. //thì phải nhảy sang trứng khác
  141. */
  142.  
  143. //vẽ trứng rơi
  144. if (object[i][0] == 0) {
  145.  
  146. // nếu không tồn tại trứng thì phải tạo trứng
  147. //b1: chuẩn bị sẵn tọa độ bằng random
  148. randomSeed(millis() % 5000);
  149. byte X_random;
  150. X_random = random(Xmin, Xmax);
  151. // lưu thông tin
  152. object[i][1] = X_random;
  153. //chương trình chỉ chạy 1 lần mà thôi
  154. }
  155. //khi gà đi đến vị trí chuẩn bị sẵn này, trứng bắt đầu được tạo và rơi
  156. if (object[i][1] == object[0][1]) { // thỏa mãn trùng tọa độ
  157. //b2: cấp giấy khai sinh
  158. // cấp thuộc tính cho đối tượng trứng
  159. //(nên nhớ đã có hoành độ Random)
  160. object[i][2] = Ymin + 10; // tung độ ban đầu
  161. object[i][3] = 4; //hướng xuống dưới
  162. object[i][0] = 1; //cấp quyền tồn tại
  163. }
  164. //b2 : trứng roi
  165. //lấy thông tin
  166.  
  167. xoa_trung(object[i][1], object[i][2]); //xóa ảnh cũ
  168. di_chuyen_trung(object[i][3], i); // vẽ ảnh mới
  169. //b3: Trứng chạm đất và vỡ
  170. // hàm test nếu tung độ quá biên thì mất quả trứng đó
  171. if (object[i][2] >= Ymax) {
  172. object[i][0] = 0; // xóa quyền tồn tại
  173. }
  174. } //for
  175. }
  176. //========================================================
  177.  
  178. void loop()
  179. {
  180.  
  181. ga_di_va_de_trung();
  182. ve_trung_roi();
  183. delay(100);
  184. }

Kết quả test thử

6

Di chuyển nhân vật

  1. #include "ST7565_homephone.h"
  2. // add a bitmap library of a 16x16 fruit icon
  3. #include "bmps.h"
  4. ST7565 lcd(3, 4, 5, 6);
  5.  
  6. #ifdef __AVR__
  7. #include <avr/io.h>
  8. #include <avr/pgmspace.h>
  9. #endif
  10. /** Nhân vật Cả Mẹo (22x18)pixel
  11. */
  12. const static unsigned char __attribute__((progmem)) ca_meo_22x18[] = {
  13. 0x60, 0x9C, 0x62, 0x01, 0x01, 0xC1, 0x26, 0x29, 0x29, 0x4B, 0x4E, 0x48, 0x70, 0x00, 0xC0, 0x80,
  14. 0x80, 0x80, 0x80, 0x80, 0x80, 0xC0, 0x00, 0x00, 0x01, 0x01, 0x02, 0xE4, 0xFF, 0xFE, 0xFE, 0xFE,
  15. 0xFC, 0x1C, 0x0E, 0x06, 0x1F, 0x21, 0x52, 0x44, 0x48, 0x52, 0x21, 0x1F, 0x00, 0x00, 0x64, 0x70,
  16. 0x2F,
  17.  
  18. };
  19. /** Nhân vật Dần Béo (23x19)pixel
  20. */
  21. const static unsigned char __attribute__((progmem)) dan_beo_23x19[] = {
  22. 0x00, 0x00, 0x80, 0x43, 0xB2, 0x0F, 0x86, 0x44, 0x5C, 0xA2, 0xA6, 0x5C, 0x50, 0xB0, 0x40, 0x00,
  23. 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x40, 0xE3, 0xF4, 0xFA, 0xF0, 0xF7, 0x28, 0x78,
  24. 0xD8, 0xA8, 0xA8, 0xA4, 0x90, 0x58, 0x3E, 0x0A, 0x11, 0x11, 0x11, 0x11, 0x0A, 0x04, 0x07, 0x07,
  25. 0x06, 0x06, 0x05, 0x07, 0x07, 0x04,
  26. };
  27. /* mũi tên
  28. *
  29. */
  30. const static unsigned char __attribute__((progmem)) mui_ten_5x4[] = {
  31.  
  32. 0x01, 0x07, 0x0F, 0x07, 0x01,
  33.  
  34. };
  35. // mảng cho 2 nhân vật Cả mẹo(0) và Dần béo(1)
  36. byte object2[2][4] = { 0 };
  37. //object[i][0]: tồn tại hay không
  38. //object[i][1]: tọa độ x
  39. //object[i][2]: tọa độ y
  40. //object[i][3]: hướng (1 phải, 2 trên , 3 trái, 4 dưới)
  41. //
  42. byte chon_nv_A;
  43. byte chon_nv_B;
  44. //lựa chọn nhân vật, mặc định A được chọn trước
  45. byte Xmin, Ymin, Xmax, Ymax; //biên
  46. //cài đặt chân input
  47. #define fight_b A5
  48. #define select_b A4
  49. #define right_b A3
  50. #define up_b A2
  51. #define left_b A1
  52. #define down_b A0
  53. // Chương trình chạy 1 lần
  54. void setup()
  55. {
  56. Serial.begin(9600);
  57. lcd.ON();
  58. lcd.SET(23, 0, 0, 0, 4);
  59.  
  60. pinMode(left_b, INPUT_PULLUP);
  61. pinMode(down_b, INPUT_PULLUP);
  62. pinMode(right_b, INPUT_PULLUP);
  63. pinMode(up_b, INPUT_PULLUP);
  64. pinMode(fight_b, INPUT_PULLUP);
  65. pinMode(select_b, INPUT_PULLUP);
  66.  
  67. Xmin = 0;
  68. Xmax = 125;
  69. Ymin = 0;
  70. Ymax = 63;
  71. chon_nv_A = 1;
  72. chon_nv_B = 0;
  73. }
  74.  
  75. ////////ĐIỀU KHIỂN 2 NHÂN VẬT//////////////////////
  76. void ve_nhan_vat(byte x, byte y, byte huong, byte i)
  77. {
  78. switch (i) {
  79.  
  80. case 0:
  81. // vẽ Cả Mẹo
  82. if (huong == 1) {
  83. //quay về bên phải
  84. lcd.Plus_Bitmap(x, y, 22, 18, ca_meo_22x18, 0, NO_MIRROR, BLACK);
  85. }
  86. if (huong == 3) {
  87. //quay về bên trái
  88. lcd.Plus_Bitmap(x, y, 22, 18, ca_meo_22x18, 0, MIRROR, BLACK);
  89. }
  90. lcd.display();
  91. break;
  92. case 1:
  93.  
  94. if (huong == 1) {
  95. //quay về bên phải
  96. lcd.Plus_Bitmap(x, y, 23, 19, dan_beo_23x19, 0, NO_MIRROR, BLACK);
  97. }
  98. if (huong == 3) {
  99. //quay về bên trái
  100. lcd.Plus_Bitmap(x, y, 23, 19, dan_beo_23x19, 0, MIRROR, BLACK);
  101. }
  102.  
  103. lcd.display();
  104. //vẽ Dần Béo
  105. break;
  106. default:
  107. break;
  108. } //switch
  109.  
  110. } // ve nhân vật
  111. void xoa_nhan_vat(byte x, byte y)
  112. {
  113. lcd.fillrect(x, y - 7, 24, 19 + 7, DELETE);
  114. lcd.display();
  115.  
  116. } // xóa nhân vật
  117. void ve_mui_ten(byte x, byte y)
  118. {
  119. // mũi tên sẽ chỉ vào nhân vật i
  120. lcd.bitmap(x, y, 5, 4, mui_ten_5x4, BLACK);
  121. lcd.display();
  122.  
  123. } // vẽ mũi tên
  124. void xoa_mui_ten(byte i)
  125. {
  126. lcd.fillrect(object2[i][1] - 5, object2[i][2] - 7, 20, 5, DELETE);
  127. lcd.display();
  128. } //xóa mũi tên
  129.  
  130. void di_chuyen_nhan_vat(byte i)
  131. {
  132. byte x_cu, y_cu, huong_cu;
  133. byte x_moi;
  134. //lấy thông tin
  135. x_cu = object2[i][1];
  136. y_cu = object2[i][2];
  137. huong_cu = object2[i][3];
  138. if (huong_cu == 1) {
  139. //đi về bên phải
  140. x_moi = x_cu + 4;
  141. ve_nhan_vat(x_moi, y_cu, huong_cu, i);
  142. ve_mui_ten(x_cu + 5, y_cu - 7);
  143. }
  144.  
  145. if (huong_cu == 3) {
  146. //đi về bên trái
  147.  
  148. if (x_cu >= Xmin + 4 * 2) {
  149. //chống quá biên
  150. x_moi = x_cu - 4;
  151. }
  152. else {
  153. x_moi = x_cu;
  154. }
  155. ve_nhan_vat(x_moi, y_cu, huong_cu, i);
  156.  
  157. ve_mui_ten(x_cu + 5, y_cu - 7);
  158. }
  159. //lưu thông tin
  160.  
  161. object2[i][1] = x_moi;
  162.  
  163. } //di chuyển nhân vật
  164. void xu_li_nhan_vat()
  165. {
  166. //b0: điều khiển lựa chọn nhân vật
  167. if (digitalRead(fight_b) == 0) { //fight được nhấn
  168. if (chon_nv_A == chon_nv_B) { // đề phòng A bằng B
  169. chon_nv_A = 1;
  170. chon_nv_B = 0;
  171. }
  172. if (chon_nv_A != chon_nv_B) { //để dảm bảo A khác B
  173. chon_nv_A = !chon_nv_A;
  174. chon_nv_B = !chon_nv_B;
  175. //đổi
  176. }
  177. } //if
  178. //b1: chọn nhân vật
  179. byte i = 0;
  180. if ((chon_nv_A == 1) && (chon_nv_B == 0)) {
  181. i = 0; // nhân vật Cả Mẹo
  182. }
  183. if ((chon_nv_A == 0) && (chon_nv_B == 1)) {
  184. i = 1; // nhân vật Dần Béo
  185. }
  186. if (digitalRead(fight_b) == 0) { //fight được nhấn
  187.  
  188. xoa_mui_ten(!i);
  189. ve_mui_ten(object2[i][1] + 5, object2[i][2] - 7);
  190. }
  191.  
  192. //b2: cấp giấy khai sinh (chỉ dùng khi start game)
  193. if (object2[i][0] == 0) {
  194. // nếu không tồn tại gà thì phải tạo gà
  195. // cấp thuộc tính cho đối tượng gà
  196. object2[i][1] = Xmin + 50 * i; //hoành độ ban đầu
  197. object2[i][2] = Ymax - 19; // tung độ ban đầu
  198. object2[i][3] = 1; //hướng về bên phải
  199. object2[i][0] = 1; //cấp quyền tồn tại
  200. }
  201.  
  202. //b4: vẽ 2 nhân vật
  203.  
  204. for (byte j = 0; j <= 1; j++) {
  205.  
  206. ve_nhan_vat(object2[j][1], object2[j][2], object2[j][3], j);
  207. }
  208. //b5: điều khiển hướng nhân vật i
  209. byte read_button;
  210. read_button = lcd.Pullup_4(right_b, up_b, left_b, down_b);
  211. if (read_button == 1) { // nút right
  212. //ghi lại tt hướng
  213. object2[i][3] = 1;
  214. xoa_mui_ten(!i);
  215.  
  216. xoa_nhan_vat(object2[i][1], object2[i][2]); //xóa ảnh cũ
  217. //lấy thông tin tọa độ để xóa
  218.  
  219. di_chuyen_nhan_vat(i); // vẽ ảnh mới
  220. }
  221.  
  222. if (read_button == 3) { // nút left
  223. object2[i][3] = 3;
  224. xoa_mui_ten(!i);
  225. xoa_nhan_vat(object2[i][1], object2[i][2]); //xóa ảnh cũ
  226. //lấy thông tin tọa độ để xóa
  227.  
  228. di_chuyen_nhan_vat(i); // vẽ ảnh mới
  229. }
  230.  
  231. } //xử lí nhân vật
  232. //==================================================
  233. void loop()
  234. {
  235. xu_li_nhan_vat();
  236. delay(50);
  237. }

Kết quả

7

Xử lí nảy trứng

Giải phương trình quỹ đạo bay Parabol.

Trong đoạn code này

 
  1. byte X0; // tọa độ đỉnh parabol
  2. f_y_moi = 1.0 + sq((float(X0) - float(x_moi)) / 4.0); //phương trình

Với quy ước màn hình, trục tung hệ tọa độ có chiều hướng xuống dưới. Kết quả ta được phương trình của chuyển động ném xiên. 

Bay từ trái sang phải

  1. #include "ST7565_homephone.h"
  2. ST7565 lcd(3, 4, 5, 6); //RST, SCLK, A0, SID
  3. void setup()
  4. {
  5. lcd.ON();
  6. lcd.SET(23, 0, 0, 0, 4);
  7. }
  8. void loop()
  9. {
  10. float y;
  11. byte X0 = 60; // hoành độ đỉnh parabol
  12. for (byte x = 30; x < 100; x += 1) {
  13. y = 1.0 + sq((float(X0) - float(x)) / 4.0); //phương trình
  14. lcd.FillCircle(x, byte(y), 4, BLACK);
  15. lcd.Display();
  16. delay(1);
  17. lcd.Clear(); // xóa toàn màn hình
  18. }
  19. }

Bay từ phải sang trái

  1. #include "ST7565_homephone.h"
  2. ST7565 lcd(3, 4, 5, 6); //RST, SCLK, A0, SID
  3. void setup()
  4. {
  5. lcd.ON();
  6. lcd.SET(23, 0, 0, 0, 4);
  7. }
  8. void loop()
  9. {
  10. float y;
  11. byte X0 = 60; // hoành độ đỉnh parabol
  12. for (byte x = 100; x > 30; x -= 1) {
  13. y = 1.0 + sq((float(X0) - float(x)) / 4.0); //phương trình
  14. lcd.FillCircle(x, byte(y), 4, BLACK);
  15. lcd.Display();
  16. delay(1);
  17. lcd.Clear(); // xóa toàn màn hình
  18. }
  19. }

8

Kết

Code đã dài, sau khi kết hợp các module với nhau, ta được Game hoàn chỉnh

GAME - ST7565 - Game hứng trứng - phiên bản nâng cấp
Bình luận
Nội dung này chưa có bình luận, hãy gửi bình luận đầu tiên của bạn.
VIẾT BÌNH LUẬN CỦA BẠN