Add Face-GameBoy Snake example

Author: EeeeBin

examples/Face/Snake_Gameboy/GameBoard.cpp

@@ -0,0 +1,236 @@
+/******************************************************************************
+ * M5Snake : Game board management                                            *
+ * -------------------------------                                            *
+ * Manage the game board (storage in memory and display                       *
+ * Author: Olivier Staquet                                                    *
+ * Last version available on https://github.com/ostaquet/M5Snake              *
+ *****************************************************************************/
+#include "GameBoard.h"
+
+/**
+ * Initialize
+ */
+void GameBoardClass::begin(uint8_t _max_game_cycles) {
+  // Keep the number of game cycles
+  max_game_cycles = _max_game_cycles;
+  current_game_cycle = 0;
+  
+  // Init the board at blank
+  for(uint8_t x = 0; x < board_width; x++) {
+    for(uint8_t y = 0; y < board_height; y++) {
+      board_data[x][y] = BLOCK_STATUS_EMPTY;
+      board_changes[x][y] = 0;
+    }
+  }
+
+  // Set screen to blank
+  M5.Lcd.fillScreen(BLACK);
+}
+
+/**
+ * Refresh display
+ */
+void GameBoardClass::refresh() {
+  // Check where there are some changes
+  for(uint8_t x = 0; x < board_width; x++) {
+    for(uint8_t y = 0; y < board_height; y++) {
+      // Check the cell
+      if(board_changes[x][y] > 0) {
+        // There is a change...
+        drawChange(x, y);
+        // Reset the change tracking
+        board_changes[x][y] = 0;
+      }
+    }
+  }
+}
+
+/**
+ * Put the head of the snake on the board and go on right
+ */
+void GameBoardClass::startSnake() {
+  // Define the middle of the screen
+  setCell(board_width / 2, board_height / 2, BLOCK_STATUS_HEAD);
+
+  // Define the direction
+  setDirection(DIRECTION_RIGHT);
+}
+
+/**
+ * Make the snake move on the board
+ * Return boolean true if OK, false if game over
+ */
+bool GameBoardClass::moveSnake() {
+  // Check if it is a cycle to move
+  if(current_game_cycle < max_game_cycles) {
+    // Wait for the next cycle
+    current_game_cycle++;
+    return true;
+  } else {
+    // Reset the game cycle
+    current_game_cycle = 0; 
+  }
+  
+  // Add 1 to all current block with between 1 and 512
+  // to keep count of the movement of the snake (1 = head, 2 = 2nd block after head...)
+  for(uint8_t x = 0; x < board_width; x++) {
+    for(uint8_t y = 0; y < board_height; y++) {
+      if(board_data[x][y] < BLOCK_STATUS_CHERRY && board_data[x][y] != BLOCK_STATUS_EMPTY) {
+        board_data[x][y] = board_data[x][y] + 1;
+      }
+    }
+  }
+  
+  // Next move to be defined
+  int8_t next_block_x = current_head_x;
+  int8_t next_block_y = current_head_y;
+  
+  // Define the next move of the head
+  switch(current_direction) {
+    case DIRECTION_UP :
+      next_block_y = current_head_y - 1;
+      break;
+    case DIRECTION_RIGHT :
+      next_block_x = current_head_x + 1;
+      break;
+    case DIRECTION_DOWN :
+      next_block_y = current_head_y + 1;
+      break;
+    case DIRECTION_LEFT :
+      next_block_x = current_head_x - 1;
+      break;
+  }
+
+  // Check if the move is valid...
+  // Check the limit of the board for X
+  if(next_block_x < 0 || next_block_x >= board_width) {
+    return false;
+  }
+  // Check the limit of the board for Y
+  if(next_block_y < 0 || next_block_y >= board_height) {
+    return false;
+  }
+
+  // Check if there is a cherry on the cell (if not a cherry, remove the last block of the tail
+  if(board_data[next_block_x][next_block_y] != BLOCK_STATUS_CHERRY) {
+    removeTail();
+  }
+  
+  // Check if there is another part of the snake
+  if(board_data[next_block_x][next_block_y] > BLOCK_STATUS_EMPTY && board_data[next_block_x][next_block_y] < BLOCK_STATUS_CHERRY) {
+    return false;
+  }
+
+  // OK, move the head of the snake
+  setCell(next_block_x, next_block_y, BLOCK_STATUS_HEAD);
+
+  return true;
+}
+
+/**
+ * Identify and remove the tail (last block of the snake)
+ */
+void GameBoardClass::removeTail() {
+  uint16_t greatest_value = 0;
+  uint8_t tail_x = 0;
+  uint8_t tail_y = 0;
+
+  // Find the cell with the biggest value (it is the tail)
+  for(uint8_t x = 0; x < board_width; x++) {
+    for(uint8_t y = 0; y < board_height; y++) {
+      if(board_data[x][y] < BLOCK_STATUS_CHERRY) {
+        if(board_data[x][y] > greatest_value) {
+          tail_x = x;
+          tail_y = y;
+          greatest_value = board_data[x][y];
+        }
+      }
+    }
+  }
+
+  // Remove the tail
+  setCell(tail_x, tail_y, BLOCK_STATUS_EMPTY);
+}
+
+/**
+ * Get the max score
+ */
+uint16_t GameBoardClass::getMaxScore() {
+  uint16_t greatest_value = 0;
+
+  // Find the cell with the biggest value (it is the tail)
+  for(uint8_t x = 0; x < board_width; x++) {
+    for(uint8_t y = 0; y < board_height; y++) {
+      if(board_data[x][y] < BLOCK_STATUS_CHERRY) {
+        if(board_data[x][y] > greatest_value) {
+          greatest_value = board_data[x][y];
+        }
+      }
+    }
+  }
+
+  return greatest_value - 1;
+}
+
+/**
+ * Draw the change of one cell
+ */
+void GameBoardClass::drawChange(uint8_t x, uint8_t y) {
+  // Compute box position
+  uint16_t pos_x = x * BLOCK_SIZE;
+  uint16_t pos_y = y * BLOCK_SIZE;
+  
+  // Depending on the content of the cell, draw the box
+  switch(board_data[x][y]) {
+    case BLOCK_STATUS_EMPTY :
+      M5.Lcd.fillRect(pos_x, pos_y, BLOCK_SIZE, BLOCK_SIZE, BLACK);
+      break;
+
+    case BLOCK_STATUS_CHERRY :
+      M5.Lcd.fillRect(pos_x, pos_y, BLOCK_SIZE, BLOCK_SIZE, BLACK);
+      M5.Lcd.fillCircle(pos_x + BLOCK_SIZE / 2, pos_y + BLOCK_SIZE / 2, BLOCK_SIZE / 2 - 1, RED);
+      break;
+
+    default :
+      M5.Lcd.drawRect(pos_x, pos_y, BLOCK_SIZE, BLOCK_SIZE, BLACK);
+      M5.Lcd.fillRect(pos_x + 1, pos_y + 1, BLOCK_SIZE - 2, BLOCK_SIZE - 2, WHITE);
+      break;
+  }
+}
+
+/**
+ * Add a ramdom cherry on the board
+ */
+void GameBoardClass::addCherry() {
+  uint8_t pos_x = random(0, board_width);
+  uint8_t pos_y = random(0, board_height);
+
+  while(board_data[pos_x][pos_y] != BLOCK_STATUS_EMPTY) {
+    pos_x = random(0, board_width);
+    pos_y = random(0, board_height);
+  }
+
+  setCell(pos_x, pos_y, BLOCK_STATUS_CHERRY);
+}
+
+/**
+ * Set direction
+ */
+void GameBoardClass::setDirection(uint8_t direction) {
+  current_direction = direction;
+}
+
+/**
+ * Set a value in a cell
+ */
+void GameBoardClass::setCell(uint8_t x, uint8_t y, uint16_t status) {
+  board_data[x][y] = status;
+  board_changes[x][y] = 1;
+
+  if(status == BLOCK_STATUS_HEAD) {
+    current_head_x = x;
+    current_head_y = y;
+  }
+}
+
+GameBoardClass GameBoard;

examples/Face/Snake_Gameboy/GameBoard.h

@@ -0,0 +1,89 @@
+/******************************************************************************
+ * M5Snake : Game board management                                            *
+ * -------------------------------                                            *
+ * Manage the game board (storage in memory and display                       *
+ * Author: Olivier Staquet                                                    *
+ * Last version available on https://github.com/ostaquet/M5Snake              *
+ *****************************************************************************/
+#ifndef _GAMEBOARD_H_
+#define _GAMEBOARD_H_
+
+#include <Arduino.h>
+#include <M5Stack.h>
+
+#define LCD_WIDTH                 320
+#define LCD_HEIGHT                240
+
+#define BLOCK_SIZE                16
+
+#define BLOCK_STATUS_EMPTY        0x00            // Empty block
+#define BLOCK_STATUS_HEAD         0x01            // Head of the snake
+// All values between 2 and 511                   // Body of the snake, greatest value = tail
+#define BLOCK_STATUS_CHERRY       0x200           // Cherry to increase the size of the snake
+
+#define DIRECTION_UP              0x01
+#define DIRECTION_RIGHT           0x02
+#define DIRECTION_DOWN            0x03
+#define DIRECTION_LEFT            0x04
+
+class GameBoardClass {
+  public:
+    // Initialize
+    void begin(uint8_t game_cycles = 4);
+
+    // Refresh display
+    void refresh();
+
+    // Start the snake
+    void startSnake();
+
+    // Make the snake move on the board
+    // Return boolean true if OK, false if game over
+    bool moveSnake();
+
+    // Set direction
+    void setDirection(uint8_t direction);
+
+    // Add a ramdom cherry on the board
+    void addCherry();
+
+    // Get the max score
+    uint16_t getMaxScore();
+    
+  private:
+    // Variables
+
+    // Current direction
+    uint8_t current_direction = 0x00;
+    uint8_t current_head_x = 0x00;
+    uint8_t current_head_y = 0x00;
+
+    // Cycles
+    uint8_t max_game_cycles = 4;
+    uint8_t current_game_cycle = 0;
+    
+    // Keep track of the size of the board
+    uint8_t board_width = LCD_WIDTH / BLOCK_SIZE;
+    uint8_t board_height = LCD_HEIGHT / BLOCK_SIZE;
+
+    // Game board in memory
+    uint16_t board_data[LCD_WIDTH / BLOCK_SIZE][LCD_HEIGHT / BLOCK_SIZE];
+
+    // Track change of the game board to optimize refresh
+    uint8_t board_changes[LCD_WIDTH / BLOCK_SIZE][LCD_HEIGHT / BLOCK_SIZE];
+
+
+    // Internal functions
+    // Set a value in a cell
+    void setCell(uint8_t x, uint8_t y, uint16_t status);
+
+    // Draw a cell with the change indicated
+    void drawChange(uint8_t x, uint8_t y);
+
+    // Remove the tail of the snake (put the biggest cell at blank)
+    void removeTail();
+};
+
+extern GameBoardClass GameBoard;
+
+#endif // _GAMEBOARD_H_

examples/Face/Snake_Gameboy/GameboyInput.cpp

@@ -0,0 +1,48 @@
+/******************************************************************************
+ * M5Snake : Input management from Gameboy faces                              *
+ * ---------------------------------------------                              *
+ * Management of input coming from the face Gameboy                           *
+ * Author: Olivier Staquet                                                    *
+ * Last version available on https://github.com/ostaquet/M5Snake              *
+ *****************************************************************************/
+#include "GameboyInput.h"
+
+/**
+ * Initialize
+ */
+void GameboyInputClass::begin(uint8_t _i2c_address, uint8_t _pin_int_face) {
+  // Store local info
+  i2c_address = _i2c_address;
+  pin_int_face = _pin_int_face;
+  
+  // Prepare the detection of activity
+  pinMode(pin_int_face, INPUT_PULLUP);
+
+  // Init the I2C
+  Wire.begin();
+}
+
+/**
+ * Check if button pressed and return which one
+ */
+uint8_t GameboyInputClass::getActivity() {
+  // Check if there is activity on interrupt
+  if(digitalRead(pin_int_face) == LOW) {
+    // If yes, request 1 byte from the panel
+    Wire.requestFrom(i2c_address, (uint8_t)1);
+
+    // Check if data on the I2C is available
+    while (Wire.available()) {
+      // Receive one byte as character
+      uint8_t key_val = Wire.read();
+      if(key_val != 0x00) {
+        return key_val;
+      }
+    }
+  }
+
+  // No activity to send back
+  return GAMEBOY_KEY_NONE;
+}
+
+GameboyInputClass GameboyInput;