#include "common.h"
#include "menu.h"
#include "buttons.h"
#include "screen.h"
#include "games.h"
#include "wifictrl.h"

typedef enum
{
  MAIN_STATE_MENU = (0),
  MAIN_STATE_SETTINGS,
  MAIN_STATE_GAMES,
  MAIN_STATE_MAX,
} MainState_e;

static MainState_e _mainstate = MAIN_STATE_MENU;
static Menu_st _mainmenu;

void setup()
{
  /* Serial */
  Serial.begin(115200);
  // delay(3000);              //Delay for Serial Monitor startup

  /* Screen */
  if (!SCREEN_Init()) {
    while (1) {
      #if defined(LED_BUILTIN)
        pinMode(LED_BUILTIN, OUTPUT);
        digitalWrite(LED_BUILTIN, LOW);
        delay(200);
        digitalWrite(LED_BUILTIN, HIGH);
        delay(200);
      #else
        delay(10);
      #endif
    }
  }
  delay(GAME_START_SCREEN_TIME);

  /* Database */
  DB_Init();

  /* Games */
  GAMES_Init();

  /* Buttons */
#if defined(KEYS_CONTROL_BUTTONS)
  BUTTONS_Init();
#endif

  /* Joystick */
#if defined(KEYS_CONTROL_JOYSTICK)
  JOYSTICK_Init();
#endif

  /* WiFi */
#if defined(KEYS_CONTROL_WIFI)
  WIFI_Init();
#endif

  /* MENU */
  MAINMENU_Init(&_mainmenu, GAMES_GetTotalGamesNum(), GAMES_GetGameName);
  MAINMENU_DrawPage(&_mainmenu, "MAIN MENU");
}

void loop()
{
  int8_t gameindex = 0;

  switch (_mainstate)
  {
    case MAIN_STATE_MENU:
      gameindex = MAINMENU_Task(&_mainmenu);
      if (gameindex >= 0)
      {
        _mainstate = MAIN_STATE_GAMES;
        GAMES_Start(gameindex);

        _mainstate = MAIN_STATE_MENU;
        MAINMENU_DrawPage(&_mainmenu, "MAIN MENU");
      }
      break;

    case MAIN_STATE_GAMES:

      break;

    default:

      break;
  }

  WOKWI_DELAY
}

sketch.ino

diagram.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

Adafruit SSD1306


libraries.txt

#include "common.h"
#include "games.h"
#include "screen.h"
#include "buttons.h"
#include "menu.h"

#define BATBON_SETTINGS_NUM           3
#define WINSCORE 7

typedef struct 
{
  boolean stopAnimate = 0; // this is set to 1 when a collision is detected
  int score = 0; // score - this affects the difficulty of the game
  int score2 = 0; // score - this affects the difficulty of the game
  boolean mute = 0;
  boolean newHigh = 0;
  int player; //0 to 128-platformWidth  - this is the position of the player
  int player2; //0 to 128-platformWidth  - this is the position of the player
} BatBonanzaInfo_st;



int lastPlayer;
int lastPlayer2;
int platformWidth = 16; 

int ballx = 62*8; // coordinate of the ball
int bally = 50*4; // coordinate of the ball
int vdir = -4; // vertical direction and step  distance
int hdir = -8; // horizontal direction and step distance

int mode = 0;

int perturbation = 0;
int pFactor = 12;
BatBonanzaInfo_st _batInfo;

void startGame(void);
void drawPlatform(void);
void drawPlatform2(void);
void drawBall(int x, int y);
void blankBall(int x, int y);

void GAME_BATBON_DrawLS(long, byte);
void GAME_BATBON_DrawRS(long, byte);

void GAME_BATBONANZA_Init()
{
  SCREEN_Clear(DISPLAY_SCREEN);
  ssd1306_char_f6x8(0, 1, "   ---------------  ");
  ssd1306_char_f6x8(0, 2, "        B A T       ");
  ssd1306_char_f6x8(0, 4, "    B O N A N Z A   ");
  ssd1306_char_f6x8(0, 5, "   ---------------  ");
  ssd1306_char_f6x8(0, 7, "   by andy jackson  "); // see comments above !

  delay(GAME_START_SCREEN_TIME);

  _batInfo.stopAnimate = 0;
  _batInfo.score = 0;
  _batInfo.score2 = 0;
  mode = 1;
}

char *GAME_BATBON_GetSettingText(uint8_t index)
{
  char *settings[BATBON_SETTINGS_NUM] = {"Normal", "Expert", "Tough"};
  return (index < BATBON_SETTINGS_NUM)? settings[index] : NULL;
}

void GAME_BATBONANZA_Settings()
{
  int8_t gamemode = -1;
  Menu_st menu;

  MAINMENU_Init(&menu, BATBON_SETTINGS_NUM, &GAME_BATBON_GetSettingText);
  MAINMENU_DrawPage(&menu, "SETTINGS");

  while (gamemode < 0)
  {
    gamemode = MAINMENU_Task(&menu);
    if (gamemode >= 0) {
      switch (gamemode)
      {
        case 0: mode = 1; break;
        case 1: mode = 4; break;
        case 2: mode = 3; break;
        default: gamemode = -1; break;
      }
    }

    WOKWI_DELAY
  }
}

void GAME_BATBONANZA_Start(uint8_t gameindex)
{
  ballx = 64*8;
  bally = 32*4;
  hdir = -8;
  vdir = -4;
  int actualy, actualx;
  int factor = 0;
  int waitCount = 0;
  int lastx=64*8, lasty=32*4;

  GAME_BATBONANZA_Settings();
  GAME_BATBONANZA_Init();
  SCREEN_Clear(DISPLAY_SCREEN);
  _batInfo.player=64;
  _batInfo.player2=64;
  lastPlayer = 64;
  lastPlayer2 = 64;
  _batInfo.score = 0; // obvious
  _batInfo.score2 = 0; // obvious
  perturbation = 0;
    
  startGame();
  while (_batInfo.stopAnimate == 0) {
    while(1) {
    BUTTONS_Task();
    waitCount++;

    if (BUTTONS_Get(BTN_UP, BTN_NO_DELAY) == BUTTON_PRESSED) {
      _batInfo.player-= 3;
    }
    _batInfo.player+=1;
    if (_batInfo.player > 48) _batInfo.player = 48;
    if (_batInfo.player <0) _batInfo.player = 0;
    
    if (mode == 1 || mode == 3 || mode == 4) {
      if(waitCount >= 3) {
        waitCount = 0;
        perturbation = perturbation - 2 + random(0,5);
        if (perturbation > pFactor) perturbation = pFactor - 2;
        if (perturbation < pFactor*-1) perturbation = (pFactor*-1)+2;
      }
      _batInfo.player2 = (bally/4 -8)+perturbation;
    }
    if (_batInfo.player2 > 48) _batInfo.player2 = 48;
    if (_batInfo.player2 <0) _batInfo.player2 = 0;

    actualy = floor(bally/4);
    actualx = floor(ballx/8);
    
    // bounce off the sides of the screen
    if ((actualy+vdir<63&&vdir>01) || (actualy- vdir>6&&vdir<0)){
      bally+=vdir;
    }else {
        vdir = vdir*-1;
    }
    ballx+=hdir;

    actualy = floor(bally/4);
    actualx = floor(ballx/8);
    
    // check it hits the left pad and deal with bounces and misses
    if (actualx <= 4) {
      if(actualy<_batInfo.player-1||actualy>_batInfo.player+platformWidth+1){ 
        _batInfo.score2++;
    
        ballx = 5*8;
        bally = _batInfo.player*4;

        hdir = 13;
        if (vdir > 0) {
          vdir = 2;
        } else vdir = -2;
        
        ssd1306_fillscreen(0x00);        
        SCREEN_DrawNumber(46,4,_batInfo.score);
        SCREEN_DrawNumber(78,4,_batInfo.score2);        
        if (_batInfo.score2 < WINSCORE) {
          for (int i = 0; i<1000; i = i+ 100){
            GAMES_Beep(50,i);
          }
          for (int incr=0;incr<3;incr++) {
              ssd1306_send_data_stop();
              ssd1306_setpos(78,4);
              ssd1306_send_data_start();
              SCREEN_SendBlock(0);
              SCREEN_SendBlock(0);
              ssd1306_send_data_stop();
              delay(350);
              SCREEN_DrawNumber(78,4,_batInfo.score2);
              delay(350);
            }
            startGame();
        }
        perturbation = 0;
        break;
      }else if (actualy<_batInfo.player+1){        
        vdir = -6;
        hdir = 7;
      }else if (actualy<_batInfo.player+4){        
        vdir = -4;
        hdir = 10;
      }else if (actualy<_batInfo.player+7){        
        vdir = -2;
        hdir = 13;
      }else if (actualy<_batInfo.player+9){        
        vdir = 0;
        hdir = 14;
      }else if (actualy<_batInfo.player+12){        
        vdir = 2;
        hdir = 13;
      }else if (actualy<_batInfo.player+15){        
        vdir = 4;
        hdir = 10;
      }else {   
        vdir = 6;
        hdir = 7;
      }
      GAMES_Beep(20,600);
    }  
    
    // check it hits the right pad and deal with bounces
    if(actualx >= 122) {
      if(actualy<_batInfo.player2-1||actualy>_batInfo.player2+platformWidth+1){
        _batInfo.score++;
  
        ballx = 120*8;
        bally = _batInfo.player2*4;

        hdir = -13;
        if (vdir > 0) {
          vdir = 2;
        } else vdir = -2;

        ssd1306_fillscreen(0x00);        
        SCREEN_DrawNumber(46,4,_batInfo.score);
        SCREEN_DrawNumber(78,4,_batInfo.score2);
        if (_batInfo.score < WINSCORE) {
        for (int i = 0; i<1000; i = i+ 100){
            GAMES_Beep(50,i);
          }                
  
          for (int incr=0;incr<3;incr++) {
              ssd1306_setpos(46,4);
              ssd1306_send_data_start();
              SCREEN_SendBlock(0);
              SCREEN_SendBlock(0);
              ssd1306_send_data_stop();
              delay(350);
              SCREEN_DrawNumber(46,4,_batInfo.score);
              delay(350);
            }
            perturbation = 0;
            startGame();
        }        
        break;
      }else if (actualy<_batInfo.player2+1){        
        vdir = -6;
        hdir = -7;
      }else if (actualy<_batInfo.player2+4){        
        vdir = -4;
        hdir = -10;
      }else if (actualy<_batInfo.player2+7){        
        vdir = -2;
        hdir = -13;
      }else if (actualy<_batInfo.player2+9){        
        vdir = 0;
        hdir = -14;
      }else if (actualy<_batInfo.player2+12){        
        vdir = 2;
        hdir = -13;
      }else if (actualy<_batInfo.player2+15){        
        vdir = 4;
        hdir = -10;
      }else {   
        vdir = 6;
        hdir = -7;
      }
      GAMES_Beep(20,300);
    }      

    
    if (mode == 2 || mode == 3 || mode == 4) {
      factor = 8-floor((_batInfo.score-_batInfo.score2)/2); // expert modes
      if (factor < 2) factor = 2;
    } else {
      factor = 20-floor((_batInfo.score-_batInfo.score2)/2); // normal modes
      if (factor < 10) factor = 10;
    }
    
    delay(factor);
    
    // draw ball
    blankBall(floor(lastx/8),floor(lasty/4));  
    drawPlatform();
    drawPlatform2();
    drawBall(floor(ballx/8),floor(bally/4));
    lastx = ballx;
    lasty = bally;
    
    SCREEN_DrawNumber(28,0,_batInfo.score);
    SCREEN_DrawNumber(92,0,_batInfo.score2);
    if (_batInfo.score == WINSCORE || _batInfo.score2 == WINSCORE) {
      _batInfo.stopAnimate = 1;
      break;
    }
    }
 }

blankBall(floor(lastx/8),floor(lasty/4));  
blankBall(floor(ballx/8),floor(bally/4));  

if (_batInfo.score > _batInfo.score2) {
  ssd1306_char_f6x8(27, 3, "P L A Y E R 1"); 
} else {
  ssd1306_char_f6x8(27, 3, "P L A Y E R 2"); 
}
ssd1306_char_f6x8(27, 4, "             ");
ssd1306_char_f6x8(27, 5, "   W I N S   ");

for (int i = 0; i<1000; i = i+ 50){
  GAMES_Beep(50,i);
}


for (int incr=0;incr<6;incr++) {
    ssd1306_setpos(28,0);
    ssd1306_send_data_start();
    SCREEN_SendBlock(0);
    SCREEN_SendBlock(0);
    ssd1306_send_data_stop();
    ssd1306_setpos(92,0);
    ssd1306_send_data_start();
    SCREEN_SendBlock(0);
    SCREEN_SendBlock(0);
    ssd1306_send_data_stop();
    delay(350);
    SCREEN_DrawNumber(28,0,_batInfo.score);
    SCREEN_DrawNumber(92,0,_batInfo.score2);
    delay(350);
  }
}

void drawPlatform() {
  if (_batInfo.player != lastPlayer) {
    ssd1306_setpos(0,lastPlayer/8);
    ssd1306_send_data_start();
    ssd1306_send_byte(B00000000);
    ssd1306_send_data_stop();
    ssd1306_setpos(0,lastPlayer/8+1);
    ssd1306_send_data_start();
    ssd1306_send_byte(B00000000);
    ssd1306_send_data_stop(); 
    ssd1306_setpos(0,lastPlayer/8+2);
    ssd1306_send_data_start();
    ssd1306_send_byte(B00000000);
    ssd1306_send_data_stop(); 
  }  

  if (_batInfo.player%8!=0){
    ssd1306_setpos(0,_batInfo.player/8);
    ssd1306_send_data_start();
    ssd1306_send_byte((B11111111)<<_batInfo.player%8);
    ssd1306_send_data_stop();
    ssd1306_setpos(0,_batInfo.player/8+1);
    ssd1306_send_data_start();
    ssd1306_send_byte(B11111111);
    ssd1306_send_data_stop();    
    ssd1306_setpos(0,_batInfo.player/8+2);
    ssd1306_send_data_start();
    ssd1306_send_byte((B01111110)>>8-_batInfo.player%8);
    ssd1306_send_data_stop();
  } else {
    ssd1306_setpos(0,_batInfo.player/8);
    ssd1306_send_data_start();
    ssd1306_send_byte(B11111111);
    ssd1306_send_data_stop();
    ssd1306_setpos(0,_batInfo.player/8+1);
    ssd1306_send_data_start();
    ssd1306_send_byte(B11111111);
    ssd1306_send_data_stop();

  }
  lastPlayer = _batInfo.player;
}

void drawPlatform2() {

  if (_batInfo.player2 != lastPlayer2) {
    ssd1306_setpos(127,lastPlayer2/8);
    ssd1306_send_data_start();
    ssd1306_send_byte(B00000000);
    ssd1306_send_data_stop();
    ssd1306_setpos(127,lastPlayer2/8+1);
    ssd1306_send_data_start();
    ssd1306_send_byte(B00000000);
    ssd1306_send_data_stop(); 
    ssd1306_setpos(127,lastPlayer2/8+2);
    ssd1306_send_data_start();
    ssd1306_send_byte(B00000000);
    ssd1306_send_data_stop(); 
  }
  
  if (_batInfo.player2%8!=0){
    ssd1306_setpos(127,_batInfo.player2/8);
    ssd1306_send_data_start();
    ssd1306_send_byte((B11111111)<<_batInfo.player2%8);
    ssd1306_send_data_stop();
    ssd1306_setpos(127,_batInfo.player2/8+1);
    ssd1306_send_data_start();
    ssd1306_send_byte(B11111111);
    ssd1306_send_data_stop();        
    ssd1306_setpos(127,_batInfo.player2/8+2);
    ssd1306_send_data_start();
    ssd1306_send_byte((B01111110)>>8-_batInfo.player2%8);
    ssd1306_send_data_stop();
  } else {
    ssd1306_setpos(127,_batInfo.player2/8);
    ssd1306_send_data_start();
    ssd1306_send_byte((B11111111)<<0);
    ssd1306_send_data_stop();
    ssd1306_setpos(127,_batInfo.player2/8+1);
    ssd1306_send_data_start();
    ssd1306_send_byte((B11111111)<<0);
    ssd1306_send_data_stop();
  }
  lastPlayer2 = _batInfo.player2;
}

void blankBall(int x, int y) {
  if (y%8!=0){
    ssd1306_setpos(x,y/8);
    ssd1306_send_data_start();
    ssd1306_send_byte(B00000000);
    ssd1306_send_byte(B00000000);
    ssd1306_send_data_stop();
    
    ssd1306_setpos(x,y/8+1);
    ssd1306_send_data_start();
    ssd1306_send_byte(B00000000);
    ssd1306_send_byte(B00000000);
    ssd1306_send_data_stop();
  } else {
    ssd1306_setpos(x,y/8);
    ssd1306_send_data_start();
    ssd1306_send_byte(B00000000);
    ssd1306_send_byte(B00000000);
    ssd1306_send_data_stop();
  }
}


void drawBall(int x, int y) {
  if (y%8!=0){
    ssd1306_setpos(x,y/8);
    ssd1306_send_data_start();
    GAME_BATBON_DrawLS(0,y%8);
    ssd1306_send_data_stop();
    
    ssd1306_setpos(x,y/8+1);
    ssd1306_send_data_start();
    GAME_BATBON_DrawRS(0,8-y%8);
    ssd1306_send_data_stop();
  } else {
    ssd1306_setpos(x,y/8);
    ssd1306_send_data_start();
    GAME_BATBON_DrawLS(0,0);
    ssd1306_send_data_stop();
  }
}

void GAME_BATBON_DrawRS(long P1, byte P2) {
  ssd1306_send_byte((B00000011 | P1)>>P2);
  ssd1306_send_byte((B00000011 | P1)>>P2);
}
void GAME_BATBON_DrawLS(long P1, byte P2) {
  ssd1306_send_byte((B00000011 | P1)<<P2);
  ssd1306_send_byte((B00000011 | P1)<<P2);
}

void startGame(void) {
  
  ssd1306_fillscreen(0x00);

  ssd1306_char_f6x8(16, 3, "-- GET READY --");
  SCREEN_DrawNumber(60,5,3);
  delay(1000);
  SCREEN_DrawNumber(60,5,2);
  delay(1000);
  SCREEN_DrawNumber(60,5,1);
  delay(1000);
  ssd1306_fillscreen(0x00);

  for (int i = 800; i>200; i = i - 200){
    GAMES_Beep(30,i);
  }
}


batbonanza.cpp

#include "games.h"
#include "screen.h"
#include "buttons.h"

typedef struct
{
  boolean stopAnimate = 0; // this is set to 1 when a collision is detected
  boolean newHigh = 0;
  int score = 0; // score - this affects the difficulty of the game
  boolean row[3][16]; // on-off array of blocks
  byte player = 0; //0 to 128-platformWidth  - this is the position of the bounce platform
  int topScoreB = 0;
  long lastFrame = 0; // time since the screen was updated last
  int vdir = -1; // vertical direction and step  distance
  int hdir = -1; // horizontal direction and step distance
  byte ballx = 62; // coordinate of the ball
  byte bally = 50; // coordinate of the ball
  byte platformWidth = 16; 
} BreakoutInfo_st;

// For Breakout

BreakoutInfo_st *_breakoutInfo = NULL;

// Function prototypes for Breakout
void collision(void);
static void drawPlatform(void);

void GAME_BREAKOUT_Init()
{
  SCREEN_Clear(DISPLAY_SCREEN);
  ssd1306_char_f6x8(16, 2, "B R E A K O U T");
  ssd1306_char_f6x8(3, 4, "mods by andy jackson"); // see comments above !
  ssd1306_char_f6x8(22, 6, "game design by");  // see comments above !
  ssd1306_char_f6x8(22, 7, "/ebboggles.com");  // see comments above !
  delay(GAME_START_SCREEN_TIME);

  if (_breakoutInfo == NULL) {
    _breakoutInfo = (BreakoutInfo_st *)malloc(sizeof(BreakoutInfo_st));
  }
}

void GAME_BREAKOUT_Start(uint8_t gameindex)
{
  GAME_BREAKOUT_Init();
  SCREEN_Clear(DISPLAY_SCREEN);

  if (_breakoutInfo == NULL) {
    return;
  }

  _breakoutInfo->lastFrame = millis();

  for (byte i =0; i<16;i++){ // reset blocks
    _breakoutInfo->row[0][i]=1; _breakoutInfo->row[1][i]=1; _breakoutInfo->row[2][i]=1;
  } 
  
  _breakoutInfo->platformWidth = 16;
  _breakoutInfo->ballx = 64;
  _breakoutInfo->bally = 50;
  _breakoutInfo->hdir = -1;
  _breakoutInfo->vdir = -1;
  _breakoutInfo->score = 0;
  _breakoutInfo->player = random(0,128-_breakoutInfo->platformWidth);
  _breakoutInfo->ballx = _breakoutInfo->player+_breakoutInfo->platformWidth/2;
  _breakoutInfo->stopAnimate = 0;

  while (_breakoutInfo->stopAnimate == 0)
  {
    delay(40);
    BUTTONS_Task();
    // continue moving after the interrupt
    if (BUTTONS_Get(BTN_RIGHT, BTN_NO_DELAY) == BUTTON_PRESSED){if (_breakoutInfo->player <128-_breakoutInfo->platformWidth){_breakoutInfo->player++;} if (_breakoutInfo->player <128-_breakoutInfo->platformWidth){_breakoutInfo->player++;} if (_breakoutInfo->player <128-_breakoutInfo->platformWidth){_breakoutInfo->player++;}}
    if (BUTTONS_Get(BTN_LEFT, BTN_NO_DELAY) == BUTTON_PRESSED){if (_breakoutInfo->player >0){_breakoutInfo->player--;} if (_breakoutInfo->player >0){_breakoutInfo->player--;} if (_breakoutInfo->player >0){_breakoutInfo->player--;}}
    
    // bounce off the sides of the screen
    if ((_breakoutInfo->bally+_breakoutInfo->vdir<54&&_breakoutInfo->vdir==1)||(_breakoutInfo->bally-_breakoutInfo->vdir>1&&_breakoutInfo->vdir==-1)){_breakoutInfo->bally+=_breakoutInfo->vdir;}else {_breakoutInfo->vdir = _breakoutInfo->vdir*-1;}
    if ((_breakoutInfo->ballx+_breakoutInfo->hdir<127&&_breakoutInfo->hdir==1)||(_breakoutInfo->ballx-_breakoutInfo->hdir>1&&_breakoutInfo->hdir==-1)){_breakoutInfo->ballx+=_breakoutInfo->hdir;}else {_breakoutInfo->hdir = _breakoutInfo->hdir*-1;}
    
    // frame actions
    if (_breakoutInfo->lastFrame+10<millis()){
      if(_breakoutInfo->bally>10&&_breakoutInfo->bally+_breakoutInfo->vdir>=54&&(_breakoutInfo->ballx<_breakoutInfo->player||_breakoutInfo->ballx>_breakoutInfo->player+_breakoutInfo->platformWidth)){ // game over if the ball misses the platform

        _breakoutInfo->stopAnimate = 1;
        break;
      }else if (_breakoutInfo->ballx<_breakoutInfo->player+_breakoutInfo->platformWidth/2&&_breakoutInfo->bally>10&&_breakoutInfo->bally+_breakoutInfo->vdir>=54){ // if the ball hits left of the platform bounce left
        _breakoutInfo->hdir=-1; GAMES_Beep(20,600);
      }else if (_breakoutInfo->ballx>_breakoutInfo->player+_breakoutInfo->platformWidth/2&&_breakoutInfo->bally>10&&_breakoutInfo->bally+_breakoutInfo->vdir>=54){  // if the ball hits right of the platform bounce right
        _breakoutInfo->hdir=1; GAMES_Beep(20,600);
      }else if (_breakoutInfo->bally+_breakoutInfo->vdir>=54){
        _breakoutInfo->hdir=1; GAMES_Beep(20,600);
      }
      
      collisionCheck: // go back to here if a collision was detected to prevent flying through a rigid
      if (floor((_breakoutInfo->bally+_breakoutInfo->vdir)/8)==2){
        if (_breakoutInfo->row[2][_breakoutInfo->ballx/8]==1){_breakoutInfo->row[2][_breakoutInfo->ballx/8]=0; _breakoutInfo->score++;  
            collision(); goto collisionCheck; // check collision for the new direction to prevent flying through a rigid
        }
      }else if (floor((_breakoutInfo->bally+_breakoutInfo->vdir)/8)==1){
        if (_breakoutInfo->row[1][_breakoutInfo->ballx/8]==1){_breakoutInfo->row[1][_breakoutInfo->ballx/8]=0; _breakoutInfo->score++; 
            collision(); goto collisionCheck;
        }
      }else if (floor((_breakoutInfo->bally+_breakoutInfo->vdir)/8)==0){
        if (_breakoutInfo->row[0][_breakoutInfo->ballx/8]==1){_breakoutInfo->row[0][_breakoutInfo->ballx/8]=0; _breakoutInfo->score++;
            collision(); goto collisionCheck;
        }
      }
      
      // reset blocks if all have been hit
      if (_breakoutInfo->score%48==0){ 
        for (byte i =0; i<16;i++){
          _breakoutInfo->row[0][i]=1; _breakoutInfo->row[1][i]=1; _breakoutInfo->row[2][i]=1;
        } 
      }
    }
      
    // update whats on the screen
    // blocks
    for (int inc = 0; inc <3; inc ++) {
      ssd1306_setpos(0,inc);
      ssd1306_send_data_start();
      for (int bl = 0; bl <16; bl++) {
        if(_breakoutInfo->row[inc][bl]==1){
          SCREEN_SendBlock(1);
        } else {
          SCREEN_SendBlock(0);
        }
      }   
      ssd1306_send_data_stop();
    }
    
    // clear area below the blocks
    
    for (int kl = 3;kl <8;kl++) {
      ssd1306_setpos(0,kl);
      ssd1306_send_data_start();
      for (byte i =0; i<128; i++){
          ssd1306_send_byte(B00000000);
      }
      ssd1306_send_data_stop();
    }
    // draw ball
    ssd1306_setpos(_breakoutInfo->ballx,_breakoutInfo->bally/8);
    uint8_t temp = B00000001;
    ssd1306_send_data_start();
    temp = temp << _breakoutInfo->bally%8+1;
    ssd1306_send_byte(temp);  
    ssd1306_send_data_stop();
    
    drawPlatform();
  }

  GAMES_End(gameindex, _breakoutInfo->score);

  if (_breakoutInfo) {
    free(_breakoutInfo);
    _breakoutInfo = NULL;
  }
}

void collision(){ // the collsision check is actually done befor this is called, this code works out where the ball will bounce
  if ((_breakoutInfo->bally+_breakoutInfo->vdir)%8==7&&(_breakoutInfo->ballx+_breakoutInfo->hdir)%8==7){ // bottom right corner
      if (_breakoutInfo->vdir==1){_breakoutInfo->hdir=1;}else if(_breakoutInfo->vdir==-1&&_breakoutInfo->hdir==1){_breakoutInfo->vdir=1;}else {_breakoutInfo->hdir=1;_breakoutInfo->vdir=1;}
    }else if ((_breakoutInfo->bally+_breakoutInfo->vdir)%8==7&&(_breakoutInfo->ballx+_breakoutInfo->hdir)%8==0){ // bottom left corner
      if (_breakoutInfo->vdir==1){_breakoutInfo->hdir=-1;}else if(_breakoutInfo->vdir==-1&&_breakoutInfo->hdir==-1){_breakoutInfo->vdir=1;}else {_breakoutInfo->hdir=-1;_breakoutInfo->vdir=1;}
    }else if ((_breakoutInfo->bally+_breakoutInfo->vdir)%8==0&&(_breakoutInfo->ballx+_breakoutInfo->hdir)%8==0){ // top left corner
      if (_breakoutInfo->vdir==-1){_breakoutInfo->hdir=-1;}else if(_breakoutInfo->vdir==1&&_breakoutInfo->hdir==-1){_breakoutInfo->vdir=-1;}else {_breakoutInfo->hdir=-1;_breakoutInfo->vdir=-1;}
    }else if ((_breakoutInfo->bally+_breakoutInfo->vdir)%8==0&&(_breakoutInfo->ballx+_breakoutInfo->hdir)%8==7){ // top right corner
      if (_breakoutInfo->vdir==-1){_breakoutInfo->hdir=1;}else if(_breakoutInfo->vdir==1&&_breakoutInfo->hdir==1){_breakoutInfo->vdir=-1;}else {_breakoutInfo->hdir=1;_breakoutInfo->vdir=-1;}
    }else if ((_breakoutInfo->bally+_breakoutInfo->vdir)%8==7){ // bottom side
      _breakoutInfo->vdir = 1;
    }else if ((_breakoutInfo->bally+_breakoutInfo->vdir)%8==0){ // top side
      _breakoutInfo->vdir = -1;
    }else if ((_breakoutInfo->ballx+_breakoutInfo->hdir)%8==7){ // right side
      _breakoutInfo->hdir = 1;
    }else if ((_breakoutInfo->ballx+_breakoutInfo->hdir)%8==0){ // left side
      _breakoutInfo->hdir = -1;
    }else {
      _breakoutInfo->hdir = _breakoutInfo->hdir*-1; _breakoutInfo->vdir = _breakoutInfo->vdir*-1;
  }
  GAMES_Beep(30,300);
}

void drawPlatform(){
//  noInterrupts();
 ssd1306_setpos(_breakoutInfo->player,7);
 ssd1306_send_data_start();
 for (byte pw = 1; pw <_breakoutInfo->platformWidth; pw++){ssd1306_send_byte(B00000011);}                
 ssd1306_send_data_stop();  
//  interrupts(); 
}


breakout.cpp

#include "buttons.h"

#define BTN_ACTIVE              LOW
#define BTN_DEACTIVE            HIGH

#if defined(KEYS_CONTROL_BUTTONS)
ButtonStates_st _buttonStates = {
  {false, BUTTON_RELEASED, BTN_LEFT_PIN,  0},
  {false, BUTTON_RELEASED, BTN_RIGHT_PIN, 0},
  {false, BUTTON_RELEASED, BTN_LEFT_PIN,  0},
  {false, BUTTON_RELEASED, BTN_RIGHT_PIN, 0},
  {false, BUTTON_RELEASED, BTN_SELECT_PIN,0},
};
static unsigned long _buttonTime[BTN_MAX] = {0};
static unsigned long volatile _timeDiffTemp = 0;
#endif

#if defined(KEYS_CONTROL_JOYSTICK)
ButtonStates_st _joyStates = {
  {false, BUTTON_RELEASED, JOY_UPDOWN_PIN,    0},
  {false, BUTTON_RELEASED, JOY_UPDOWN_PIN,    0},
  {false, BUTTON_RELEASED, JOY_LEFTRIGHT_PIN, 0},
  {false, BUTTON_RELEASED, JOY_LEFTRIGHT_PIN, 0},
  {false, BUTTON_RELEASED, JOY_BUTTON_PIN,    0},
};
#endif

#if defined(KEYS_CONTROL_WIFI)
ButtonStates_st _wifiBtnStates = {
  {false, BUTTON_RELEASED, 0},
  {false, BUTTON_RELEASED, 0},
  {false, BUTTON_RELEASED, 0},
  {false, BUTTON_RELEASED, 0},
  {false, BUTTON_RELEASED, 0},
};
#endif

static Button_st *LocalGetButton(ButtonStates_st *buttons, const uint8_t btn_dir);

#if defined(KEYS_CONTROL_BUTTONS) || defined(KEYS_CONTROL_JOYSTICK)
void btnFallingIsrHandler(uint8_t btn_dir)
{
#if defined(KEYS_CONTROL_BUTTONS)
  Button_st *btn = LocalGetButton(&_buttonStates, btn_dir);
#else
  Button_st *btn = LocalGetButton(&_joyStates, btn_dir);
#endif

  if (btn && btn->state == BUTTON_RELEASED) {
    _timeDiffTemp = millis() - _buttonTime[btn_dir];
    if (_timeDiffTemp > BTN_DEBOUNCE_TIME) {
      btn->state = BUTTON_PRESSED;
      _buttonTime[btn_dir] = millis();
    }
  }
}

void btnRisingIsrHandler(uint8_t btn_dir)
{
#if defined(KEYS_CONTROL_BUTTONS)
  Button_st *btn = LocalGetButton(&_buttonStates, btn_dir);
#else
  Button_st *btn = LocalGetButton(&_joyStates, btn_dir);
#endif

  if (btn && btn->state == BUTTON_PRESSED) {
    _timeDiffTemp = millis() - _buttonTime[btn_dir];
    if (_timeDiffTemp > BTN_DEBOUNCE_TIME) {
      btn->clicked = true;
      btn->clicked_time = millis();
      btn->state = BUTTON_RELEASED;
      _buttonTime[btn_dir] = millis();
    }
  }
}

void
#if defined(ESP32) || defined(ESP8266) 
IRAM_ATTR
#endif
btnLeftIsr() {
  if (digitalRead(BTN_LEFT_PIN)) {
    btnRisingIsrHandler(BTN_LEFT);
  } else {
    btnFallingIsrHandler(BTN_LEFT);
  }
}

void
#if defined(ESP32) || defined(ESP8266) 
IRAM_ATTR
#endif
btnRightIsr() {
  if (digitalRead(BTN_RIGHT_PIN)) {
    btnRisingIsrHandler(BTN_RIGHT);
  } else {
    btnFallingIsrHandler(BTN_RIGHT);
  }
}

void
#if defined(ESP32) || defined(ESP8266) 
IRAM_ATTR
#endif
btnSelIsr() {
  if (digitalRead(BTN_SELECT_PIN)) {
    btnRisingIsrHandler(BTN_SELECT);
  } else {
    btnFallingIsrHandler(BTN_SELECT);
  }
}

void LocalAdjustButtonDebounce(uint8_t btn_dir)
{
#if 0
  Button_st *btn = LocalGetButton(&_buttonStates, btn_dir);
  if (btn && millis() - _buttonTime[btn_dir] > 150) {
    btn->state = (digitalRead(btn->pin))? BUTTON_RELEASED : BUTTON_PRESSED;
  }
#endif
}
#endif  //KEYS_CONTROL_BUTTONS || KEYS_CONTROL_JOYSTICK

Button_st *LocalGetButton(ButtonStates_st *buttons, const uint8_t btn_dir)
{
  Button_st *btn = NULL;
  if (buttons) {
    switch (btn_dir) {
      case BTN_UP:
#if !defined(KEYS_CONTROL_BUTTONS)
        btn = &(buttons->up);     break;
#endif
      case BTN_LEFT:
        btn = &(buttons->left);   break;
      case BTN_DOWN:
#if !defined(KEYS_CONTROL_BUTTONS)
        btn = &(buttons->down);   break;
#endif
      case BTN_RIGHT:
        btn = &(buttons->right);  break;
      case BTN_SELECT:
        btn = &(buttons->select); break;
      default: break;
    }
  }
  return btn;
}

void BUTTONS_Init()
{
#if defined(KEYS_CONTROL_BUTTONS)
  pinMode(BTN_LEFT_PIN,   INPUT_PULLUP);
  pinMode(BTN_RIGHT_PIN,  INPUT_PULLUP);
  pinMode(BTN_SELECT_PIN, INPUT_PULLUP);

  attachInterrupt(BTN_LEFT_PIN,   btnLeftIsr,  CHANGE);
  attachInterrupt(BTN_RIGHT_PIN,  btnRightIsr, CHANGE);
  attachInterrupt(BTN_SELECT_PIN, btnSelIsr,   CHANGE);
#endif  //KEYS_CONTROL_BUTTONS

#if defined(KEYS_CONTROL_JOYSTICK)
  attachInterrupt(JOY_BUTTON_PIN, btnSelIsr,   CHANGE);
#endif  //KEYS_CONTROL_JOYSTICK
}

#if defined(KEYS_CONTROL_JOYSTICK)
void JOYSTICK_Init()
{
  pinMode(JOY_UPDOWN_PIN,     INPUT);
  pinMode(JOY_LEFTRIGHT_PIN,  INPUT);
  pinMode(JOY_BUTTON_PIN,     INPUT_PULLUP);
}
#endif

void BUTTONS_Task()
{
  /* Buttons */
  //Handle in interrupt ISR

  /* Joystick */
#if defined(KEYS_CONTROL_JOYSTICK)
  ButtonStates_st prevJoy;
  uint16_t joy_percent_lr = map(analogRead(JOY_LEFTRIGHT_PIN), 0, JOYSTICK_RESOLUTION, 0, 100);
  uint16_t joy_percent_ud = map(analogRead(JOY_UPDOWN_PIN), 0, JOYSTICK_RESOLUTION, 0, 100);
  //Serial.print("UpDown: ");Serial.print(joy_percent_ud);Serial.print("%");
  //Serial.print(" - LeftRight: ");Serial.print(joy_percent_lr);Serial.println("%");

  //Store previous states
  memcpy(&prevJoy, &_joyStates, sizeof(ButtonStates_st));

  //Get current values
  if (joy_percent_lr >= 80) {
    _joyStates.left.state = BUTTON_PRESSED;
    _joyStates.right.state = BUTTON_RELEASED;
  } else if (joy_percent_lr <= 20) {
    _joyStates.right.state = BUTTON_PRESSED;
    _joyStates.left.state = BUTTON_RELEASED;
  } else {
    _joyStates.right.state = BUTTON_RELEASED;
    _joyStates.left.state = BUTTON_RELEASED;
  }

  if (joy_percent_ud >= 80) {
    _joyStates.up.state = BUTTON_PRESSED;
    _joyStates.down.state = BUTTON_RELEASED;
  } else if (joy_percent_ud <= 20) {
    _joyStates.down.state = BUTTON_PRESSED;
    _joyStates.up.state = BUTTON_RELEASED;
  } else {
    _joyStates.up.state = BUTTON_RELEASED;
    _joyStates.down.state = BUTTON_RELEASED;
  }

  /* Check clicked */
  if (prevJoy.left.state == BUTTON_PRESSED && _joyStates.left.state == BUTTON_RELEASED) {
    _joyStates.left.clicked = true;
    _joyStates.left.clicked_time = millis();
  }
  if (prevJoy.right.state == BUTTON_PRESSED && _joyStates.right.state == BUTTON_RELEASED) {
    _joyStates.right.clicked = true;
    _joyStates.right.clicked_time = millis();
  }
  if (prevJoy.up.state == BUTTON_PRESSED && _joyStates.up.state == BUTTON_RELEASED) {
    _joyStates.up.clicked = true;
    _joyStates.up.clicked_time = millis();
  }
  if (prevJoy.down.state == BUTTON_PRESSED && _joyStates.down.state == BUTTON_RELEASED) {
    _joyStates.down.clicked = true;
    _joyStates.down.clicked_time = millis();
  }
#endif  //KEYS_CONTROL_JOYSTICK
}

bool BUTTONS_GetClicked(uint8_t btn_dir)
{
  bool        isClicked = false;
#if defined(KEYS_CONTROL_WIFI)
  ButtonStates_st *btns = &_wifiBtnStates;
#elif defined(KEYS_CONTROL_BUTTONS)
  ButtonStates_st *btns = &_buttonStates;
#elif defined(KEYS_CONTROL_JOYSTICK)
  ButtonStates_st *btns = &_joyStates;
#endif
  Button_st   *btn = LocalGetButton(btns, btn_dir);
  
  if (btn && btn->clicked) {
    if (millis() - btn->clicked_time <= BTN_CLICKED_REMAIN_TIME) {
      isClicked = true;
      btn->clicked = false; //Reset state
      btn->clicked_time = 0;
    }
  }

  return isClicked;
}

uint8_t BUTTONS_Get(uint8_t btn_dir, bool isDelay)
{
  uint8_t btn_state = BUTTON_RELEASED, joy_state = BUTTON_RELEASED, wifi_state = BUTTON_RELEASED;

#if defined(KEYS_CONTROL_BUTTONS)
  LocalAdjustButtonDebounce(btn_dir);
  Button_st *btn = LocalGetButton(&_buttonStates, btn_dir);
  if (btn) {
    btn_state = btn->state;
  }
#endif  //KEYS_CONTROL_BUTTONS

#if defined(KEYS_CONTROL_JOYSTICK)
  Button_st *btn = LocalGetButton(&_joyStates, btn_dir);
  if (btn) {
    joy_state = (btn->state > 0)? BUTTON_PRESSED : BUTTON_RELEASED;
  }
#endif  //KEYS_CONTROL_JOYSTICK

#if defined(KEYS_CONTROL_WIFI)
  Button_st *btn = LocalGetButton(&_wifiBtnStates, btn_dir);
  if (btn) {
    wifi_state = btn->state;
  }
#endif  //KEYS_CONTROL_WIFI

  return btn_state | joy_state | wifi_state;
}

#if defined(KEYS_CONTROL_WIFI)
void BUTTONS_WifiUpdate(uint8_t btn_dir, uint8_t btn_stt)
{
  Button_st *btn = LocalGetButton(&_wifiBtnStates, btn_dir);;

  if (btn) {
    if (btn_stt == BUTTON_CLICKED) {
      btn->clicked = btn_stt;
      btn->clicked_time = millis();
    } else {
      btn->state = btn_stt;
    }
  }
}
#endif

buttons.cpp

#pragma once

#include <Arduino.h>
#include "configs.h"

#define BUTTON_RELEASED           0
#define BUTTON_PRESSED            1
#define BUTTON_CLICKED            2

#define BTN_NO_DELAY              false

typedef enum
{
  BTN_UP = (0),
  BTN_DOWN,
  BTN_LEFT,
  BTN_RIGHT,
  BTN_SELECT,
  BTN_MAX
} ButtonType_e;

typedef struct Button_t
{
  bool          clicked;
  uint8_t       state;
#if defined(KEYS_CONTROL_BUTTONS) || defined(KEYS_CONTROL_JOYSTICK)
  uint8_t       pin;
#endif
  unsigned long clicked_time;
} Button_st;

typedef struct ButtonStates_t
{
  Button_st up;
  Button_st down;
  Button_st left;
  Button_st right;
  Button_st select;
} ButtonStates_st;

void BUTTONS_Init();
void BUTTONS_Task();
uint8_t BUTTONS_Get(uint8_t btn_dir, bool isDelay = true);
bool BUTTONS_GetClicked(uint8_t btn_dir);

#if defined(KEYS_CONTROL_WIFI)
void BUTTONS_WifiUpdate(uint8_t btn_dir, uint8_t btn_stt);
#endif

#if defined(KEYS_CONTROL_JOYSTICK)
void JOYSTICK_Init();
#endif


buttons.h

#pragma once

#include <Arduino.h>
#include "configs.h"

// Delay for smooth running on Wokwi
#define WOKWI_DELAY             delay(10);

#if defined(ESP32) || defined(ESP8266)
#include <SPI.h>
#include <FS.h>

#if defined(ESP32)
#include <SD.h>
#include <SPIFFS.h>
#endif

#define FILE_PATH_MAX               128
#define WIFI_CREDENTIALS_LEN        32

/* File */
bool STORAGE_ReadFile(fs::FS &fs, const char * path, uint8_t *data, size_t size);
bool STORAGE_WriteFile(fs::FS &fs, const char * path, const uint8_t *data, size_t size);
bool STORAGE_FileExist(fs::FS &fs, const char * path);
bool STORAGE_FileExist(fs::FS &fs, String path);
bool STORAGE_Remove(fs::FS &fs, const char *path);
bool STORAGE_Remove(fs::FS &fs, String path);
bool STORAGE_MakeDir(fs::FS &fs, const char *path);
bool STORAGE_MakeDir(fs::FS &fs, String path);
unsigned long STORAGE_FileSize(fs::FS &fs, const char *path);
unsigned long STORAGE_FileSize(fs::FS &fs, String path);
#endif  //KEYS_CONTROL_WIFI


common.h

#pragma once

/* Keys Control */
/*
  The button layout has 3 buttons: LEFT - RIGHT - SELECT
  It keeps the original layout from Attiny Arduino Projects
*/
#define KEYS_CONTROL_BUTTONS

/*
  Please use Joystick with push button for selection
  If your joystick does not contain a push button, use an external one instead
*/
// #define KEYS_CONTROL_JOYSTICK

/*
  Only avalable on ESP chipset
*/
// #define KEYS_CONTROL_WIFI

/* Speaker/Buzzer */
#define SPEAKER_PIN                   13

/* Buttons */
#if defined(KEYS_CONTROL_BUTTONS)
#define BTN_LEFT_PIN                  10//32
#define BTN_RIGHT_PIN                 11//33
#define BTN_SELECT_PIN                12//25
#endif

#if defined(KEYS_CONTROL_JOYSTICK)
#define JOY_UPDOWN_PIN                0//32
#define JOY_LEFTRIGHT_PIN             4//33
#define JOY_BUTTON_PIN                16//25
#if defined(ESP32) || defined(ESP8266)
#define JOYSTICK_RESOLUTION           4095  //12 bit
#else
#define JOYSTICK_RESOLUTION           1023  //10 bit
#endif  //ESP
#endif

#define BTN_CLICKED_REMAIN_TIME       500   //ms
#define BTN_DEBOUNCE_TIME             30    //ms
#define BTN_DEBOUNCE_TIMES            16

/* SSD1306 OLED 128x64 */
#define SSD1306_DEFAULT_ADDR          0x3C
#define OLED_WIDTH                    128
#define OLED_HEIGHT                   64
#define OLED_RESET                    -1  // Reset pin # (or -1 if sharing Arduino reset pin)

/* TIME */
#define TIME_SECOND                   1000    //mili
#define TIME_MINUTE                   (60 * TIME_SECOND)
#define TIME_HOUR                     (60 * TIME_MINUTE)

/* WIFI */
#if defined(ESP32)
#define WIFI_AP_SSID                  "ESP32 Arduino Games"
#elif defined(ESP8266)
#define WIFI_AP_SSID                  "ESP8266 Arduino Games"
#endif
#define WIFI_AP_PASSWORD              ""
#define WIFI_CONNECT_TIMEOUT          (10 * TIME_SECOND)

/* Web Server/Socket */
#define WEBSERVER_PORT                80
#define WEBSOCKET_PATH                "/ws"

/* Captive Portal */
// #define CAPTIVE_PORTAL_ENABLED
#define DNS_SERVER_PORT               53

/* Database */
#define DATABASE_ENABLED

/* Configs Validation */
#if defined(KEYS_CONTROL_WIFI) && !defined(ESP32) && !defined(ESP8266)
#error "WIFI is not available. Please select ESP chipset to use WIFI features."
#endif


configs.h

#include "common.h"
#include "games.h"

#if defined(DATABASE_ENABLED)
#if defined(__AVR__)
#include <EEPROM.h>
#endif

typedef struct {
#if defined(ESP32) || defined(ESP8266)
  char wifi_ssid[WIFI_CREDENTIALS_LEN];
  char wifi_pass[WIFI_CREDENTIALS_LEN];
#endif
  uint16_t highscores[TOTAL_GAMES];
} st_Database;


static st_Database _db;

uint16_t DB_HIGHSCORE_Getval(uint8_t index)
{
  uint16_t val = 0;
  if (index < GAMES_GetTotalGamesNum()) {
    val = _db.highscores[index];
  }

  return val;
}

void DB_HIGHSCORE_SetVal(uint8_t index, uint16_t score)
{
  if (index < GAMES_GetTotalGamesNum()) {
    _db.highscores[index] = score;
    DB_Store();
  }
}

#if defined(ESP32) || defined(ESP8266)
#define LOG_COMMON                    ""

#define DB_PATH                       "/arduinogames"

void DB_Init()
{
#if defined(ESP32)
  SPIFFS.begin(true);
#elif defined(ESP8266)
  SPIFFS.begin();
#endif

  memset((uint8_t*)&_db, 0, sizeof(_db));

  if (!STORAGE_FileExist(SPIFFS, DB_PATH)) {
    if (STORAGE_WriteFile(SPIFFS, DB_PATH, (const uint8_t*)&_db, sizeof(_db))){}
  }

  if (STORAGE_ReadFile(SPIFFS, DB_PATH, (uint8_t*)&_db, sizeof(_db)) == false) {
    // ESP_LOGE(LOG_COMMON, "Database read failed! Set to default.");
    memset((uint8_t*)&_db, 0, sizeof(_db));
    DB_Store();
  }
}

const char *DB_GetWifiSSID() {
  return _db.wifi_ssid;
}

const char *DB_GetWifiPass() {
  return _db.wifi_pass;
}

void DB_UpdateWifiCredentials(const char *ssid, const char *pass) {
  if (ssid && pass) {
    memset(_db.wifi_ssid, 0, WIFI_CREDENTIALS_LEN);
    memset(_db.wifi_pass, 0, WIFI_CREDENTIALS_LEN);
    strncpy(_db.wifi_ssid, ssid, WIFI_CREDENTIALS_LEN - 1);
    strncpy(_db.wifi_pass, pass, WIFI_CREDENTIALS_LEN - 1);
    DB_Store();
  }
}

void DB_UpdateWifiCredentials(String ssid, String pass) {
  DB_UpdateWifiCredentials(ssid.c_str(), pass.c_str());
}

bool STORAGE_FileExist(fs::FS &fs, const char * path) {
  return fs.exists(path);
}

bool STORAGE_FileExist(fs::FS &fs, String path) {
  return STORAGE_FileExist(fs, path.c_str());
}

unsigned long STORAGE_FileSize(fs::FS &fs, const char *path)
{
  unsigned long filesize = 0;
#if defined(ESP32)
  File file = fs.open(path);
#elif defined(ESP8266)
  File file = fs.open(path, "r");
#endif
  if (!file || file.isDirectory()) {
      //ESP_LOGE(LOG_COMMON, "Failed to open file for reading: %s", path);
  } else {
    filesize = file.size();
    file.close();
  }

  return filesize;
}

bool STORAGE_Remove(fs::FS &fs, const char *path)
{
  bool ret = false;

  if (STORAGE_FileExist(fs, path)) {
    ret = fs.remove(path);
  }

  return ret;
}

bool STORAGE_Remove(fs::FS &fs, String path) {
  return STORAGE_Remove(fs, path.c_str());
}

unsigned long STORAGE_FileSize(fs::FS &fs, String path) {
  return STORAGE_FileSize(fs, path.c_str());
}

bool STORAGE_ReadFile(fs::FS &fs, const char * path, uint8_t *data, size_t size)
{
  bool result = true;

#if defined(ESP32)
  File file = fs.open(path);
#elif defined(ESP8266)
  File file = fs.open(path, "r");
#endif
  if (!file || file.isDirectory()) {
    //ESP_LOGE(LOG_COMMON, "Failed to open file for reading: %s", path);
    return false;
  }

  if (file.available()) {
    int readSize = file.readBytes((char *)data, size);
    if (readSize < size) {
      //ESP_LOGE(LOG_COMMON, "Read size error %d - expected %d", readSize, size);
      result = false;
    }
  }
  else {
    //ESP_LOGE(LOG_COMMON, "File not available. Read error!");
    result = false;
  }

  file.close();
  return result;
}

bool STORAGE_WriteFile(fs::FS &fs, const char * path, const uint8_t *data, size_t size)
{
  bool result = true;

#if defined(ESP32)
  File file = fs.open(path, FILE_WRITE);
#elif defined(ESP8266)
  File file = fs.open(path, "w");
#endif
  if (!file){
    //ESP_LOGE(LOG_COMMON, "Failed to open file for writing %s", path);
    return false;
  }

  int writeSize = file.write(data, size);
  if (writeSize < size) {
    //ESP_LOGE(LOG_COMMON, "Write size error %d - expected %d", writeSize, size);
    result = false;
  }

  file.close();
  return result;
}

void DB_Store() {
  STORAGE_WriteFile(SPIFFS, DB_PATH, (uint8_t*)&_db, sizeof(_db));
}
#else  //KEYS_CONTROL_WIFI
#define EEPROM_MAX_SIZE           (TOTAL_GAMES * sizeof(uint16_t))  //bytes

void DB_Init() {
  uint8_t i = 0;
  uint8_t total_games = GAMES_GetTotalGamesNum();

  EEPROM.begin();

  for (i = 0; i < total_games; i++) {
    _db.highscores[i] = (uint16_t)EEPROM.read(i * sizeof(uint16_t)) << 8;
    _db.highscores[i] |= (uint16_t)EEPROM.read(i * sizeof(uint16_t) + 1);
  }
}

void DB_Store() {
  uint8_t i = 0;
  uint8_t total_games = GAMES_GetTotalGamesNum();

  for (i = 0; i < total_games; i++) {
    EEPROM.update(i * sizeof(uint16_t), (_db.highscores[i] >> 8) & 0xFF);
    EEPROM.update(i * sizeof(uint16_t) + 1, _db.highscores[i] & 0xFF);
  }
}
#endif
#else  //DATABASE_ENABLED
void DB_Init(){}
void DB_Store(){}
void DB_HIGHSCORE_SetVal(uint8_t index, uint16_t score) {}
uint16_t DB_HIGHSCORE_Getval(uint8_t index) { return 0; }
const char *DB_GetWifiSSID() { return NULL; }
const char *DB_GetWifiPass() { return NULL; }
void DB_UpdateWifiCredentials(const char *ssid, const char *pass){}
void DB_UpdateWifiCredentials(String ssid, String pass){}

#endif

database.cpp

/*
 * SSD1306xLED - Drivers for SSD1306 controlled dot matrix OLED/PLED 128x64 displays
 *
 * @file: font6x8.h
 * @created: 2014-08-12
 * @author: Neven Boyanov
 * 
 * Hacked by andy jackson to allow two games (originally by webboggles.com) to 
 * fit onto an ATTiny85 at the same time - hence several characters are missing
 * and a couple have been moved to limit the amount of software remapping required
 * to map ASCII values onto locations in this array.
 *
 * Source code available at: https://bitbucket.org/tinusaur/ssd1306xled
 *
 */

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------

/* Standard ASCII 6x8 font */
#if 0
static const uint8_t ssd1306xled_font6x8 [] PROGMEM = {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // sp
/*
  0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, // !
  0x00, 0x00, 0x07, 0x00, 0x07, 0x00, // "
  0x00, 0x14, 0x7f, 0x14, 0x7f, 0x14, // #
  0x00, 0x24, 0x2a, 0x7f, 0x2a, 0x12, // $
  0x00, 0x62, 0x64, 0x08, 0x13, 0x23, // %
  0x00, 0x36, 0x49, 0x55, 0x22, 0x50, // &
  0x00, 0x00, 0x05, 0x03, 0x00, 0x00, // '
  0x00, 0x00, 0x1c, 0x22, 0x41, 0x00, // (
  0x00, 0x00, 0x41, 0x22, 0x1c, 0x00, // )
  0x00, 0x14, 0x08, 0x3E, 0x08, 0x14, // *
  0x00, 0x08, 0x08, 0x3E, 0x08, 0x08, // +
  0x00, 0x00, 0x00, 0xA0, 0x60, 0x00, // ,
  */
  0x00, 0x08, 0x08, 0x08, 0x08, 0x08, // -
  0x00, 0x00, 0x60, 0x60, 0x00, 0x00, // .
  0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C, // w in place of /
  //0x00, 0x20, 0x10, 0x08, 0x04, 0x02, // /
  0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E, // 0
  0x00, 0x00, 0x42, 0x7F, 0x40, 0x00, // 1
  0x00, 0x42, 0x61, 0x51, 0x49, 0x46, // 2
  0x00, 0x21, 0x41, 0x45, 0x4B, 0x31, // 3
  0x00, 0x18, 0x14, 0x12, 0x7F, 0x10, // 4
  0x00, 0x27, 0x45, 0x45, 0x45, 0x39, // 5
  0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30, // 6
  0x00, 0x01, 0x71, 0x09, 0x05, 0x03, // 7
  0x00, 0x36, 0x49, 0x49, 0x49, 0x36, // 8
  0x00, 0x06, 0x49, 0x49, 0x29, 0x1E, // 9
  0x00, 0x00, 0x36, 0x36, 0x00, 0x00, // :
/*
  0x00, 0x00, 0x56, 0x36, 0x00, 0x00, // ;
  0x00, 0x08, 0x14, 0x22, 0x41, 0x00, // <
  0x00, 0x14, 0x14, 0x14, 0x14, 0x14, // =
  0x00, 0x00, 0x41, 0x22, 0x14, 0x08, // >
  0x00, 0x02, 0x01, 0x51, 0x09, 0x06, // ?
  0x00, 0x32, 0x49, 0x59, 0x51, 0x3E, // @
 */
  0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C, // A
  0x00, 0x7F, 0x49, 0x49, 0x49, 0x36, // B
  0x00, 0x3E, 0x41, 0x41, 0x41, 0x22, // C
  0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C, // D
  0x00, 0x7F, 0x49, 0x49, 0x49, 0x41, // E
  0x00, 0x7F, 0x09, 0x09, 0x09, 0x01, // F
  0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A, // G
  0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F, // H
  0x00, 0x00, 0x41, 0x7F, 0x41, 0x00, // I
  0x00, 0x20, 0x40, 0x41, 0x3F, 0x01, // J
  0x00, 0x7F, 0x08, 0x14, 0x22, 0x41, // K
  0x00, 0x7F, 0x40, 0x40, 0x40, 0x40, // L
  0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F, // M
  0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F, // N
  0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E, // O
  0x00, 0x7F, 0x09, 0x09, 0x09, 0x06, // P
  0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E, // Q
  0x00, 0x7F, 0x09, 0x19, 0x29, 0x46, // R
  0x00, 0x46, 0x49, 0x49, 0x49, 0x31, // S
  0x00, 0x01, 0x01, 0x7F, 0x01, 0x01, // T
  0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F, // U
  0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F, // V
  0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F, // W
/*
  0x00, 0x63, 0x14, 0x08, 0x14, 0x63, // X
  0x00, 0x07, 0x08, 0x70, 0x08, 0x07, // Y
  0x00, 0x61, 0x51, 0x49, 0x45, 0x43, // Z
  0x00, 0x00, 0x7F, 0x41, 0x41, 0x00, // [
  0x00, 0x55, 0x2A, 0x55, 0x2A, 0x55, // 55
  0x00, 0x00, 0x41, 0x41, 0x7F, 0x00, // ]
  0x00, 0x04, 0x02, 0x01, 0x02, 0x04, // ^
  0x00, 0x40, 0x40, 0x40, 0x40, 0x40, // _
  0x00, 0x00, 0x01, 0x02, 0x04, 0x00, // '
*/
  0x00, 0x20, 0x54, 0x54, 0x54, 0x78, // a
  0x00, 0x7F, 0x48, 0x44, 0x44, 0x38, // b
  0x00, 0x38, 0x44, 0x44, 0x44, 0x20, // c
  0x00, 0x38, 0x44, 0x44, 0x48, 0x7F, // d
  0x00, 0x38, 0x54, 0x54, 0x54, 0x18, // e
  //0x00, 0x08, 0x7E, 0x09, 0x01, 0x02, // f
  0x00, 0x7F, 0x08, 0x04, 0x04, 0x78, // h in place of f
  0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C, // g
  0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C, // y (in place of h)
  //0x00, 0x7F, 0x08, 0x04, 0x04, 0x78, // h
  0x00, 0x00, 0x44, 0x7D, 0x40, 0x00, // i
  0x00, 0x40, 0x80, 0x84, 0x7D, 0x00, // j
  0x00, 0x7F, 0x10, 0x28, 0x44, 0x00, // k
  0x00, 0x00, 0x41, 0x7F, 0x40, 0x00, // l
  0x00, 0x7C, 0x04, 0x18, 0x04, 0x78, // m
  0x00, 0x7C, 0x08, 0x04, 0x04, 0x78, // n
  0x00, 0x38, 0x44, 0x44, 0x44, 0x38, // o
  0x00, 0xFC, 0x24, 0x24, 0x24, 0x18, // p
  0x00, 0x18, 0x24, 0x24, 0x18, 0xFC, // q
  0x00, 0x7C, 0x08, 0x04, 0x04, 0x08, // r
  0x00, 0x48, 0x54, 0x54, 0x54, 0x20, // s
  0x00, 0x04, 0x3F, 0x44, 0x40, 0x20, // t
  0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C, // u
  0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C, // v
 // 0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C, // w
 // 0x00, 0x44, 0x28, 0x10, 0x28, 0x44, // x
 // 0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C // y
};
#endif
// ----------------------------------------------------------------------------

static const byte font8x8[][8] PROGMEM = {
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},   // U+0020 (space)
    { 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x00},   // U+002D (-)
    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x0C, 0x00},   // U+002E (.)
    { 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x00},   // U+002F (/)
    { 0x3E, 0x63, 0x73, 0x7B, 0x6F, 0x67, 0x3E, 0x00},   // U+0030 (0)
    { 0x0C, 0x0E, 0x0C, 0x0C, 0x0C, 0x0C, 0x3F, 0x00},   // U+0031 (1)
    { 0x1E, 0x33, 0x30, 0x1C, 0x06, 0x33, 0x3F, 0x00},   // U+0032 (2)
    { 0x1E, 0x33, 0x30, 0x1C, 0x30, 0x33, 0x1E, 0x00},   // U+0033 (3)
    { 0x38, 0x3C, 0x36, 0x33, 0x7F, 0x30, 0x78, 0x00},   // U+0034 (4)
    { 0x3F, 0x03, 0x1F, 0x30, 0x30, 0x33, 0x1E, 0x00},   // U+0035 (5)
    { 0x1C, 0x06, 0x03, 0x1F, 0x33, 0x33, 0x1E, 0x00},   // U+0036 (6)
    { 0x3F, 0x33, 0x30, 0x18, 0x0C, 0x0C, 0x0C, 0x00},   // U+0037 (7)
    { 0x1E, 0x33, 0x33, 0x1E, 0x33, 0x33, 0x1E, 0x00},   // U+0038 (8)
    { 0x1E, 0x33, 0x33, 0x3E, 0x30, 0x18, 0x0E, 0x00},   // U+0039 (9)
    { 0x0C, 0x1E, 0x33, 0x33, 0x3F, 0x33, 0x33, 0x00},   // U+0041 (A)
    { 0x3F, 0x66, 0x66, 0x3E, 0x66, 0x66, 0x3F, 0x00},   // U+0042 (B)
    { 0x3C, 0x66, 0x03, 0x03, 0x03, 0x66, 0x3C, 0x00},   // U+0043 (C)
    { 0x1F, 0x36, 0x66, 0x66, 0x66, 0x36, 0x1F, 0x00},   // U+0044 (D)
    { 0x7F, 0x46, 0x16, 0x1E, 0x16, 0x46, 0x7F, 0x00},   // U+0045 (E)
    { 0x7F, 0x46, 0x16, 0x1E, 0x16, 0x06, 0x0F, 0x00},   // U+0046 (F)
    { 0x3C, 0x66, 0x03, 0x03, 0x73, 0x66, 0x7C, 0x00},   // U+0047 (G)
    { 0x33, 0x33, 0x33, 0x3F, 0x33, 0x33, 0x33, 0x00},   // U+0048 (H)
    { 0x1E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00},   // U+0049 (I)
    { 0x78, 0x30, 0x30, 0x30, 0x33, 0x33, 0x1E, 0x00},   // U+004A (J)
    { 0x67, 0x66, 0x36, 0x1E, 0x36, 0x66, 0x67, 0x00},   // U+004B (K)
    { 0x0F, 0x06, 0x06, 0x06, 0x46, 0x66, 0x7F, 0x00},   // U+004C (L)
    { 0x63, 0x77, 0x7F, 0x7F, 0x6B, 0x63, 0x63, 0x00},   // U+004D (M)
    { 0x63, 0x67, 0x6F, 0x7B, 0x73, 0x63, 0x63, 0x00},   // U+004E (N)
    { 0x1C, 0x36, 0x63, 0x63, 0x63, 0x36, 0x1C, 0x00},   // U+004F (O)
    { 0x3F, 0x66, 0x66, 0x3E, 0x06, 0x06, 0x0F, 0x00},   // U+0050 (P)
    { 0x1E, 0x33, 0x33, 0x33, 0x3B, 0x1E, 0x38, 0x00},   // U+0051 (Q)
    { 0x3F, 0x66, 0x66, 0x3E, 0x36, 0x66, 0x67, 0x00},   // U+0052 (R)
    { 0x1E, 0x33, 0x07, 0x0E, 0x38, 0x33, 0x1E, 0x00},   // U+0053 (S)
    { 0x3F, 0x2D, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00},   // U+0054 (T)
    { 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F, 0x00},   // U+0055 (U)
    { 0x33, 0x33, 0x33, 0x33, 0x33, 0x1E, 0x0C, 0x00},   // U+0056 (V)
    { 0x63, 0x63, 0x63, 0x6B, 0x7F, 0x77, 0x63, 0x00},   // U+0057 (W)
    { 0x63, 0x63, 0x36, 0x1C, 0x1C, 0x36, 0x63, 0x00},   // U+0058 (X)
    { 0x33, 0x33, 0x33, 0x1E, 0x0C, 0x0C, 0x1E, 0x00},   // U+0059 (Y)
    { 0x7F, 0x63, 0x31, 0x18, 0x4C, 0x66, 0x7F, 0x00},   // U+005A (Z)
    { 0x00, 0x00, 0x1E, 0x30, 0x3E, 0x33, 0x6E, 0x00},   // U+0061 (a)
    { 0x07, 0x06, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00},   // U+0062 (b)
    { 0x00, 0x00, 0x1E, 0x33, 0x03, 0x33, 0x1E, 0x00},   // U+0063 (c)
    { 0x38, 0x30, 0x30, 0x3e, 0x33, 0x33, 0x6E, 0x00},   // U+0064 (d)
    { 0x00, 0x00, 0x1E, 0x33, 0x3f, 0x03, 0x1E, 0x00},   // U+0065 (e)
    { 0x1C, 0x36, 0x06, 0x0f, 0x06, 0x06, 0x0F, 0x00},   // U+0066 (f)
    { 0x00, 0x00, 0x6E, 0x33, 0x33, 0x3E, 0x30, 0x1F},   // U+0067 (g)
    { 0x07, 0x06, 0x36, 0x6E, 0x66, 0x66, 0x67, 0x00},   // U+0068 (h)
    { 0x0C, 0x00, 0x0E, 0x0C, 0x0C, 0x0C, 0x1E, 0x00},   // U+0069 (i)
    { 0x30, 0x00, 0x30, 0x30, 0x30, 0x33, 0x33, 0x1E},   // U+006A (j)
    { 0x07, 0x06, 0x66, 0x36, 0x1E, 0x36, 0x67, 0x00},   // U+006B (k)
    { 0x0E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00},   // U+006C (l)
    { 0x00, 0x00, 0x33, 0x7F, 0x7F, 0x6B, 0x63, 0x00},   // U+006D (m)
    { 0x00, 0x00, 0x1F, 0x33, 0x33, 0x33, 0x33, 0x00},   // U+006E (n)
    { 0x00, 0x00, 0x1E, 0x33, 0x33, 0x33, 0x1E, 0x00},   // U+006F (o)
    { 0x00, 0x00, 0x3B, 0x66, 0x66, 0x3E, 0x06, 0x0F},   // U+0070 (p)
    { 0x00, 0x00, 0x6E, 0x33, 0x33, 0x3E, 0x30, 0x78},   // U+0071 (q)
    { 0x00, 0x00, 0x3B, 0x6E, 0x66, 0x06, 0x0F, 0x00},   // U+0072 (r)
    { 0x00, 0x00, 0x3E, 0x03, 0x1E, 0x30, 0x1F, 0x00},   // U+0073 (s)
    { 0x08, 0x0C, 0x3E, 0x0C, 0x0C, 0x2C, 0x18, 0x00},   // U+0074 (t)
    { 0x00, 0x00, 0x33, 0x33, 0x33, 0x33, 0x6E, 0x00},   // U+0075 (u)
    { 0x00, 0x00, 0x33, 0x33, 0x33, 0x1E, 0x0C, 0x00},   // U+0076 (v)
    { 0x00, 0x00, 0x63, 0x6B, 0x7F, 0x7F, 0x36, 0x00},   // U+0077 (w)
    { 0x00, 0x00, 0x63, 0x36, 0x1C, 0x36, 0x63, 0x00},   // U+0078 (x)
    { 0x00, 0x00, 0x33, 0x33, 0x33, 0x3E, 0x30, 0x1F},   // U+0079 (y)
    { 0x00, 0x00, 0x3F, 0x19, 0x0C, 0x26, 0x3F, 0x00},   // U+007A (z)
};

static const uint8_t ssd1306xled_font6x8 [] PROGMEM = {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // sp
  0x00, 0x00, 0x00, 0x2f, 0x00, 0x00, // !
  0x00, 0x00, 0x07, 0x00, 0x07, 0x00, // "
  0x00, 0x14, 0x7f, 0x14, 0x7f, 0x14, // #
  0x00, 0x24, 0x2a, 0x7f, 0x2a, 0x12, // $
  0x00, 0x62, 0x64, 0x08, 0x13, 0x23, // %
  0x00, 0x36, 0x49, 0x55, 0x22, 0x50, // &
  0x00, 0x00, 0x05, 0x03, 0x00, 0x00, // '
  0x00, 0x00, 0x1c, 0x22, 0x41, 0x00, // (
  0x00, 0x00, 0x41, 0x22, 0x1c, 0x00, // )
  0x00, 0x14, 0x08, 0x3E, 0x08, 0x14, // *
  0x00, 0x08, 0x08, 0x3E, 0x08, 0x08, // +
  0x00, 0x00, 0x00, 0xA0, 0x60, 0x00, // ,
  0x00, 0x08, 0x08, 0x08, 0x08, 0x08, // -
  0x00, 0x00, 0x60, 0x60, 0x00, 0x00, // .
  0x00, 0x20, 0x10, 0x08, 0x04, 0x02, // /
  0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E, // 0
  0x00, 0x00, 0x42, 0x7F, 0x40, 0x00, // 1
  0x00, 0x42, 0x61, 0x51, 0x49, 0x46, // 2
  0x00, 0x21, 0x41, 0x45, 0x4B, 0x31, // 3
  0x00, 0x18, 0x14, 0x12, 0x7F, 0x10, // 4
  0x00, 0x27, 0x45, 0x45, 0x45, 0x39, // 5
  0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30, // 6
  0x00, 0x01, 0x71, 0x09, 0x05, 0x03, // 7
  0x00, 0x36, 0x49, 0x49, 0x49, 0x36, // 8
  0x00, 0x06, 0x49, 0x49, 0x29, 0x1E, // 9
  0x00, 0x00, 0x36, 0x36, 0x00, 0x00, // :
  0x00, 0x00, 0x56, 0x36, 0x00, 0x00, // ;
  0x00, 0x08, 0x14, 0x22, 0x41, 0x00, // <
  0x00, 0x14, 0x14, 0x14, 0x14, 0x14, // =
  0x00, 0x00, 0x41, 0x22, 0x14, 0x08, // >
  0x00, 0x02, 0x01, 0x51, 0x09, 0x06, // ?
  0x00, 0x32, 0x49, 0x59, 0x51, 0x3E, // @
  0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C, // A
  0x00, 0x7F, 0x49, 0x49, 0x49, 0x36, // B
  0x00, 0x3E, 0x41, 0x41, 0x41, 0x22, // C
  0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C, // D
  0x00, 0x7F, 0x49, 0x49, 0x49, 0x41, // E
  0x00, 0x7F, 0x09, 0x09, 0x09, 0x01, // F
  0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A, // G
  0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F, // H
  0x00, 0x00, 0x41, 0x7F, 0x41, 0x00, // I
  0x00, 0x20, 0x40, 0x41, 0x3F, 0x01, // J
  0x00, 0x7F, 0x08, 0x14, 0x22, 0x41, // K
  0x00, 0x7F, 0x40, 0x40, 0x40, 0x40, // L
  0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F, // M
  0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F, // N
  0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E, // O
  0x00, 0x7F, 0x09, 0x09, 0x09, 0x06, // P
  0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E, // Q
  0x00, 0x7F, 0x09, 0x19, 0x29, 0x46, // R
  0x00, 0x46, 0x49, 0x49, 0x49, 0x31, // S
  0x00, 0x01, 0x01, 0x7F, 0x01, 0x01, // T
  0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F, // U
  0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F, // V
  0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F, // W
  0x00, 0x63, 0x14, 0x08, 0x14, 0x63, // X
  0x00, 0x07, 0x08, 0x70, 0x08, 0x07, // Y
  0x00, 0x61, 0x51, 0x49, 0x45, 0x43, // Z
  0x00, 0x00, 0x7F, 0x41, 0x41, 0x00, // [
  0x00, 0x55, 0x2A, 0x55, 0x2A, 0x55, // 55
  0x00, 0x00, 0x41, 0x41, 0x7F, 0x00, // ]
  0x00, 0x04, 0x02, 0x01, 0x02, 0x04, // ^
  0x00, 0x40, 0x40, 0x40, 0x40, 0x40, // _
  0x00, 0x00, 0x01, 0x02, 0x04, 0x00, // '
  0x00, 0x20, 0x54, 0x54, 0x54, 0x78, // a
  0x00, 0x7F, 0x48, 0x44, 0x44, 0x38, // b
  0x00, 0x38, 0x44, 0x44, 0x44, 0x20, // c
  0x00, 0x38, 0x44, 0x44, 0x48, 0x7F, // d
  0x00, 0x38, 0x54, 0x54, 0x54, 0x18, // e
  0x00, 0x08, 0x7E, 0x09, 0x01, 0x02, // f
  0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C, // g
  0x00, 0x7F, 0x08, 0x04, 0x04, 0x78, // h
  0x00, 0x00, 0x44, 0x7D, 0x40, 0x00, // i
  0x00, 0x40, 0x80, 0x84, 0x7D, 0x00, // j
  0x00, 0x7F, 0x10, 0x28, 0x44, 0x00, // k
  0x00, 0x00, 0x41, 0x7F, 0x40, 0x00, // l
  0x00, 0x7C, 0x04, 0x18, 0x04, 0x78, // m
  0x00, 0x7C, 0x08, 0x04, 0x04, 0x78, // n
  0x00, 0x38, 0x44, 0x44, 0x44, 0x38, // o
  0x00, 0xFC, 0x24, 0x24, 0x24, 0x18, // p
  0x00, 0x18, 0x24, 0x24, 0x18, 0xFC, // q
  0x00, 0x7C, 0x08, 0x04, 0x04, 0x08, // r
  0x00, 0x48, 0x54, 0x54, 0x54, 0x20, // s
  0x00, 0x04, 0x3F, 0x44, 0x40, 0x20, // t
  0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C, // u
  0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C, // v
  0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C, // w
  0x00, 0x44, 0x28, 0x10, 0x28, 0x44, // x
  0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C, // y
  0x00, 0x44, 0x64, 0x54, 0x4C, 0x44, // z
  0x14, 0x14, 0x14, 0x14, 0x14, 0x14, // horiz lines
};



font6x8AJ.h

frogger.cpp

#include "games.h"
#include "buttons.h"
#include "screen.h"
#include "menu.h"
#include "common.h"

#define GAME_NAME_LEN                   28
#define GAME_END_CONTINUE               0
#define GAME_END_MAINMENU               1

/*************************************************

 * Public Constants

 *************************************************/

#define NOTE_B0  31
#define NOTE_C1  33
#define NOTE_CS1 35
#define NOTE_D1  37
#define NOTE_DS1 39
#define NOTE_E1  41
#define NOTE_F1  44
#define NOTE_FS1 46
#define NOTE_G1  49
#define NOTE_GS1 52
#define NOTE_A1  55
#define NOTE_AS1 58
#define NOTE_B1  62
#define NOTE_C2  65
#define NOTE_CS2 69
#define NOTE_D2  73
#define NOTE_DS2 78
#define NOTE_E2  82
#define NOTE_F2  87
#define NOTE_FS2 93
#define NOTE_G2  98
#define NOTE_GS2 104
#define NOTE_A2  110
#define NOTE_AS2 117
#define NOTE_B2  123
#define NOTE_C3  131
#define NOTE_CS3 139
#define NOTE_D3  147
#define NOTE_DS3 156
#define NOTE_E3  165
#define NOTE_F3  175
#define NOTE_FS3 185
#define NOTE_G3  196
#define NOTE_GS3 208
#define NOTE_A3  220
#define NOTE_AS3 233
#define NOTE_B3  247
#define NOTE_C4  262
#define NOTE_CS4 277
#define NOTE_D4  294
#define NOTE_DS4 311
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_FS4 370
#define NOTE_G4  392
#define NOTE_GS4 415
#define NOTE_A4  440
#define NOTE_AS4 466
#define NOTE_B4  494
#define NOTE_C5  523
#define NOTE_CS5 554
#define NOTE_D5  587
#define NOTE_DS5 622
#define NOTE_E5  659
#define NOTE_F5  698
#define NOTE_FS5 740
#define NOTE_G5  784
#define NOTE_GS5 831
#define NOTE_A5  880
#define NOTE_AS5 932
#define NOTE_B5  988
#define NOTE_C6  1047
#define NOTE_CS6 1109
#define NOTE_D6  1175
#define NOTE_DS6 1245
#define NOTE_E6  1319
#define NOTE_F6  1397
#define NOTE_FS6 1480
#define NOTE_G6  1568
#define NOTE_GS6 1661
#define NOTE_A6  1760
#define NOTE_AS6 1865
#define NOTE_B6  1976
#define NOTE_C7  2093
#define NOTE_CS7 2217
#define NOTE_D7  2349
#define NOTE_DS7 2489
#define NOTE_E7  2637
#define NOTE_F7  2794
#define NOTE_FS7 2960
#define NOTE_G7  3136
#define NOTE_GS7 3322
#define NOTE_A7  3520
#define NOTE_AS7 3729
#define NOTE_B7  3951
#define NOTE_C8  4186
#define NOTE_CS8 4435
#define NOTE_D8  4699
#define NOTE_DS8 4978

typedef void (*GameMain_fn)(uint8_t gameindex);
typedef struct
{
  char name[GAME_NAME_LEN];
  GameMain_fn play_fn;
} GamesMenu_st;

GamesMenu_st _gameItems[TOTAL_GAMES] =
{
  {"UFO",             GAME_UFO_Start},
  {"Stacker",         GAME_STACKER_Start},
  {"Frogger",         GAME_FROGGER_Start},
#if !defined(ARDUINO_AVR_UNO)
  {"Space Attack",    GAME_SPACEATTACK_Start},
  {"Teris",           GAME_TERRIS_Start},
  {"Pacman",          GAME_PACMAN_Start},
  {"Bat Bonanza",     GAME_BATBONANZA_Start},
  {"Roller coaster",  GAME_ROLLERCOASTER_Start},
  {"Morse Decoder",   GAME_MORSE_Start},
  {"Breakout",        GAME_BREAKOUT_Start},
};
#endif

static bool mute = false;

void GAMES_Init()
{
  pinMode(SPEAKER_PIN, OUTPUT);
}

uint8_t GAMES_GetTotalGamesNum()
{
  return TOTAL_GAMES;
}

char *GAMES_GetGameName(uint8_t index)
{
  char *name = NULL;

  if (index < TOTAL_GAMES)
  {
    name = (char *)(_gameItems[index].name);
  }

  return name;
}

void GAMES_HighScoreResetAndMute(void)
{
  long startT = millis();
  long nowT =0;
  boolean sChange = 0;

  BUTTONS_Task();
  while (BUTTONS_Get(BTN_RIGHT) == BUTTON_PRESSED) {
    nowT = millis();
    if (nowT - startT > 2000) {
      sChange = 1;     
      if (BUTTONS_Get(BTN_LEFT) == BUTTON_PRESSED) {
        ssd1306_char_f6x8(8, 0, "-HIGH SCORE RESET-");
      } else if (mute == 0) { mute = 1; ssd1306_char_f6x8(32, 0, "-- MUTE --"); } else { mute = 0; ssd1306_char_f6x8(23, 0, "-- SOUND ON --");  }    
      break;
    }
    if (sChange == 1) break;
  }  

  while(BUTTONS_Get(BTN_RIGHT) == BUTTON_PRESSED) {};
}

void GAMES_Beep(int bCount, int bDelay) {
  if (mute) { return; }
#if 1
  tone(SPEAKER_PIN, bCount, bDelay);
#else
  for (int i = 0; i<=bCount; i++)
  {
    digitalWrite(SPEAKER_PIN,HIGH);
    for(int i2=0; i2<bDelay; i2++) {
      __asm__("nop\n\t");
    }

    digitalWrite(SPEAKER_PIN,LOW);
    for(int i2=0; i2<bDelay; i2++)
    {
      __asm__("nop\n\t");
    }
  }
#endif
}

void GAMES_BtnPressBeep() {
  GAMES_Beep(600, 100);
}

char *GAMES_ContinueMenuText(uint8_t index)
{
  const char *_continueText[2] = {"Continue", "Main menu"};
  return (char *)((index < 2)? _continueText[index] : NULL);
}

uint8_t GAMES_ContinueMenu(void)
{
  Menu_st continueMenu;
  uint8_t ret = 0;
  int8_t selection = -1;
  MAINMENU_Init(&continueMenu, 2, GAMES_ContinueMenuText);
  MAINMENU_DrawPage(&continueMenu, "OPTIONS");

  while (selection < 0)
  {
    selection = MAINMENU_Task(&continueMenu);
    switch (selection)
    {
      case 0: ret = GAME_END_CONTINUE; break;
      case 1: ret = GAME_END_MAINMENU; break;
      default: break;
    }

    WOKWI_DELAY
  }

  return ret;
}

void GAMES_Start(int8_t gameindex)
{
  if (gameindex < TOTAL_GAMES)
  {
    if (_gameItems[gameindex].play_fn != NULL)
    {
      do {
        _gameItems[gameindex].play_fn(gameindex);
      } while (GAMES_ContinueMenu() == GAME_END_CONTINUE);
    }
  }
}

void GAMES_End(int gameindex, int score)
{
  uint16_t prev_score = DB_HIGHSCORE_Getval(gameindex);

  SCREEN_Clear(DISPLAY_SCREEN);
  ssd1306_char_f6x8(11, 1, "----------------");
  ssd1306_char_f6x8(11, 2, "G A M E  O V E R");
  ssd1306_char_f6x8(11, 3, "----------------");
  ssd1306_char_f6x8(37, 5, "SCORE:");
  SCREEN_DrawNumber(75, 5, score);
  ssd1306_char_f6x8(21, 7, "HIGH SCORE:");
  SCREEN_DrawNumber(88, 7, prev_score);
  for (int i = 700; i > 200; i = i - 50) {
    GAMES_Beep(30,i);
  }
  delay(GAME_HIGHSCORE_SCREEN_TIME);

  if ((uint16_t)score > prev_score) {
    ssd1306_fillscreen(0x00);
    ssd1306_char_f6x8(10, 1, "----------------");
    ssd1306_char_f6x8(10, 3,  " NEW HIGH SCORE ");
    ssd1306_char_f6x8(10, 7, "----------------");
    SCREEN_DrawNumber(50, 5, score);
    DB_HIGHSCORE_SetVal(gameindex, score);

    for (int i = 0; i<1000; i = i+ 50) {
      GAMES_Beep(50,i);
    }
    delay(GAME_HIGHSCORE_SCREEN_TIME);
  }
}

games.cpp

#pragma once

#include <Arduino.h>
#include "configs.h"

#if defined(ARDUINO_AVR_UNO)
#define TOTAL_GAMES                             3
#else
#define TOTAL_GAMES                             10
#endif


#define GAME_START_SCREEN_TIME                  3000        //seconds
#define GAME_END_SCREEN_TIME                    3000
#define GAME_HIGHSCORE_SCREEN_TIME              3000

void GAMES_Init();
uint8_t GAMES_GetTotalGamesNum();
char *GAMES_GetGameName(uint8_t index);
void GAMES_HighScoreResetAndMute(void);
void GAMES_Beep(int freq, int duration);
void GAMES_Start(int8_t gameindex);
void GAMES_End(int gameindex, int score);

/* Database */
void DB_Init();
void DB_Store();
void DB_HIGHSCORE_SetVal(uint8_t index, uint16_t score);
uint16_t DB_HIGHSCORE_Getval(uint8_t index);

#if defined(KEYS_CONTROL_WIFI)
const char *DB_GetWifiSSID();
const char *DB_GetWifiPass();
void DB_UpdateWifiCredentials(String ssid, String pass);
#endif

/* Beep */
void GAMES_BtnPressBeep(void);

/* UFO */
void GAME_UFO_Start(uint8_t gameindex);

/* Stacker */
void GAME_STACKER_Start(uint8_t gameindex);

/* Frogger */
void GAME_FROGGER_Start(uint8_t gameindex);

/* Space Attack */
void GAME_SPACEATTACK_Start(uint8_t gameindex);

/* Terris */
void GAME_TERRIS_Start(uint8_t gameindex);

/* Pacman */
void GAME_PACMAN_Start(uint8_t gameindex);

/* Roller Coaster */
void GAME_ROLLERCOASTER_Start(uint8_t gameindex);

/* BAT BONANZA */
void GAME_BATBONANZA_Start(uint8_t gameindex);

/* Morse */
void GAME_MORSE_Start(uint8_t gameindex);

/* Breakout */
void GAME_BREAKOUT_Start(uint8_t gameindex);


games.h

logo.h

#include "menu.h"
#include "screen.h"
#include "buttons.h"
#include "games.h"

#define MENU_ITEMS                  10

/* Bitmap */
static const uint8_t cursor_arrow_bm[] = {
    0x00, 0x00, 0x04, 0x00, 0x06, 0x00, 0x3f, 0x00, 0x3f, 0x00, 0x06, 0x00, 0x04, 0x00, 0x00, 0x00
};

void MAINMENU_Init(Menu_st *menu, uint32_t total, getText_cb getText_fn)
{
  memset(menu, 0, sizeof(Menu_st));
  MENU_SetCursor(menu, total, MENU_PAGE_ITEMS);

  menu->DrawLine_fn = MAINMENU_DrawLine;
  menu->DrawPage_fn = MAINMENU_DrawLines;
  menu->GetText_fn  = getText_fn;
}

int8_t MAINMENU_Task(Menu_st *menu)
{
  int8_t ret = -1;

  BUTTONS_Task();
  if (BUTTONS_GetClicked(BTN_DOWN)) {
    GAMES_BtnPressBeep();
    MENU_MoveCursor(menu, MENU_KEY_DOWN);
  } else if (BUTTONS_GetClicked(BTN_UP)) {
    GAMES_BtnPressBeep();
    MENU_MoveCursor(menu, MENU_KEY_UP);
  } else if (BUTTONS_GetClicked(BTN_SELECT)) {
    GAMES_BtnPressBeep();
    ret = menu->Focus + menu->Top;
  }

  return ret;
}

void MAINMENU_DrawLine(Menu_st *cs, uint8_t line, bool focus)
{
  char buffer[32] = {0};
  const char *name = NULL;

  if (focus) {
    SCREEN_DrawBitMap(0, line * MENU_LINE_GAP + MENU_LIST_Y, cursor_arrow_bm, 16, 8);
  } else {
    SCREEN_FillRect(0, line * MENU_LINE_GAP + MENU_LIST_Y, CURSOR_ARROW_WIDTH, 8);
  }

  memset(buffer, 0, 32);
  if (cs->GetText_fn) {
    name = cs->GetText_fn(line + cs->Top);
  }

  if (name != NULL) {
    snprintf(buffer, 32, "%d. %s", line + 1 + cs->Top, name);
  } else {
    snprintf(buffer, 32, "%d. %s", line + 1 + cs->Top, "Unknown");
  }
  SCREEN_PrintAt(15, MENU_LIST_Y + (line * MENU_LINE_GAP), buffer);
}

void MAINMENU_DrawLines(Menu_st *cs)
{
  uint8_t i = 0;

  SCREEN_FillRect(0, MENU_LIST_Y, OLED_WIDTH, OLED_HEIGHT);

  for (i = 0; i < cs->Page; i++) {
    MAINMENU_DrawLine(cs, i, i == cs->Focus);
  }

  SCREEN_Display();
}

void MAINMENU_DrawPage(Menu_st *cs, const char *title)
{
  SCREEN_Clear();

  if (title) {
    SCREEN_PrintAt(40, 0, title);
  }

  MAINMENU_DrawLines(cs);
}

const uint8_t *MENU_GetCursorArrowBitmap()
{
  return cursor_arrow_bm;
}

void MENU_SetCursorToLast( Menu_st *cs )
{
  if (cs)
  {
    if ( cs->Total <= cs->Page )
    {
      cs->Top = 0;
      cs->Focus = cs->Total - 1;
    }
    else
    {
      cs->Top = cs->Total - cs->Page;
      cs->Focus = cs->Page - 1;
    }
  }
}

void MENU_SetCursor( Menu_st *cs, uint32_t Total, uint32_t PageUnit )
{
  if (cs)
  {
    cs->Total = Total;
    if( Total > PageUnit )
    {
      cs->Page = PageUnit;
    }
    else
    {
      cs->Page = Total;
    }

    if ( cs->Top + cs->Page > cs->Total )
    {
      if ( cs->Top > 0 )
      {
        cs->Top--;
      }
    }

    if ( cs->Focus >= cs->Total )
    {
      cs->Focus = cs->Total - 1;
    }
  }
}

void MENU_MoveCursor( Menu_st *cs, uint32_t key )
{
  int32_t prev_top = 0;
  int32_t prev_focus = 0;

	if( cs != NULL || cs->Page >= 1)
	{
    prev_top = cs->Top;
    prev_focus = cs->Focus;

    switch( key )
    {
      /* cursor is moved to up */
      case MENU_KEY_UP:
        if( cs->Focus > 0 )
        {
          cs->Focus--;
        }
        else
        {
          if( cs->Top > 0 )
          {
            cs->Top--;
          }
          else
          {
            cs->Top = cs->Total - cs->Page;
            cs->Focus = cs->Page - 1;
          }
        }
        break;
        
      /* cursor is moved to down */
      case MENU_KEY_DOWN:
        if( cs->Focus < cs->Page - 1 )
        {
          cs->Focus++;
        }
        else
        {
          if( cs->Top <  cs->Total - cs->Page )
          {
            cs->Top++;
          }
          else
          {
            cs->Top = 0;
            cs->Focus = 0;
          }
        }
        break;
        
      /* cursor is go up by one page */
      case MENU_KEY_PGUP:
        if( cs->Focus > 0 )
        {
          cs->Focus = 0;
        }
        else
        {
          if( cs->Top == 0 )
          {
            cs->Top = cs->Total - cs->Page;
            cs->Focus = cs->Page - 1;
          }
          else 	if( cs->Top - cs->Page <= 0 )
          {
            cs->Top = 0;
          }
          else
          {
            cs->Top = cs->Top - cs->Page;
          }
        }
        break;
        
      /* cursor is go down by one page */
      case MENU_KEY_PGDOWN:
        if( cs->Focus < cs->Page - 1 )
        {
          cs->Focus = cs->Page - 1;
        }
        else
        {
          if( cs->Top == cs->Total - cs->Page )
          {
            cs->Top = 0;
            cs->Focus = 0;
          }
          else 	if( cs->Top + cs->Page > cs->Total - cs->Page )
          {
            cs->Top = cs->Total - cs->Page;
          }
          else
          {
            cs->Top = cs->Top + cs->Page;
          }
        }
        break;
      
      default:
        break;
    }

    /* Update screen */
    if (prev_top != cs->Top) {
      if (cs->DrawPage_fn) {
        cs->DrawPage_fn(cs);
      }
    } else if (prev_focus != cs->Focus) {
        if (cs->DrawLine_fn) { 
          cs->DrawLine_fn(cs, prev_focus, MENU_LINE_IDLE);
          cs->DrawLine_fn(cs, cs->Focus, MENU_LINE_FOCUS);
          SCREEN_Display();
        }
    }
  }
}

menu.cpp

#pragma once

#include <Arduino.h>

#define MENU_LINE_IDLE                false
#define MENU_LINE_FOCUS               true

#define MENU_PAGE_ITEMS               5
#define CURSOR_ARROW_WIDTH            10
#define MENU_LINE_GAP                 10
#define MENU_LIST_Y                   15

typedef enum
{
  MENU_KEY_UP = (0),
  MENU_KEY_DOWN,
  MENU_KEY_PGUP,
  MENU_KEY_PGDOWN
} MenuKey_e;

typedef void (*drawPage_cb)(struct Menu_t *cs);
typedef void (*drawLine_cb)(struct Menu_t *cs, uint8_t line, bool focus);
typedef char *(*getText_cb)(uint8_t index);

typedef struct Menu_t
{
	int32_t	Top;      // Top index
	int32_t	Focus;    // Current focus index within visible page
	int32_t	Total;    // Total items
	int32_t	Page;     // Total visible items in a page
  drawPage_cb DrawPage_fn;
  drawLine_cb DrawLine_fn;
  getText_cb  GetText_fn;
} Menu_st;

void MAINMENU_Init(Menu_st *menu, uint32_t total, getText_cb getText_fn);
void MAINMENU_DrawPage(Menu_st *cs, const char *title);
void MAINMENU_DrawLines(Menu_st *cs);
void MAINMENU_DrawLine(Menu_st *cs, uint8_t line, bool focus);
void MENU_SetCursorToLast( Menu_st *cs );
void MENU_SetCursor( Menu_st *cs, uint32_t Total, uint32_t PageUnit );
void MENU_MoveCursor( Menu_st *cs, uint32_t key );
int8_t MAINMENU_Task(Menu_st *menu);
const uint8_t *MENU_GetCursorArrowBitmap();

menu.h

#include "games.h"
#include "screen.h"
#include "buttons.h"
#include "font6x8AJ.h"

#define FIRSTLINE 2     // The first displayed line of decoded morse on the LCD
#define LASTLINE 6      // The last displayed line of decoded morse on the LCD
#define LINELENGTH 20   // The number of characters on one completed line
#define MAXWORD 17      // The longest any single word can be (needed to manage buffer limits)

// Custom draw functions - allow for extra functionality like inverse display
void keyIsDown();
void keyIsUp();
void printSpace();
void shiftBits();
void printCharacter();
void deleteLastWord();
void printPunctuation();
void sendToLCD();
void newLine();
void blankLine(int line);
void scrollUp();

int stopRunning = 0;

// Variable declarations for decoder
int inputPin = BTN_RIGHT;         // input data comes in here (key or decoder)
int audio = 1;            // will store the value we read on this pin
int letterCount = 0;
int LCDline = FIRSTLINE;          // keeps track of which line we're printing on
boolean ditOrDah = true;  // We have either a full dit or a full dah
int dit;            

// The following values will auto adjust to the sender's speed
int averageDah;                   // A dah should be 3 times as long as a dit
int averageWordGap;               // will auto adjust

boolean characterDone = true; // A full character has been sent

int downTime = 0;        // How long the tone was on in milliseconds
int upTime = 0;          // How long the tone was off in milliseconds
int myBounce = 2;        // Used as a short delay between key up and down
long startDownTime = 0;  // Arduino's internal timer when tone first comes on
long startUpTime = 0;    // Arduino's internal timer when tone first goes off

int currentWordLength = 0;
int currentWordPos = 0;
char currentWord[MAXWORD];
char screenText[LASTLINE-FIRSTLINE+1][LINELENGTH+1];
int lastWordLength = 0;

boolean justDid = true; // Makes sure we only print one space during long gaps

int myNum = 0;           // We will turn dits and dahs into a binary number stored here
char mySet[] ="##TEMNAIOGKDWRUS##QZYCXBJP#L#FVH09#8###7#####/-61#######2###3#45";
char decodedCharacter = ' ';       // We will store the actual character decoded here

void GAME_MORSE_Init()
{
  SCREEN_Clear(DISPLAY_SCREEN);
  ssd1306_char_f6x8(0, 0, "  M O R S E");
  ssd1306_char_f6x8(0, 1, "      D E C O D E R");
  ssd1306_char_f6x8(27, 5, "andy jackson"); // see comments above !

  ssd1306_setpos(16,2); 
  for (int incr = 16; incr < 112; incr++) {
    ssd1306_send_data_start();
    ssd1306_send_byte(B00001010);
    ssd1306_send_data_stop();                    
  }
  ssd1306_setpos(27,4); 
  for (int incr = 0; incr < 72; incr++) {
    ssd1306_send_data_start();
    ssd1306_send_byte(B00100000);
    ssd1306_send_data_stop();                    
  }
  ssd1306_setpos(27,6); 
  for (int incr = 0; incr < 72; incr++) {
    ssd1306_send_data_start();
    ssd1306_send_byte(B00000100);
    ssd1306_send_data_stop();                    
  }

  delay(GAME_START_SCREEN_TIME);
}

void GAME_MORSE_Start(uint8_t gameindex)
{
  int wpm = 0;

  GAME_MORSE_Init();

  averageDah = 240;             // Starting point for auto-adjusting speed
  averageWordGap = averageDah;  // Will auto adjust
  dit = averageDah / 3;         
  lastWordLength = 0;
  letterCount = 0;
  LCDline = FIRSTLINE; 
  currentWordLength = 0;
  currentWordPos = 0;

  for (int i = 700; i>200; i = i - 50){
    GAMES_Beep(30,i);
  }

  SCREEN_Clear(DISPLAY_SCREEN);
  ssd1306_char_f6x8(0, 0, "Listening.. WPM:");
  wpm = floor(1200 / (float(averageDah/3.0)) );
  SCREEN_DrawNumber(96,0,wpm);

  while(stopRunning == 0) {
    BUTTONS_Task();
    audio = BUTTONS_Get(inputPin, BTN_NO_DELAY); // What is the tone decoder doing?
  
    if (audio == BUTTON_PRESSED) {
      keyIsDown();
      while(audio == BUTTON_PRESSED) {
        GAMES_Beep(50,250);
        BUTTONS_Task();
        audio = BUTTONS_Get(inputPin, BTN_NO_DELAY);
      }
    }

    if (audio == BUTTON_RELEASED) { 
      keyIsUp(); 
    }        
  }
}

void keyIsDown() {
   // The decoder is detecting our tone
   // The LEDs on the decoder and Arduino will blink on in unison
   
   
   if (startUpTime>0){
     // We only need to do once, when the key first goes down
     startUpTime=0;    // clear the 'Key Up' timer
     }
   // If we haven't already started our timer, do it now
   if (startDownTime == 0){
       startDownTime = millis();  // get Arduino's current clock time
      }

     characterDone=false; // we're still building a character
     ditOrDah=false;      // the key is still down we're not done with the tone
     delay(myBounce);     // Take a short breath here
     
   if (myNum == 0) {      // myNum will equal zero at the beginning of a character
      myNum = 1;          // This is our start bit  - it only does this once per letter
      }
 }
 
void keyIsUp() {
   // The decoder does not detect our tone
   // The LEDs on the decoder and Arduino will blink off in unison 
   
   // If we haven't already started our timer, do it now
   if (startUpTime == 0){startUpTime = millis();}
   
   // Find out how long we've gone with no tone
   // If it is twice as long as a dah print a space
   upTime = millis() - startUpTime;
   if (upTime<10)return;
   if (upTime > (averageDah*2)) {    
      printSpace();
   }
   
   // Only do this once after the key goes up
   if (startDownTime > 0){
     downTime = millis() - startDownTime;  // how long was the tone on?
     startDownTime=0;      // clear the 'Key Down' timer
   }
 
   if (!ditOrDah) {   
     // We don't know if it was a dit or a dah yet
      shiftBits();    // let's go find out! And do our Magic with the bits
    }

    // If we are still building a character ...
    if (!characterDone) {
       // Are we done yet?
       if (upTime > dit) { 
         // BINGO! we're done with this one  
         printCharacter();       // Go figure out what character it was and print it       
         characterDone=true;     // We got him, we're done here
         myNum=0;                // This sets us up for getting the next start bit
         }
         downTime=0;               // Reset our keyDown counter
       }
   }
   
void shiftBits() {
 
  // we know we've got a dit or a dah, let's find out which
  // then we will shift the bits in myNum and then add 1 or not add 1
  
  if (downTime < dit / 3) return;  // ignore my keybounce
  
  myNum = myNum << 1;   // shift bits left
  ditOrDah = true;        // we will know which one in two lines 
  
  
  // If it is a dit we add 1. If it is a dah we do nothing!
  if (downTime < dit) {
     myNum++;           // add one because it is a dit
     } else {
  
    // The next three lines handle the automatic speed adjustment:
    averageDah = (downTime+averageDah) / 2;  // running average of dahs

    if (averageDah > 1000) averageDah = 1000; // limiting slowest speed to about 3wpm !
   
    dit = averageDah / 3;                    // normal dit would be this
    dit = dit * 2;    // double it to get the threshold between dits and dahs
     }
  }

void printCharacter() {           
  justDid = false;         // OK to print a space again after this

  if (myNum == 511) {
    deleteLastWord();
    return;
  }
  
  // Punctuation marks will make a BIG myNum
  if (myNum > 63) {  
    printPunctuation();  // The value we parsed is bigger than our character array
                         // It is probably a punctuation mark so go figure it out.
    return;              
  }
  decodedCharacter = mySet[myNum]; 
  
  if (currentWordLength < MAXWORD) {
    currentWord[currentWordPos] = decodedCharacter;
    currentWordLength++;
    currentWordPos++;
    lastWordLength = currentWordLength; // this will ensure that lastWordLength is always the length of the most recent word
  } else printSpace();
  sendToLCD();      
}

void printSpace() {
  int wpm;

  if (justDid) return;  // only one space, no matter how long the gap
  justDid = true;       // so we don't do this twice

  currentWordLength = 0;
  currentWordPos = 0;

  wpm = floor(1200 / (float(averageDah/3.0)) );
  ssd1306_char_f6x8(96, 0, "   ");
  SCREEN_DrawNumber(96,0,wpm);
  
  // We keep track of the average gap between words and bump it up 20 milliseconds
  // do avoid false spaces within the word
  averageWordGap = ((averageWordGap + upTime) / 2) + 20;

  decodedCharacter=' ';            // this is going to go to the LCD 
  
  sendToLCD();         // go figure out where to put it on the display
}

void printPunctuation() {
  // Punctuation marks are made up of more dits and dahs than
  // letters and numbers. Rather than extend the character array
  // out to reach these higher numbers we will simply check for
  // them here. This funtion only gets called when myNum is greater than 63
  
  // Thanks to Jack Purdum for the changes in this function
  // The original uses if then statements and only had 3 punctuation
  // marks. Then as I was copying code off of web sites I added
  // characters we don't normally see on the air and the list got
  // a little long. Using 'switch' to handle them is much better.

  lastWordLength = currentWordLength; // this will ensure that lastWordLength is always the length of the most recent word
  
  switch (myNum) {
    case 71:
      decodedCharacter = ':';
      break;
    case 76:
      decodedCharacter = ',';
      break;
    case 84:
      decodedCharacter = '!';
      break;
    case 94:
      decodedCharacter = '-';
      break;
    case 97:
      decodedCharacter = 39;    // Apostrophe
      break;
    case 101:
      decodedCharacter = '@';
      break;
    case 106:
      decodedCharacter = '.';
      break;
    case 115:
      decodedCharacter = '?';
      break;
    case 246:
      decodedCharacter = '$';
      break;
    case 122:
      decodedCharacter = 's';
      sendToLCD();
      decodedCharacter = 'k';
      break;
    default:
      decodedCharacter = '#';    // Should not get here
      break;
  }
  sendToLCD();    // go figure out where to put it on the display
}

void sendToLCD(){
  uint8_t c,i;

  screenText[LCDline-FIRSTLINE][letterCount] = decodedCharacter;
  
  c = decodedCharacter - 32;
  ssd1306_setpos(letterCount*6,LCDline);
  ssd1306_send_data_start();
  for(i=0;i<6;i++)
  {
    ssd1306_send_byte(pgm_read_byte(&ssd1306xled_font6x8[c*6+i]));
  }
  ssd1306_send_data_stop();

  letterCount++; 

  if (letterCount > LINELENGTH) {
    newLine(); 
  }
}

void newLine() {
    int scrollNow = 0;
    int oldLine = LCDline;
    int scrolled = 0;
    
    if (LCDline == LASTLINE) {scrollNow = 1; oldLine = LASTLINE-1; scrolled = 1;} else {LCDline++; scrollNow = 0;}
    
    if (scrollNow == 1) scrollUp();
    blankLine(LCDline);
    
    letterCount = 0;


    if (decodedCharacter > ' ') {   
      for (int i = 0; i < currentWordLength; i++) {
        decodedCharacter = currentWord[i];
        sendToLCD();                        
        screenText[oldLine-FIRSTLINE][LINELENGTH-i] = ' '; 
      }  
      ssd1306_setpos(126-(currentWordLength*6),oldLine);
      ssd1306_send_data_start();
      for(int i=0;i<(currentWordLength*6);i++)
      {
        ssd1306_send_byte(0);
      }
      ssd1306_send_data_stop();
    }
}

void blankLine(int line) {
  uint8_t i;
 
  ssd1306_setpos(0,LCDline);
  ssd1306_send_data_start();
  for(i=0;i<128;i++)
  {
    ssd1306_send_byte(0);
  }
  ssd1306_send_data_stop();
}

void scrollUp() {
  int i,j,k,c;

  for(i = 0; i < LASTLINE-FIRSTLINE; i++) {
    for (j=0;j<LINELENGTH+1;j++) {
      screenText[i][j] = screenText[i+1][j];
      c = screenText[i][j] - 32;
      ssd1306_setpos(j*6,i+FIRSTLINE);
      ssd1306_send_data_start();
      for(k=0;k<6;k++)
      {
        ssd1306_send_byte(pgm_read_byte(&ssd1306xled_font6x8[c*6+k]));
      }
      ssd1306_send_data_stop();      
    }
  }  
}

void deleteLastWord() {

  if (lastWordLength < 1) return; 

  if (screenText[LCDline-FIRSTLINE][letterCount-1] == ' ') {
    letterCount--;
  }
  letterCount--;

  for(int i = 0; i < lastWordLength; i++) {
    ssd1306_setpos(letterCount*6,LCDline);
    ssd1306_send_data_start();
    for(int k=0;k<6;k++)
    {
      ssd1306_send_byte(0);
    }
    ssd1306_send_data_stop();    
    letterCount--;
  }
  letterCount++; // we will have gone one further back than the start of the deleted word
  lastWordLength = 0;
  if (letterCount < 0) letterCount = 0;
  justDid = true; // we don't want to stick another space in after deleting
}



morse.cpp

pacman.cpp

#include "screen.h"
#include "games.h"
#include "buttons.h"

typedef struct
{
  boolean stopAnimate = 0; // this is set to 1 when a collision is detected
  int score = 0;
  int top = 0;
  boolean newHigh = 0;
  boolean mute = 0;
  int playerOffset = 0; // y offset of the top of the player
} RollerCoasterInfo_st;


byte landscape[128];

byte i;
int totaldistance = 0;
byte interscore = 0;
float incr;
float start = 0.0;
float si = 0.1;
int gostep = 5;
float height = 25.0;
byte lastPos = 0;
int boost = 0;
boolean onit = 0;
int speedBoost = 0;
boolean doneUpdate = 0;
RollerCoasterInfo_st _rollerInfo;

byte doDrawRS(byte P2);
byte doDrawLS(byte P2);
byte doDrawRSP(byte column, byte P2);
byte doDrawLSP(byte column, byte P2);
void drawBird(byte startRow, byte endRow);
void drawLandscape(byte startRow, byte endRow);

void GAME_ROLLERCOASTER_Init()
{
  SCREEN_Clear(DISPLAY_SCREEN);
  ssd1306_char_f6x8(8, 1, "   --------------");
  ssd1306_char_f6x8(8, 2, "    W R E N      ");
  ssd1306_char_f6x8(8, 4, "    ROLLERCOASTER");
  ssd1306_char_f6x8(8, 5, "   --------------");
  ssd1306_char_f6x8(8, 7, "    andy jackson "); // see comments above !

  for (int k = 2; k>=0;k--){
    for (_rollerInfo.playerOffset = 55; _rollerInfo.playerOffset>0+(k*10);_rollerInfo.playerOffset--) {
      drawBird(0,8);
      GAMES_Beep(2,200+_rollerInfo.playerOffset);
      delay(2);
    }
    for (_rollerInfo.playerOffset = 0+(k*10); _rollerInfo.playerOffset<55;_rollerInfo.playerOffset++) {
      drawBird(0,8);
      GAMES_Beep(2,200+_rollerInfo.playerOffset);
      delay(2);
    }
  }

  delay(GAME_START_SCREEN_TIME);
}

void GAME_ROLLERCOASTER_Start(uint8_t gameindex)
{
  GAME_ROLLERCOASTER_Init();
  totaldistance = 0;
  interscore = 0;
  start = 3.14159265;
  si = 0.05;
  gostep = 5;
  height = 20.0;
  _rollerInfo.playerOffset = 0;
  lastPos = 0;
  boost = 0;
  onit = 0;
  speedBoost = 0;
  doneUpdate = 0;
  _rollerInfo.newHigh = 0;
  _rollerInfo.score = 0;
  totaldistance = 0;
  int thisrun = 0;
  
  SCREEN_Clear(DISPLAY_SCREEN);
  incr = start;
  for (i = 0; i < 128; i++) {
    float sinfactor = sin(incr);
    landscape[i] = floor(62 - height + (height * sinfactor));
    incr += si;
  }
  
  randomSeed(0);
  
  while (_rollerInfo.stopAnimate == 0) {
    BUTTONS_Task();
    // Total distance isn't really distance - it's a measure of how long the game's been running - used to stop the game
    totaldistance++;

    // Increment score every 10 cycles
    interscore += gostep;
    if (interscore >= 10) {
      interscore = 0;
      _rollerInfo.score++;
    }

    /*
     * NORMAL BUTTON USE
     */
    // With the left button down - the bird falls and height (but not speed) boost is reduced faster than normal
    if (BUTTONS_Get(BTN_LEFT, BTN_NO_DELAY) == BUTTON_PRESSED) {
      thisrun++;
      _rollerInfo.playerOffset += 2;
      boost -=10;
    } else {
      thisrun = 0;
    }
    
    if (onit && lastPos < _rollerInfo.playerOffset) {
      speedBoost+=10;
      boost+=7;
      } else {
      if (thisrun>30) {
        boost-=thisrun;
        speedBoost -= thisrun;
      }
      
    }
    lastPos = _rollerInfo.playerOffset;
   

    // With the right button pressed - the bird flaps (slightly slowing its descent)
    if (BUTTONS_Get(BTN_RIGHT, BTN_NO_DELAY) == BUTTON_PRESSED) {
      _rollerInfo.playerOffset -= 1;
    }

    /*
     *  HANDLING SLIDES AND OTHER ON-GROUND AND IN-AIR BEHAVIOUR
     */
    // Boost the speed and the height if you slide through the valleys
    if ( (_rollerInfo.playerOffset > 45) && onit && BUTTONS_Get(BTN_LEFT, BTN_NO_DELAY) == BUTTON_PRESSED) {
      boost +=75; // boost the flight
      speedBoost+=100; // boost the speed
      GAMES_Beep(1,350-speedBoost);
    } else {
      // The level of boost will keep the bird from falling (or even make it rise!)
      _rollerInfo.playerOffset -= floor(boost / 40); // Apply boost whilst in the air
    }
    
    // Cap speedboost!
    if (speedBoost > 700) {
      speedBoost = 700;
    }

    // Cap boost!
    if (boost > 450) {
      boost = 450;
    }

    // If you do nothing, the bird will gradually drop
    _rollerInfo.playerOffset += 3;

    // If you do nothing and you're in the air, the boost will drop
    if ((boost > 0) && (onit != 1)) {
      boost -=20;
    }
    if (boost < 0) boost = 0;

    // If you do nothing, the speed boost will drop
    if (speedBoost > 0) {
      speedBoost -= 7;
    }
    if (speedBoost < 0) speedBoost = 0;

    /*
     * APPLY SPEEDBOOST TO THE SPEED 
     */
    // This is the number of pixels the screen scrolls on each cycle of the game
    gostep = floor(2+speedBoost/110);

    // Detect whether the bird is on the ground
    onit = 0;
    if (_rollerInfo.playerOffset >= landscape[17] - 8) {
      onit = 1;
      _rollerInfo.playerOffset = landscape[17] - 8;
    }
    if (_rollerInfo.playerOffset <= 0) _rollerInfo.playerOffset = 0;

    // Just keep iterating around between zero and 2pi (roughly)
    if (incr >= 6.2831853) {
      incr -= 6.2831853;
    }

    //shift landscape left gostep places
    for (i = 0; i < 127 - gostep; i++) {
      landscape[i] = landscape[i + gostep];
    }

    // fill in the rest of the landscape
    for (i = 127 - gostep; i < 128; i++) {
      float sinfactor = sin(incr);
      if (sinfactor < -0.2) {
        sinfactor = -0.2 - (-0.2-sinfactor)/2.0;
      }
      landscape[i] = floor(62 - height + (height * sinfactor));
      if (sinfactor < 0.90) doneUpdate = 0;
      if (sinfactor > 0.97) {
        if (doneUpdate == 0) {
          byte newheight = (random(7, 25));
          while ( (newheight > height - 7) && (newheight < height + 7) ) newheight = (random(7, 25));
          height = newheight;
          si = (float)random(35,75)/1000.0;          
          doneUpdate = 1;
        }    
      }

      incr += si;
    }

    // Draw landscape and bird
    drawLandscape(2,8);    
    // Fill in the bird in the top couple of rows
    drawBird(0,2);

    /*
     * Debug mode code for monitoring parameters 
     */
     /*
    ssd1306_char_f6x8(85, 0, "    ");
    ssd1306_char_f6x8(85, 1, "    ");
    SCREEN_DrawNumber(85, 0, speedBoost);
    SCREEN_DrawNumber(85, 1, boost);
    */

    // Draw the score
    SCREEN_DrawNumber(85, 0, _rollerInfo.score);

    // Add time on to the game if the player is doing well
    if (_rollerInfo.score == 950 && interscore == 0) {
      totaldistance -=900;
    } else if (_rollerInfo.score == 1450  && interscore == 0) {
      totaldistance -=900;
    } else if (_rollerInfo.score == 1950  && interscore == 0) {
      totaldistance -=900;
    } else if (_rollerInfo.score == 2400  && interscore == 0) {
      totaldistance -=900;
    }

    if (totaldistance < 0) totaldistance = 0; // just in case - almost certainly would never happen!!

    // Draw the bar indicating the time left
    ssd1306_setpos(40, 0);
    ssd1306_send_data_start();
    ssd1306_send_byte(B11111111);
    for (float sc = 1;sc < 0.016*(2000-totaldistance); sc += 1.0) {
      ssd1306_send_byte(B10111101);
    }
    for (float sc = 0.016*(2000-totaldistance); sc<32; sc += 1.0) {
      ssd1306_send_byte(B10000001);
    }
    ssd1306_send_byte(B11111111);    
    ssd1306_send_data_stop();
    ssd1306_setpos(56, 0);
    ssd1306_send_data_start();
    ssd1306_send_byte(B11111111);
    ssd1306_send_data_stop();
 
    if (totaldistance >= 2000) {

      while (_rollerInfo.playerOffset < (landscape[17] - 8) ) {
        drawBird(0,2);
        drawLandscape(2,8);
        _rollerInfo.playerOffset++;
        delay(50);
      }
      
      _rollerInfo.stopAnimate = 1;
      delay(1000);
    }
  
  }
  delay(1500);

  GAMES_End(gameindex, _rollerInfo.score);
}

byte doDrawRS(byte P2) {
  return(B00000011 >> P2);
}
byte doDrawLS(byte P2) {
  return(B00000011 << P2);
}


byte doDrawRSP(byte column, byte P2) {
  switch(column) {
  case 0:
  return((B00111111) >> P2);
  break;
  case 1:
  return((B01111100) >> P2);
  break;
  case 2:
  return((B11111110) >> P2);
  break;
  case 3:
  return((B11100110) >> P2);
  break;
  case 4:
  return((B01100110) >> P2);
  break;
  case 5:
  return((B00111100) >> P2);
  break;
  case 6:
  return((B00011000) >> P2);
  break;
  default:
  return((B00010000) >> P2);
  break;
  }
}

byte doDrawLSP(byte column, byte P2) {
  switch(column) {
  case 0:
  return((B00111111) << P2);
  break;
  case 1:
  return((B01111100) << P2);
  break;
  case 2:
  return((B11111110) << P2);
  break;
  case 3:
  return((B11100110) << P2);
  break;
  case 4:
  return((B01100110) << P2);
  break;
  case 5:
  return((B00111100) << P2);
  break;
  case 6:
  return((B00011000) << P2);
  break;
  default:
  return((B00010000) << P2);
  break;
  }
}

void drawBird(byte startRow, byte endRow) {
    for (byte c = startRow; c < endRow; c++) {
    ssd1306_setpos(8, c);
    ssd1306_send_data_start();
    for (byte r = 8; r<16; r++) {
      int x = r;
      // bird with LS only
      if (c == _rollerInfo.playerOffset/8) {
        ssd1306_send_byte(doDrawLSP(r-8, _rollerInfo.playerOffset % 8));
      // bird with RS only
      } else if (c == _rollerInfo.playerOffset/8 + 1) {
        ssd1306_send_byte(doDrawRSP(r-8, 8- _rollerInfo.playerOffset % 8));
      } else {
        ssd1306_send_byte(B00000000);
      }
    }
    ssd1306_send_data_stop();
  }
}

void drawLandscape(byte startRow, byte endRow) {
  // Draw the landscape and bird 
  for (byte c = startRow; c < endRow; c++) {
    ssd1306_setpos(0, c);
    ssd1306_send_data_start();
    for (byte r = 0; r<127; r++) {
      int x = r;
      int y = landscape[r];
      if (r<8 || r>15) {
        if (c == y/8) {
          ssd1306_send_byte(doDrawLS(y % 8));
        } else if (c == y/8+1) {
          ssd1306_send_byte(doDrawRS(8 - y % 8));
        } else {
          ssd1306_send_byte(B00000000);
        }  
      } else {
        // landscape with LS only
        if ( (c == y/8) && (c != _rollerInfo.playerOffset/8) && (c != _rollerInfo.playerOffset/8 + 1) ) {
          ssd1306_send_byte(doDrawLS(y % 8));
        // landscape with RS only  
        } else if ( (c == y/8+1) && (c != _rollerInfo.playerOffset/8) && (c != _rollerInfo.playerOffset/8 + 1) ) {
          ssd1306_send_byte(doDrawRS(8 - y % 8));
        // bird with LS only  
        } else if ( (c != y/8+1) && (c != y/8) && (c == _rollerInfo.playerOffset/8) ) {
          ssd1306_send_byte(doDrawLSP(r-8, _rollerInfo.playerOffset % 8));
        // bird with RS only
        } else if ( (c != y/8+1) && (c != y/8) && (c == _rollerInfo.playerOffset/8 + 1) ) {
          ssd1306_send_byte(doDrawRSP(r-8, 8- _rollerInfo.playerOffset % 8));
        // both with LS
        } else if ( (c == y/8) && (c == _rollerInfo.playerOffset/8) ) {
          ssd1306_send_byte(doDrawLSP(r-8, _rollerInfo.playerOffset % 8) | doDrawLS(y % 8));            
        // both with RS
        } else if ( (c == y/8+1) && (c == _rollerInfo.playerOffset/8+1) ) {
          ssd1306_send_byte(doDrawRSP(r-8, 8-_rollerInfo.playerOffset % 8) | doDrawRS(8- y % 8));            
        // landscape left, bird right
        } else if ( (c == y/8) && (c == _rollerInfo.playerOffset/8+1) ) {
          ssd1306_send_byte(doDrawRSP(r-8, 8-_rollerInfo.playerOffset % 8) | doDrawLS(y % 8));            
        // landscape right, bird left
        } else if ( (c == y/8+1) && (c == _rollerInfo.playerOffset/8) ) {
          ssd1306_send_byte(doDrawLSP(r-8, _rollerInfo.playerOffset % 8) | doDrawRS(8- y % 8));            
        } else {
          ssd1306_send_byte(B00000000);
        }
      }      
    }
    ssd1306_send_data_stop();
  }

}

rollercoaster.cpp

#include <Wire.h>
#include <Adafruit_GFX.h>
#include "screen.h"
#include "font6x8AJ.h"
#include "logo.h"

Adafruit_SSD1306          _oled(OLED_WIDTH, OLED_HEIGHT, &Wire, OLED_RESET);
static uint8_t            _displayAddr = SSD1306_DEFAULT_ADDR;

bool SCREEN_Init(uint8_t addr)
{
  if(_oled.begin(SSD1306_SWITCHCAPVCC, addr)) {
    _oled.setTextSize(1);
    _oled.setTextColor(SSD1306_WHITE);
    _displayAddr = addr;

    SCREEN_Clear();
    SCREEN_DrawBitMap(32, 0, humalogo, LOGO_WIDTH, LOGO_HEIGHT);
    SCREEN_Display();
    return true;
  } else {
    return false;
  }
}

void SCREEN_Display(void)
{
  _oled.display();
}

void SCREEN_Clear(bool display)
{
  _oled.clearDisplay();
  if (display) { SCREEN_Display(); }
}

void SCREEN_FillScreen(uint16_t color, bool display)
{
  _oled.fillScreen(color);
  if (display) { SCREEN_Display(); }
}

void SCREEN_SetCursor(int16_t x, int16_t y)
{
  _oled.setCursor(x, y);
}

void SCREEN_SendCommand(char c)
{
  _oled.ssd1306_command(c);
}

void SCREEN_SendBytes(const uint8_t *c, uint8_t n)
{
  // _oled.
}

void SCREEN_Print(const char ch[], bool display)
{
  _oled.print(ch);
  if (display) { SCREEN_Display(); }
}

void SCREEN_PrintAt(uint8_t x, uint8_t y, const char ch[], bool display)
{
  SCREEN_SetCursor(x, y);
  SCREEN_Print(ch, display);
}

void SCREEN_DisplayOff()
{
  SCREEN_SendCommand(SSD1306_DISPLAYOFF);
}

void SCREEN_DisplayOn()
{
  SCREEN_SendCommand(SSD1306_DISPLAYON);
}

void SCREEN_DrawBitMap(int16_t x, int16_t y, const uint8_t bitmap[],
                       int16_t w, int16_t h, uint16_t color)
{
  _oled.drawBitmap(x, y, bitmap, w, h, color);
}

void SCREEN_FillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color, bool display)
{
  _oled.fillRect(x, y, w, h, color);
  if (display) { SCREEN_Display(); }
}

void SCREEN_DrawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color, bool display)
{
  _oled.drawRect(x, y, w, h, color);
  if (display) { SCREEN_Display(); }
}

void SCREEN_DrawNumber (int x, int y, int value) {
  char temp[10] = {0,0,0,0,0,0,0,0,0,0};
  itoa(value,temp,10);
  ssd1306_char_f6x8(x, y, temp);
}

void SCREEN_SendBlock(boolean fill) {
  if (fill==1) {
   ssd1306_send_byte(B00000000);
   ssd1306_send_byte(B01111110);
   ssd1306_send_byte(B01111110);
   ssd1306_send_byte(B01111110);
   ssd1306_send_byte(B01111110);
   ssd1306_send_byte(B01111110);
   ssd1306_send_byte(B01111110);
   ssd1306_send_byte(B00000000);
  } else {
   ssd1306_send_byte(B00000000);
   ssd1306_send_byte(B00000000);
   ssd1306_send_byte(B00000000);
   ssd1306_send_byte(B00000000);
   ssd1306_send_byte(B00000000);
   ssd1306_send_byte(B00000000);
   ssd1306_send_byte(B00000000);
   ssd1306_send_byte(B00000000);
  } 
}

/* ************************************************************************* */
void ssd1306_init(void){
}

void ssd1306_xfer_start(void) {
  Wire.beginTransmission(_displayAddr);
}

void ssd1306_xfer_stop(void) {
  Wire.endTransmission();
}

void ssd1306_send_byte(uint8_t byte) {
  Wire.write(byte);
}

void ssd1306_send_command(uint8_t command) {
  ssd1306_xfer_start();
  ssd1306_send_byte(0x00);  // write command
  ssd1306_send_byte(command);
  ssd1306_xfer_stop();
}

void ssd1306_send_data_start(void) {
  ssd1306_xfer_start();
  ssd1306_send_byte(0x40);  //write data
}

void ssd1306_send_data_stop(void) {
  ssd1306_xfer_stop();
}

void ssd1306_setpos(uint8_t x, uint8_t y)
{
  ssd1306_xfer_start();
  ssd1306_send_byte(0x00);  //write command

  ssd1306_send_byte(0xb0+y);
  ssd1306_send_byte(((x&0xf0)>>4)|0x10); // |0x10
  ssd1306_send_byte((x&0x0f)|0x01); // |0x01

  ssd1306_xfer_stop();
}

void ssd1306_fillscreen(uint8_t fill_Data) {
  SCREEN_FillScreen(fill_Data, DISPLAY_SCREEN);
}

void ssd1306_char_f6x8(uint8_t x, uint8_t y, const char *ch)
{
  uint8_t c,i,j=0;

  while (ch[j] != '\0')
  {
    c = ch[j] - 32;
#if 0
    if (c > 0) c = c - 12;
    if (c > 15) c = c - 6;
    if (c > 40) c = c - 9;
#endif
    if (x > 126) {
      x=0;
      y++;
    }

    ssd1306_setpos(x, y);
    ssd1306_send_data_start();
    for (i = 0; i < 6; i++) {
      ssd1306_send_byte(pgm_read_byte(&ssd1306xled_font6x8[c*6 + i]));
    }
    ssd1306_send_data_stop();

    x += 6;
    j++;
  }
}

void ssd1306_char_f8x8(uint8_t x, uint8_t y, const char ch[]) {
  uint8_t c, i, j = 0;

  while (ch[j] != '\0')
  {
    c = ch[j] - 32; // to space
    if (c > 0) c = c - 12; // to dash
    if (c > 15) c = c - 7; 
    if (c > 40) c = c - 6;

    ssd1306_setpos(y, x);
    ssd1306_send_data_start();
    for (byte lxn = 0; lxn < 8; lxn++) {    
      ssd1306_send_byte(pgm_read_byte(&font8x8[c][7-lxn]));      
    }

    ssd1306_send_data_stop();
    x+= 1;
    j++;
  }
}


screen.cpp

#pragma once
#include <Adafruit_SSD1306.h>
#include "configs.h"

#define DISPLAY_SCREEN                  true

bool SCREEN_Init(uint8_t addr = SSD1306_DEFAULT_ADDR);
void SCREEN_Display(void);
void SCREEN_Clear(bool display = false);
void SCREEN_FillScreen(uint16_t color, bool display = false);
void SCREEN_SetCursor(int16_t x, int16_t y);
void SCREEN_SendCommand(char c);
void SCREEN_Print(const char ch[], bool display = false);
void SCREEN_PrintAt(uint8_t x, uint8_t y, const char ch[], bool display = false);
void SCREEN_DisplayOff(void);
void SCREEN_DisplayOn(void);
void SCREEN_FillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color = SSD1306_BLACK, bool display = false);
void SCREEN_DrawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t color = SSD1306_WHITE, bool display = false);
void SCREEN_DrawBitMap(int16_t x, int16_t y, const uint8_t bitmap[],
                       int16_t w, int16_t h, uint16_t color = SSD1306_WHITE);
void SCREEN_DrawNumber(int x, int y, int value);
void SCREEN_SendBlock(boolean fill);

/* ************************************************************************* */
void ssd1306_init(void);
void ssd1306_xfer_start(void);
void ssd1306_xfer_stop(void);
void ssd1306_send_byte(uint8_t byte);
void ssd1306_send_command(uint8_t command);
void ssd1306_send_data_start(void);
void ssd1306_send_data_stop(void);
void ssd1306_setpos(uint8_t x, uint8_t y);
void ssd1306_fillscreen(uint8_t fill_Data);
void ssd1306_char_f6x8(uint8_t x, uint8_t y, const char *ch);
void ssd1306_char_f8x8(uint8_t x, uint8_t y, const char ch[]);

screen.h

#include "games.h"
#include "screen.h"
#include "buttons.h"

typedef struct
{
  boolean fire = 0;
  int topScoreB = 0;
  int player; //0 to 128-platformWidth  - this is the position of the player
  int platformWidth = 16; 
  boolean stopAnimate = 0; // this is set to 1 when a collision is detected
  boolean mute = 0;
  boolean newHigh = 0;
  int score = 0; // score - this affects the difficulty of the game
  int top = 0;
  boolean row[4][10]; // on-off array of aliens
  int level = 1; // Game level - incremented every time you clear the screen
} SpaceAttackInfo_st;

long firecounter = 0; // Timer for managing fire
long aliencounter = 0; // Timer for alien movement
int mothercounter = 0; // Timer for movement of the mothership

int mothershipX = 0; // position of mothership
int mothership = 0; // is mothership active?
int mothershipWidth = 8; // mothership width in pixels
int fireXidx, fireYidx; // mapping of player fire locaiton onto array of aliens
int leftLimit; // furtherst left in x-axis pixels that the aliens are currently
int positionNow = 0; // current position of the alien array (as steps from the left)
boolean alienDirection = 1; // current direction of travel for alien swarm - 1 is right 0 is left
int alienRow = 0; // which alien row are we considering
int alienFire[5][3]; // max 5 lots of alien fire  - indices are active, xpos, ypos
int playerFire[3]; // one lot of player fire - indices are active, xpos, ypos

int firstAlien = 0; // index of first live alien in the array
int lastAlien = 8; // index of last live alien in the array
int newFirst = firstAlien; // as above when it changes
int newLast = lastAlien; // ...
int aliensDead = 0; // how many aliens have been killed in total on this level?
int lastActiveRow = 2; // what's the lowest row in which we will find live aliens?
int deadOn1 = 0; // how many aliens are dead on row one (middle row)
int deadOn2 = 0; // how many aliens are dead on row two (bottom row)
SpaceAttackInfo_st _spaceInfo;

// Function prototypes
void resetAliens(void);
static void drawPlatform(void);
static void sendBlock(int);
static void levelUp(int);
void drawFire(int x, int y);
static void doDrawLS(long, byte);
static void doDrawRS(long, byte);
void clearAlienArea(int row, int lastActive);

void GAME_SPACEATTACK_Init()
{
  SCREEN_Clear(DISPLAY_SCREEN);

  ssd1306_char_f6x8(0, 1, "S P A C E");
  ssd1306_char_f6x8(4, 2, "A T T A C K");
  ssd1306_char_f6x8(0, 4, "andy jackson"); // see comments above !

  ssd1306_setpos(85,1);
  ssd1306_send_data_start();
  sendBlock(1);
  sendBlock(0);  
  sendBlock(1);
  ssd1306_send_data_stop();
  ssd1306_setpos(85,2);
  ssd1306_send_data_start();
  sendBlock(0);
  sendBlock(2);
  sendBlock(0);
  ssd1306_send_data_stop();
  ssd1306_setpos(85,3);
  ssd1306_send_data_start();
  sendBlock(0);
  sendBlock(0);  
  sendBlock(1);
  sendBlock(0);  
  sendBlock(1);
  ssd1306_send_data_stop();
  _spaceInfo.player = 96;
  drawPlatform();

  for (byte mm = 112;mm>=1;mm--) {
    if ( (mm>=32) && (mm<56) ) drawFire(104,mm);
      if (mm == 32) {
        ssd1306_setpos(100,3);      
        ssd1306_send_data_start();
        sendBlock(0);
        ssd1306_send_data_stop();
        ssd1306_setpos(100,4);      
        ssd1306_send_data_start();
        sendBlock(0);
        ssd1306_send_data_stop();
        GAMES_Beep(30,100);
      }
      ssd1306_setpos(mm,0);      
      ssd1306_send_data_start();
      sendBlock(3);
      sendBlock(0);
      ssd1306_send_data_stop();
      drawPlatform();
      delay(20);
    }
    ssd1306_setpos(0,0);      
    ssd1306_send_data_start();
    sendBlock(0);
    sendBlock(0);
    ssd1306_send_data_stop();
    ssd1306_char_f6x8(0, 6, "inspired by");  // see comments above !
    ssd1306_char_f6x8(0, 7, "/ebboggles.com");  // see comments above !
    delay(GAME_START_SCREEN_TIME);

    _spaceInfo.stopAnimate = 0;
    _spaceInfo.score = 0;
}

void GAME_SPACEATTACK_Start(uint8_t gameindex)
{
  GAME_SPACEATTACK_Init();
  SCREEN_Clear(DISPLAY_SCREEN);
  firecounter = 0; // Timer for managing fire
  _spaceInfo.level = 1; // Game level - incremented every time you clear the screen
  _spaceInfo.topScoreB = 0; // highscore
  _spaceInfo.score = 0; // obvious
  
  // Initialisations
  for (byte i = 0; i<5;i++) {
    alienFire[i][0] = 0;
  }
  resetAliens();

  levelUp(1); // This also does various essential initialisations
  
  // attachInterrupt(0,playerIncSpaceAttack,CHANGE);

  while (_spaceInfo.stopAnimate == 0) {
    while(_spaceInfo.stopAnimate == 0) {
    BUTTONS_Task();
    aliencounter++;
    firecounter++;
    mothercounter++;
    
    // deal with inputs
    if (BUTTONS_GetClicked(BTN_SELECT)) { _spaceInfo.fire = 1; } // this reads the reset pin (pin 1) of the Attiny85 - to use it, see comments section above

    if (BUTTONS_Get(BTN_RIGHT, BTN_NO_DELAY) == BUTTON_PRESSED) {
      if(_spaceInfo.player < 127-_spaceInfo.platformWidth) {
        _spaceInfo.player++;
      } 
    }
    if (BUTTONS_Get(BTN_LEFT, BTN_NO_DELAY) == BUTTON_PRESSED){
      if (_spaceInfo.player > 1) {
        _spaceInfo.player--;
        } 
     }

    if ( (mothership == 0) && (random(0,1000) > 998) && (alienRow > 0) ) {
      mothership = 1;
      mothershipX= 127-16;
    }

    // draw aliens
    for (int inc = 0; inc <= lastActiveRow; inc ++) {
      ssd1306_setpos((positionNow*8),inc+alienRow);
      ssd1306_send_data_start();
      for (int bl = firstAlien; bl <=lastAlien; bl++){
        if(_spaceInfo.row[inc][bl]==1){
          if (inc == lastActiveRow) {
            if(random(0,1000) > (999-_spaceInfo.level)) { // this alien is going to fire!
              byte afIndex = 0;
              while (alienFire[afIndex][0] == 1) {
                afIndex++; // search for empty alien fire option
                if (afIndex == 5) break;
              } 
              if (afIndex < 5) { // we've found a slot
                alienFire[afIndex][0] = 1; // activate fire on this slot
                alienFire[afIndex][1] = ( (positionNow*8) + ((bl-firstAlien) * 8) + 4); // x position
                alienFire[afIndex][2] = (inc+alienRow+1)*8; // Where the fire starts
              }
            } // end of this alien firing
          } // only if we are on the lowest row of live aliens
          if ( (inc == 0) || (inc == 2) ) {
            sendBlock(1);
          } else {
            sendBlock(2);
          }
        }else {
          sendBlock(0);
        }
       }   
      ssd1306_send_data_stop();
    }

    // Display the score
    SCREEN_DrawNumber(0,6,_spaceInfo.score);
    
    // Burn clock cycles to keep game at constant (ish) speed when there are low numbers of live aliens 
    int burnLimit = (8-(lastAlien-firstAlien));
    for (int burn = 0; burn < burnLimit; burn+=2) {                  
      drawPlatform();    
    }

    // Display the mothership
    if (mothercounter >= 3) {
      mothercounter = 0;    
      // draw mothership
      if (mothership) {
        ssd1306_setpos(mothershipX,0);
        ssd1306_send_data_start();
        sendBlock(3);
        sendBlock(0);
        ssd1306_send_data_stop();
        mothershipX --;
        if (mothershipX == 0) {
          mothership = 0;                      
          ssd1306_setpos(mothershipX,0);
          ssd1306_send_data_start();
          sendBlock(0);
          sendBlock(0);
          ssd1306_send_data_stop();
        }
      }
    }

    // Move the aliens
    if (aliencounter >= (92-((_spaceInfo.level-1)*5)) ) {
        aliencounter = 0;
      if(alienDirection) { // Moving right
        // move down a row
        if (positionNow >= 6+(8-(lastAlien-firstAlien))) {
          alienDirection = 0;
          clearAlienArea(alienRow,lastActiveRow);                                   
          alienRow++;
        } else {
          positionNow++;
        }
      } else { // Moving left
        // move down a row
        if (positionNow <= 0) {
          alienDirection = 1;
          clearAlienArea(alienRow,lastActiveRow);                                   
          alienRow++;
        } else {
          positionNow --;
        }
      } 
      clearAlienArea(alienRow,lastActiveRow);                                   
    }

    // Fire !
    if ((_spaceInfo.fire == 1) && (playerFire[0] == 0)) { // fire has been pressed and we're not currently firing - initiate fire!!
      playerFire[0] = 1;
      playerFire[1] = _spaceInfo.player+_spaceInfo.platformWidth/2; // xposition of new fire!
      playerFire[2] = 56;
    }

    // Handle all firing-related stuff (in both directions!)
    if (firecounter >= 2) {                  
      firecounter = 0;
      // --- Deal with player Firing --- 
      if (playerFire[0] == 1) {                      
          drawFire(playerFire[1], playerFire[2]);
          if (playerFire[2] == 0) {
            ssd1306_setpos(playerFire[1],0);
            uint8_t temp = B00000000;
            ssd1306_send_data_start();
            ssd1306_send_byte(temp);  
            ssd1306_send_data_stop();                                                          
            playerFire[0] = 0;
            _spaceInfo.fire = 0;
          } else {
            playerFire[2] = playerFire[2] - 1;                          
          }
      }
      
      // aliens are at positionNow * 8 + 8* their index
      
      leftLimit = positionNow*8;
      if ((_spaceInfo.fire == 1)) {
        fireXidx = firstAlien + floor((playerFire[1]-positionNow*8)/8);                    
        fireYidx=  floor(floor(playerFire[2]/8) - alienRow);
        
        if((mothership == 1) && (playerFire[1] >= mothershipX) && (playerFire[1] <= mothershipX +8) && playerFire[2] <=8) {
          long scm = random(1,100);
          if (scm<30) {
            _spaceInfo.score +=50;
          } else if (scm<60) {
            _spaceInfo.score += 100;
          } else if (scm<90) {
            _spaceInfo.score += 150;
          } else {
            _spaceInfo.score += 300;
          }
            
          GAMES_Beep(30,400);
          GAMES_Beep(30,300);          
          GAMES_Beep(30,200);
          GAMES_Beep(30,100);
          mothership = 0;
          ssd1306_setpos(mothershipX,0);
          ssd1306_send_data_start();
          sendBlock(0);
          sendBlock(0);
          ssd1306_send_data_stop();
        }

        // Alien has been hit
        if ((playerFire[1] >= leftLimit) && (fireYidx>=0) && (fireYidx<=lastActiveRow) && (fireXidx>=0) && (fireXidx<9)) {                    
          if (_spaceInfo.row[fireYidx][fireXidx] == 1) { 

            int lastActiveToClear = lastActiveRow; // if we kill the last alien on a row - we still need to clear that row (end of this fn)
            
            if (fireYidx == 2) deadOn2++;
            if (fireYidx == 1) deadOn1++;
            
            if (deadOn2 == 5) {lastActiveRow = 1;}
            if ((deadOn1 == 4) && (deadOn2 == 5)) {lastActiveRow = 0;}

            _spaceInfo.score = _spaceInfo.score + (int)((3-fireYidx) * 10);
                        
            aliensDead++;                      
            ssd1306_setpos(playerFire[1],alienRow+fireYidx+1);
            uint8_t temp = B00000000;
            ssd1306_send_data_start();
            ssd1306_send_byte(temp);  
            ssd1306_send_data_stop();                                                          
            GAMES_Beep(30,100);
            
            _spaceInfo.fire = 0;
            playerFire[0] = 0;
            playerFire[1] = 0;
            playerFire[2] = 7;
            _spaceInfo.row[fireYidx][fireXidx] = 0;
            
            if (fireXidx == firstAlien) { // this is the first Alien - sweep back and reset to new first alien
              for (int xi = lastAlien; xi>=firstAlien;xi--) {
                if ( (_spaceInfo.row[0][xi] == 1) || (_spaceInfo.row[1][xi] == 1) || (_spaceInfo.row[2][xi] == 1) ) newFirst = xi;
              }
              positionNow += newFirst - firstAlien;
              firstAlien = newFirst;
            }
            
            if (fireXidx == lastAlien) { // this is the last Alien - sweep thru and reset to new last alien
              for (int xi = firstAlien; xi<=lastAlien;xi++) {
                if ( (_spaceInfo.row[0][xi] == 1) || (_spaceInfo.row[1][xi] == 1) || (_spaceInfo.row[2][xi] == 1) ) newLast = xi;
              }
              lastAlien = newLast;
            }
            clearAlienArea(alienRow,lastActiveToClear);                        
          }         
        }
      }


      // --- Deal with Alien Firing --- 
      for (byte afIndex = 0; afIndex<5; afIndex++) {
        if(alienFire[afIndex][0] == 1) {
          drawFire(alienFire[afIndex][1],alienFire[afIndex][2]);
          alienFire[afIndex][2] = alienFire[afIndex][2] + 1;

          if (alienFire[afIndex][2] >= 56) {
            ssd1306_setpos(alienFire[afIndex][1],7);
            uint8_t temp = B00000000;
            ssd1306_send_data_start();
            ssd1306_send_byte(temp);  
            ssd1306_send_data_stop();                                                          
            alienFire[afIndex][0] = 0; // the fire's got to the end
            if( ((alienFire[afIndex][1]) > _spaceInfo.player) && ( (alienFire[afIndex][1]) < _spaceInfo.player+_spaceInfo.platformWidth) ) { // you've been hit!!
              _spaceInfo.stopAnimate = 1;
              break;
            }
          }
        }                  
      } // end of aliens firing

      if (_spaceInfo.stopAnimate) { break; }
    }

    if (aliensDead == 14) {
      for (int ai = 0; ai <= 5; ai++) alienFire[ai][0] = 0;

      _spaceInfo.level++;
      if (_spaceInfo.level>15) _spaceInfo.level = 15;
      levelUp(_spaceInfo.level);

      resetAliens();
    }
    
    if( ((alienRow == 5) && (lastActiveRow == 2))||  ( (alienRow == 6) && (lastActiveRow == 1)) || ((alienRow == 7) && (lastActiveRow == 0)) || _spaceInfo.stopAnimate) {
      _spaceInfo.stopAnimate = 1;
      break;
    }
    // draw the player
    drawPlatform();
    }
  }

  GAMES_End(gameindex, _spaceInfo.score);
}

void drawPlatform(){
 ssd1306_setpos(_spaceInfo.player,7);
 ssd1306_send_data_start();
 ssd1306_send_byte(B00000000);   
 ssd1306_send_byte(B00000000);   
 for (byte pw = 0; pw <5; pw++){ssd1306_send_byte(B11000000);}                
 for (byte pw = 0; pw <4; pw++){ssd1306_send_byte(B11110000);}                
 for (byte pw = 0; pw <5; pw++){ssd1306_send_byte(B11000000);}                
 ssd1306_send_byte(B00000000);   
 ssd1306_send_byte(B00000000);   
 ssd1306_send_data_stop();  
}

void sendBlock(int fill){
  if (fill == 1) {
   ssd1306_send_byte(B10011000);
   ssd1306_send_byte(B01011100);
   ssd1306_send_byte(B10110110);
   ssd1306_send_byte(B01011111);
   ssd1306_send_byte(B01011111);
   ssd1306_send_byte(B10110110);
   ssd1306_send_byte(B01011100);
   ssd1306_send_byte(B10011000);
  } else if (fill == 2) {
   ssd1306_send_byte(B00110000);
   ssd1306_send_byte(B00111110);
   ssd1306_send_byte(B10110011);
   ssd1306_send_byte(B01011101);
   ssd1306_send_byte(B01011101);
   ssd1306_send_byte(B10110011);
   ssd1306_send_byte(B00111110);
   ssd1306_send_byte(B00110000);  
  } else if (fill == 3) {
   ssd1306_send_byte(B00011000);
   ssd1306_send_byte(B00111000);
   ssd1306_send_byte(B00110100);
   ssd1306_send_byte(B00110100);
   ssd1306_send_byte(B00110100);
   ssd1306_send_byte(B00110100);
   ssd1306_send_byte(B00111000);
   ssd1306_send_byte(B00011000);  
  } else if (fill == 0) {
   ssd1306_send_byte(B00000000);
   ssd1306_send_byte(B00000000);
   ssd1306_send_byte(B00000000);
   ssd1306_send_byte(B00000000);
   ssd1306_send_byte(B00000000);
   ssd1306_send_byte(B00000000);
   ssd1306_send_byte(B00000000);
   ssd1306_send_byte(B00000000);
  } 
}

void levelUp(int number) {

  _spaceInfo.fire = 0; // make sure no fire
  playerFire[0] = 0; // player fire inactive
  aliencounter=0;
  firecounter=0;
  mothercounter=0;
  firstAlien = 0;
  lastAlien = 8;
  newFirst = 0;
  newLast = 8;
  lastActiveRow = 2;
  deadOn1 = 0;
  deadOn2 = 0;
  aliensDead = 0;      
  mothership = 0;
  alienRow = 0;
  positionNow = 0;
  alienDirection = 1;
  _spaceInfo.player = 64;

  ssd1306_fillscreen(0x00);
  ssd1306_char_f6x8(16, 3, "--------------");
  ssd1306_char_f6x8(16, 4, " L E V E L ");
  ssd1306_char_f6x8(16, 5, "--------------");
  SCREEN_DrawNumber(85,4,number);
  for (int i = 800; i>200; i = i - 200){
  GAMES_Beep(30,i);
  }
  delay(700);    
  ssd1306_fillscreen(0x00);
}

void drawFire(int x, int y) {
  if (y%8!=0){
    ssd1306_setpos(x,y/8);
    ssd1306_send_data_start();
    doDrawLS(0,y%8);
    ssd1306_send_data_stop();
    
    ssd1306_setpos(x,y/8+1);
    ssd1306_send_data_start();
    doDrawRS(0,8-y%8);
    ssd1306_send_data_stop();
  } else {
    ssd1306_setpos(x,y/8);
    ssd1306_send_data_start();
    doDrawLS(0,0);
    ssd1306_send_data_stop();
  }
}

// Drawing routine for the player and fire - with right-shifts
void doDrawRS(long P1, byte P2) {
  ssd1306_send_byte((B01111110 | P1)>>P2);
}

// Drawing routine for the player and fire - with left-shifts
void doDrawLS(long P1, byte P2) {
  ssd1306_send_byte((B01111110 | P1)<<P2);
}

void clearAlienArea(int row, int lastActive) {
  // clear alien area
  for (int inc = row; inc <=row+lastActive; inc ++) {
    ssd1306_setpos(0,inc);
    ssd1306_send_data_start();
    for (int bl = 0; bl <16; bl++){
      sendBlock(0);
      }   
      ssd1306_send_data_stop();
    }
}

void resetAliens(void) {
  for (byte i =0; i<10;i++){ // reset aliens
    _spaceInfo.row[0][i]=0; _spaceInfo.row[1][i]=0; _spaceInfo.row[2][i]=0;
  } 
  for (byte i =0; i<9;i+=2){ // reset aliens
    _spaceInfo.row[0][i]=1; _spaceInfo.row[2][i]=1;
  } 
  for (byte i =1; i<9;i+=2){ // reset aliens
    _spaceInfo.row[1][i]=1;
  }     
}


spaceattack.cpp

#include "games.h"
#include "screen.h"
#include "buttons.h"

typedef struct 
{
  boolean fire = 0;
  int topScoreB = 0;
  boolean stopAnimate = 0; // this is set to 1 when a collision is detected
  boolean mute = 0;
  boolean newHigh = 0;
  int score = 0; // score - this affects the difficulty of the game
  int top = 0;
  boolean row[2][16]; // on-off array of blocks - building up from the bottom
} StackerInfo_st;

boolean perfect = 1;
int runCounter = 0;
boolean fireLock = 0;
boolean fireCounterActive = 0;
int fireCounter = 0;
int level = 1; // Game level - incremented every time you clear the screen
boolean blockDirection = 1; // current direction of travel for blocks - 1 is right 0 is left
int stackRow = 0; // which row are we considering
int movecounter = 0; // timer for movement
int matchCount = 6;
StackerInfo_st _stackerInfo;

void levelUp(int number);
void resetBlocks(void);
void drawRow(int thisRow, int location);

void GAME_STACKER_Init()
{
  SCREEN_Clear(DISPLAY_SCREEN);
  for (int j = 0;j<16;j++) {
    _stackerInfo.row[0][j] = 0;
  }
  for (int i= 14;i<15;i++) {
    _stackerInfo.row[0][i] = 1;
  }
  drawRow(0,2);

  for (int i= 13;i<15;i++) {
    _stackerInfo.row[0][i] = 1;
  }
  drawRow(0,3);

  for (int i= 13;i<16;i++) {
    _stackerInfo.row[0][i] = 1;
  }
  drawRow(0,4);

  for (int i= 13;i<16;i++) {
    _stackerInfo.row[0][i] = 1;
  }
  drawRow(0,5);

  for (int i= 12;i<16;i++) {
    _stackerInfo.row[0][i] = 1;
  }
  drawRow(0,6);

  for (int i= 12;i<16;i++) {
    _stackerInfo.row[0][i] = 1;
  }
  drawRow(0,7);  

  ssd1306_char_f6x8(0, 2, "S T A C K E R");
  ssd1306_char_f6x8(0, 4, "andy jackson"); // see comments above !
  ssd1306_char_f6x8(0, 6, "inspired by");  // see comments above !
  ssd1306_char_f6x8(0, 7, "/ebboggles.com");  // see comments above !
  delay(GAME_START_SCREEN_TIME);

  _stackerInfo.stopAnimate = 0;
  _stackerInfo.score = 0;
}

void GAME_STACKER_Start(uint8_t gameindex)
{
  GAME_STACKER_Init();
  runCounter = 0;
  movecounter = 0;
  level = 1; // Game level - incremented every time you clear the screen
  blockDirection = 1; // current direction of travel for blocks - 1 is right 0 is left
  stackRow = 6; // what's the index of the current active row (0 is the top line, 7 is the bottom)?
  _stackerInfo.topScoreB = 0; // highscore
  _stackerInfo.fire = 0; // make sure no fire
  _stackerInfo.score = 0; // obvious
  _stackerInfo.stopAnimate = 0;
  matchCount = 6;
  fireLock = 0;
  fireCounterActive = 0;
  fireCounter = 0;
  perfect = 1;

  SCREEN_Clear(DISPLAY_SCREEN);
  resetBlocks();
  
  // draw base row
  drawRow(1,7);

  while (_stackerInfo.stopAnimate == 0) {
      yield();
      movecounter++;
      SCREEN_DrawNumber(0, 7, _stackerInfo.score);

      // All this stuff is a complex debounce on the fire/trigger button
      if (fireCounterActive) { fireCounter++; }
      if ( (fireCounter >= 10) && fireCounterActive ) {
        fireCounterActive = 0;
        fireLock = 0;
        _stackerInfo.fire = 0;
      }

      BUTTONS_Task();
      if (BUTTONS_GetClicked(BTN_LEFT) ||
          BUTTONS_GetClicked(BTN_RIGHT) ||
          BUTTONS_GetClicked(BTN_DOWN) ||
          BUTTONS_GetClicked(BTN_UP) ||
          BUTTONS_GetClicked(BTN_SELECT)) {
        _stackerInfo.fire = 1;
      }

      drawRow(0,stackRow);     

      // Fire / stop the blocks!
      if ( (fireLock == 0) && (_stackerInfo.fire == 1) ) { // fire has been pressed - do stuff - check for alignment, update the array and decrement active row
        int matchTarget = matchCount;
        runCounter = 0;
        matchCount = 0;
        for (int i = 0; i < 16; i++) {
          if (_stackerInfo.row[1][i] == 1) {
            if (_stackerInfo.row[0][i] == 1) {
              matchCount++;
              _stackerInfo.row[1][i] = 1;
            } else {
              _stackerInfo.row[1][i] = 0;
            }
          }
        }
        if (matchCount < matchTarget) { perfect = 0; }

        // draw stack row - now fixed
        drawRow(1,stackRow);
                                            
        stackRow--;

        if (matchCount > 0 ) {
          _stackerInfo.score += (7 - stackRow);
          GAMES_Beep(50,300);
        }
        fireLock = 1; // lock fire until the button is lifted and the timeout is done
        _stackerInfo.fire = 0;
        fireCounter = 0;
        fireCounterActive = 1;

        // fill the next row (unless we're already at the top! - arduino hates attempts to access arrays with negative indices
        if (stackRow >= 0) {
          for (int i=0; i < matchCount; i++) {
            _stackerInfo.row[0][i] =1;
          } 
          for (int i=matchCount; i < 16; i++) {
            _stackerInfo.row[0][i] =0;
          }
        }
      } // end of fire routine
   
      // Move the blocks
      int speedNow = 13-level;
      if (speedNow < 4) { speedNow = 4; }
      if (movecounter >= speedNow) {
        movecounter = 0;
        if (blockDirection) { // Moving right
          if (_stackerInfo.row[0][15] == 1) { // we've hit the end
            runCounter++;
            if (runCounter > 20) { // runCounter kills the game if no activity for 20 cycles
              _stackerInfo.stopAnimate = 1;     // this is to prevent the battery being drained if the game is accidentally started
              break;
            }

            blockDirection = 0;
          } else {
            for(int i=15; i > 0; i--) { // shuffle right
              _stackerInfo.row[0][i] = _stackerInfo.row[0][i-1];
            } 
            _stackerInfo.row[0][0] = 0;          
          }
        } else { // Moving left
          if (_stackerInfo.row[0][0] == 1) { // we've hit the end
            blockDirection = 1;
          } else {
            for(int i=0; i < 15; i++) { // shuffle left
              _stackerInfo.row[0][i] = _stackerInfo.row[0][i+1];
            } 
            _stackerInfo.row[0][15] = 0;
          }
        }
      }

      if (matchCount == 0) { // deal with failure here 
        _stackerInfo.stopAnimate = 1;
        break;
      }

      // Level up
      if (stackRow < 0) {
        if (level <6) {
          matchCount = 6;
        } else if (level < 9) {
          matchCount = 5;
        } else if (level < 12) {
          matchCount = 4;
        } else if (level < 15) {
          matchCount = 3;
        } else {
          matchCount = 2;
        }
        fireCounter = 0;
        fireLock = 0;
        fireCounterActive = 0;
        movecounter=0;
        stackRow = 6;
        level++;
        levelUp(level);
        blockDirection = 1;
        perfect = 1;
        resetBlocks();
        _stackerInfo.fire =0;
        
        // draw base row
        drawRow(1,7);

        for (int i = 700; i>100; i = i - 100) {
          GAMES_Beep(30,i);
        }
      }
  }

  GAMES_End(gameindex, _stackerInfo.score);
}

void levelUp(int number) {
  ssd1306_fillscreen(0x00);
  ssd1306_char_f6x8(16, 1, "--------------");
  ssd1306_char_f6x8(16, 2, " L E V E L ");
  ssd1306_char_f6x8(16, 3, "--------------");
  if (perfect) {
     ssd1306_char_f6x8(25, 5, "PERFECT LEVEL");
     ssd1306_char_f6x8(25, 7, "  100 BONUS");
     _stackerInfo.score += 100;
  }
  SCREEN_DrawNumber(85,2,number);
  for (int i = 800; i>200; i = i - 200){
  GAMES_Beep(30,i);
  }
  delay(1500);    
  ssd1306_fillscreen(0x00);
}

void resetBlocks(void) {
  for (byte j = 0;j<16;j++) {
    _stackerInfo.row[0][j] = 0;
  }
  for (byte j = 0;j<16;j++) {
    _stackerInfo.row[1][j] = 0;
  }

  for (int i=6;i<6+matchCount;i++) {
    _stackerInfo.row[1][i] = 1;
  }
  
  for (int i=0;i<matchCount;i++) {
    _stackerInfo.row[0][i] =1;
  }
}


void drawRow(int thisRow, int location) {
  if (thisRow <0) return;
  if (thisRow>1) return;
  ssd1306_setpos(0,location);
  ssd1306_send_data_start();
  for(int j=0;j<16;j++) {
    if (_stackerInfo.row[thisRow][j] == 1) {
      SCREEN_SendBlock(1);
    } else {
      SCREEN_SendBlock(0);
    }
  }
  ssd1306_send_data_stop();                    
}


stacker.cpp

terris.cpp

#include "screen.h"
#include "buttons.h"
#include "games.h"

boolean stopAnimate = 0; // this is set to 1 when a collision is detected
int score = 0; // score - this affects the difficulty of the game
boolean fire = 0;

int obstacle[9] = {-50,-50,-50,-50,-50,-50,-50,-50,-50}; // x offset of the obstacle default position, out of view
byte gapOffset[9] = {0,0,0,0,0,0,0,0,0}; // y offset of the fly-through gap
int gapSize[9]; // y height of the gap
byte maxGap = 60; // max height of the gap
int stepsSinceLastObstacle = 0; // so obstacles are not too close
byte gapBlock[9] = {0,0,0,0,0,0,0,0,0}; // if the fly-through gap is closed
int topScoreU = 0;
boolean isStacker = 0;
byte maxObstacles = 1; // this defines the max number of in game obstacles
byte obstacleStep = 2; // pixel step of obstacles per frame
byte blockChance = 0; // this higher value decreases the likelihood of gap being closed 
byte fireCount = 0; // the shot is persistent for several frames
byte playerOffset = 0; // y offset of the top of the player
byte flames = 0; // this is set to 1 when the move up interrupt is triggered
byte flameMask[2]={B00111111,B11111111}; // this is used to only show the flame part of the icon when moving up
void GAME_UFO_DrawLS(long, byte);
void GAME_UFO_DrawRS(long, byte);

void GAME_UFO_Init(void)
{
  SCREEN_Clear(DISPLAY_SCREEN);
  
  for (byte s = 0; s < 30; s++){ // generate stars
    ssd1306_setpos((uint8_t)(random(0,127)),(uint8_t)(random(0,7)) );
    ssd1306_send_data_start();
    ssd1306_send_byte(B10000000>>random(0,7)); 
    ssd1306_send_data_stop();
  }

  ssd1306_char_f6x8(14, 2, "U F O  C H A O S");
  // The lower case character set is seriously compromised because I've had to truncate the ASCII table
  // to release space for executable code - hence lower case y and w are remapped to h and / respectively.
  // There is no z in the table (or h!) as these aren't used anywhere in the text here and most of the 
  // symbols are also missing for the same reason (see my hacked version of font6x8.h - font6x8AJ.h for more detail)
  ssd1306_char_f6x8(3, 4, "mods by andy jackson"); // see comments above !
  ssd1306_char_f6x8(17, 6, "original game by");  // see comments above !
  ssd1306_char_f6x8(22, 7, "/ebboggles.com");  // see comments above !
  delay(GAME_START_SCREEN_TIME);

  stopAnimate = 0;
  score = 0;
}

void GAME_UFO_Start(uint8_t gameindex)
{
  int fireLock = 0;

  GAME_UFO_Init(); 

  fire = 0;
  maxObstacles = 3;
  obstacleStep = 2;
  for (byte i = 0; i<9; i++) {
    obstacle[i] = -50;
    gapOffset[i]=0;
  }

  stepsSinceLastObstacle = 0;
  playerOffset = 0; // y offset of the top of the player
  fireLock = 0;
  
  SCREEN_Clear(DISPLAY_SCREEN);
  while (stopAnimate == 0)
  {
    BUTTONS_Task();
    // deal with inputs
    if (BUTTONS_Get(BTN_RIGHT, BTN_NO_DELAY) == BUTTON_PRESSED) { 
      if (fireLock == 0) {
        GAMES_BtnPressBeep();
        fire =1; fireCount = 5;
        fireLock = 1;
      } 
    } else { fireLock = 0; }

    //update game vars to make it harder to play
    if (score < 500) {
      blockChance = 11-score/50;
      if (maxObstacles<5) {
        maxObstacles=(score+40)/70+1;
      }
      delayMicroseconds(16000/maxObstacles);
    }

    if (score < 2000) { maxGap = 60-score/100; }
    if (fire == 1) { score--; }
    if (fireCount > 0) { fireCount--; }

    for (int boo = 0; boo<3; boo++) {
      if (BUTTONS_Get(BTN_UP, BTN_NO_DELAY) == BUTTON_PRESSED) {
        if (playerOffset > 0) {
          playerOffset--; 
          flames = 1; // move player up
        }
      }
    }

    stepsSinceLastObstacle += obstacleStep;
    for (byte i = 0; i < maxObstacles; i++) { // fly obstacles
      if (obstacle[i] >= 0 && obstacle[i] <= 128) {
        obstacle[i] -= obstacleStep;
        if (gapBlock[i] > 0 && obstacle[i] < 36  && playerOffset>gapOffset[i] && playerOffset+5<gapOffset[i]+gapSize[i] && fireCount > 0) {//
          gapBlock[i] = 0;
          score += 5; 
          // for (byte cp = 400; cp>0; cp--) {
          //   GAMES_Beep(1,cp);
          // }
        }
      } 

      if (obstacle[i] <= 4 && stepsSinceLastObstacle >= random(30,100)) { // generate new obstacles
        obstacle[i] = 123;
        gapSize[i] = random(25,maxGap);
        gapOffset[i] = random(0,64-gapSize[i]);
        if (random(0,blockChance) == 0) {
          gapBlock[i] = 1;
        } else {
          gapBlock[i] = 0;
        }
        stepsSinceLastObstacle = 0;
        score+=1;
      }
    }
  
    if ( (fireCount == 0) && (playerOffset < 56) ){ playerOffset++; } // player gravit
  
    // update what's on the screen
    // erase player
    for (byte r=0; r<8; r++) {
      if (r < playerOffset/8 | r >= playerOffset / 8+1) {
        ssd1306_setpos(0,r);
        ssd1306_send_data_start();
        SCREEN_SendBlock(0);
        SCREEN_SendBlock(0);
        ssd1306_send_data_stop();
      }
    }
  
    //erase fire
    ssd1306_setpos(16,playerOffset/8);
    ssd1306_send_data_start();
    if (fireCount == 0) {
      for (byte f = 0; f <= 30; f++) {
        ssd1306_send_byte(B00000000);
      }
    }
    ssd1306_send_data_stop();
  
    // Send Obstacle
    for (byte i = 0; i<maxObstacles;i++) {
      if (obstacle[i] >= -5 && obstacle[i] <= 128) { // only deal with visible obstacles
        if (obstacle[i] > 8 && obstacle[i] <16) { // look for collision if obstacle is near the player
          if (playerOffset < gapOffset[i] || playerOffset+5 > gapOffset[i]+gapSize[i] || gapBlock[i] != 0) {
            // collision - stop looping
            stopAnimate = 1;
          }
        }
  
        for (byte row = 0; row <8; row++)
        {
          ssd1306_setpos(obstacle[i],row);
          ssd1306_send_data_start();

          // if (i > 0) {Serial.printf("row: %d\n", row);}
          if (obstacle[i] > 0 && obstacle[i] < 128)
          {
            if ((row+1)*8 - gapOffset[i] <= 8) { // generate obstacle : top and transition
              byte temp = B11111111>>((row+1)*8 - gapOffset[i]); 
              byte tempB = B00000000; 
              if (gapBlock[i]>0){tempB=B10101010;}
              ssd1306_send_byte(temp);
              ssd1306_send_byte(temp|tempB>>1);
              ssd1306_send_byte(temp|tempB);
              ssd1306_send_byte(temp);
            }
            else if (row*8 >= gapOffset[i] && (row+1)*8 <= gapOffset[i] + gapSize[i]) { // middle gap
              byte tempB = B00000000; 
              if (gapBlock[i]>0){tempB=B10101010;}
              ssd1306_send_byte(B00000000);
              ssd1306_send_byte(B00000000|tempB>>1);
              ssd1306_send_byte(B00000000|tempB);
              ssd1306_send_byte(B00000000);
            }
            else if ((gapOffset[i] +gapSize[i]) >= row*8 && (gapOffset[i] +gapSize[i]) <= (row+1)*8) { // bottom transition
              byte temp = B11111111<<((gapOffset[i] + gapSize[i])%8); 
              byte tempB = B00000000; 
              if (gapBlock[i]>0){tempB=B10101010;}
              ssd1306_send_byte(temp);
              ssd1306_send_byte(temp|tempB>>1);
              ssd1306_send_byte(temp|tempB);
              ssd1306_send_byte(temp);
            }
            else { // fill rest of obstacle
              ssd1306_send_byte(B11111111);
              ssd1306_send_byte(B11111111);
              ssd1306_send_byte(B11111111);
              ssd1306_send_byte(B11111111);
            }

            ssd1306_send_byte(B00000000);
            ssd1306_send_byte(B00000000);
          }

          ssd1306_send_data_stop();
        }
      }
    }
   
    if (playerOffset % 8 != 0) {
      ssd1306_setpos(8,playerOffset/8);
      ssd1306_send_data_start();
      GAME_UFO_DrawLS(0,playerOffset%8);
      ssd1306_send_data_stop();
      
      ssd1306_setpos(8,playerOffset/8+1);
      ssd1306_send_data_start();
      GAME_UFO_DrawRS(0,8-playerOffset%8);
      ssd1306_send_data_stop();
    } else {
      ssd1306_setpos(8,playerOffset/8);
      ssd1306_send_data_start();
      GAME_UFO_DrawLS(0,0);
      ssd1306_send_data_stop();
    }

    // Display score in the screen corner
    SCREEN_DrawNumber(92, 0, score);
    
    flames = 0;
  }

  GAMES_End(gameindex, score);
}

// Drawing routine for the player and fire - with right-shifts
void GAME_UFO_DrawRS(long P1, byte P2) {
  ssd1306_send_byte(((B00001100&flameMask[flames]) | P1)>>P2);
  ssd1306_send_byte(((B01011110&flameMask[flames]) | P1)>>P2);
  ssd1306_send_byte(((B10010111&flameMask[flames]) | P1)>>P2);
  ssd1306_send_byte(((B01010011&flameMask[flames]) | P1)>>P2);
  ssd1306_send_byte(((B01010011&flameMask[flames]) | P1)>>P2);
  ssd1306_send_byte(((B10010111&flameMask[flames]) | P1)>>P2);
  ssd1306_send_byte(((B01011110&flameMask[flames]) | P1)>>P2);
  ssd1306_send_byte(((B00001100&flameMask[flames]) | P1)>>P2);  
  
  if (fireCount >0) {
        for (byte f = 0; f<=24; f++){
            ssd1306_send_byte(B00000100>>P2);
        }
        ssd1306_send_byte(B00010101>>P2);
        //ssd1306_send_byte(B00001010>>P2);
        ssd1306_send_byte(B00010101>>P2);
        // if (fire==1){GAMES_Beep(50,100);}
        fire = 0;
  } 
}

// Drawing routine for the player and fire - with left-shifts
void GAME_UFO_DrawLS(long P1, byte P2) {
  ssd1306_send_byte((B00001100&flameMask[flames] | P1)<<P2);
  ssd1306_send_byte((B01011110&flameMask[flames] | P1)<<P2);
  ssd1306_send_byte((B10010111&flameMask[flames] | P1)<<P2);
  ssd1306_send_byte((B01010011&flameMask[flames] | P1)<<P2);
  ssd1306_send_byte((B01010011&flameMask[flames] | P1)<<P2);
  ssd1306_send_byte((B10010111&flameMask[flames] | P1)<<P2);
  ssd1306_send_byte((B01011110&flameMask[flames] | P1)<<P2);
  ssd1306_send_byte((B00001100&flameMask[flames] | P1)<<P2);  
  
  if (fireCount > 0) {
    for (byte f = 0; f<=24; f++){
        ssd1306_send_byte(B00000100<<P2);
    }
    ssd1306_send_byte(B00010101<<P2);
    //ssd1306_send_byte(B00001010<<P2);
    ssd1306_send_byte(B00010101<<P2);
    // if (fire == 1) { GAMES_Beep(50,100); }
    fire = 0;
  }   
}


ufo.cpp

#include "wifictrl.h"
#include "games.h"
#include "screen.h"
#include "buttons.h"
#include "logo.h"
#include "common.h"

#if defined(KEYS_CONTROL_WIFI)

#if defined(CAPTIVE_PORTAL_ENABLED)
#include <DNSServer.h>
#endif

#if defined(ESP32)
#include <WiFi.h>
#include <AsyncTCP.h>
#elif defined(ESP8266)
#include <ESP8266WiFi.h>
#include <ESPAsyncTCP.h>
#endif
#include <ESPAsyncWebServer.h>

typedef enum
{
  WEBSOCK_UP_PRESSED = (0),
  WEBSOCK_UP_RELEASED,
  WEBSOCK_DOWN_PRESSED,
  WEBSOCK_DOWN_RELEASED,
  WEBSOCK_LEFT_PRESSED,
  WEBSOCK_LEFT_RELEASED,
  WEBSOCK_RIGHT_PRESSED,
  WEBSOCK_RIGHT_RELEASED,
  WEBSOCK_SEL_PRESSED,
  WEBSOCK_SEL_RELEASED,
  WEBSOCK_UP_CLICKED,
  WEBSOCK_DOWN_CLICKED,
  WEBSOCK_LEFT_CLICKED,
  WEBSOCK_RIGHT_CLICKED,
  WEBSOCK_SEL_CLICKED
} WebSocketButtonType_e;

AsyncWebServer _server(WEBSERVER_PORT);
AsyncWebSocket _ws(WEBSOCKET_PATH);
static bool _portalStarted = false;

#if defined(CAPTIVE_PORTAL_ENABLED)
DNSServer _dnsServer;

class CaptiveRequestHandler : public AsyncWebHandler {
public:
  CaptiveRequestHandler() {}
  virtual ~CaptiveRequestHandler() {}

  bool canHandle(AsyncWebServerRequest *request){
    //request->addInterestingHeader("ANY");
    return true;
  }

  void handleRequest(AsyncWebServerRequest *request) {
    AsyncResponseStream *response = request->beginResponseStream(index_html);
    request->send(response);
    _portalStarted = true;
  }
};
#endif

void handleWebSocketMessage(void *arg, uint8_t *data, size_t len) {
  AwsFrameInfo *info = (AwsFrameInfo*)arg;

  if (info->final && info->index == 0 && info->len == len && info->opcode == WS_BINARY) {
    switch (data[0])
    {
    case WEBSOCK_UP_CLICKED:    BUTTONS_WifiUpdate(BTN_UP, BUTTON_CLICKED);     break;
    case WEBSOCK_DOWN_CLICKED:  BUTTONS_WifiUpdate(BTN_DOWN, BUTTON_CLICKED);   break;
    case WEBSOCK_LEFT_CLICKED:  BUTTONS_WifiUpdate(BTN_LEFT, BUTTON_CLICKED);   break;
    case WEBSOCK_RIGHT_CLICKED: BUTTONS_WifiUpdate(BTN_RIGHT, BUTTON_CLICKED);  break;
    case WEBSOCK_SEL_CLICKED:   BUTTONS_WifiUpdate(BTN_SELECT, BUTTON_CLICKED); break;
    case WEBSOCK_UP_PRESSED:    BUTTONS_WifiUpdate(BTN_UP, BUTTON_PRESSED);     break;
    case WEBSOCK_DOWN_PRESSED:  BUTTONS_WifiUpdate(BTN_DOWN, BUTTON_PRESSED);   break;
    case WEBSOCK_LEFT_PRESSED:  BUTTONS_WifiUpdate(BTN_LEFT, BUTTON_PRESSED);   break;
    case WEBSOCK_RIGHT_PRESSED: BUTTONS_WifiUpdate(BTN_RIGHT, BUTTON_PRESSED);  break;
    case WEBSOCK_SEL_PRESSED:   BUTTONS_WifiUpdate(BTN_SELECT, BUTTON_PRESSED); break;
    case WEBSOCK_UP_RELEASED:   BUTTONS_WifiUpdate(BTN_UP, BUTTON_RELEASED);    break;
    case WEBSOCK_DOWN_RELEASED: BUTTONS_WifiUpdate(BTN_DOWN, BUTTON_RELEASED);  break;
    case WEBSOCK_LEFT_RELEASED: BUTTONS_WifiUpdate(BTN_LEFT, BUTTON_RELEASED);  break;
    case WEBSOCK_RIGHT_RELEASED:BUTTONS_WifiUpdate(BTN_RIGHT, BUTTON_RELEASED); break;
    case WEBSOCK_SEL_RELEASED:  BUTTONS_WifiUpdate(BTN_SELECT, BUTTON_RELEASED);break;
    default: break;
    }
  }
}

void onEvent(AsyncWebSocket *server, AsyncWebSocketClient *client, AwsEventType type,
             void *arg, uint8_t *data, size_t len) {
  switch (type) {
    case WS_EVT_CONNECT:
      _portalStarted = true;
      // Serial.printf("WebSocket client #%u connected from %s\n", client->id(), client->remoteIP().toString().c_str());
      break;
    case WS_EVT_DISCONNECT:
      // Serial.printf("WebSocket client #%u disconnected\n", client->id());
      break;
    case WS_EVT_DATA:
      handleWebSocketMessage(arg, data, len);
      break;
    case WS_EVT_PONG:
    case WS_EVT_ERROR:
      break;
  }
}

bool LocalValidateWifiCredentials(String ssid, String pass)
{
  return (ssid.length() > 4 && (pass.length() >= 8 || pass.length() == 0));
}

void LocalDisplayWifiStatus()
{
  SCREEN_Clear();
  if (WiFi.getMode() == WIFI_STA) {
    if (WiFi.status() == WL_CONNECTED) {
      // Serial.print("WiFi connected! "); Serial.println(WiFi.localIP());
      SCREEN_PrintAt(20, 0, "WiFi Connected");
      SCREEN_PrintAt(25, 40, WiFi.localIP().toString().c_str());
    } else {
      SCREEN_PrintAt(17, 0, "WiFi Disconnected");
    }
  } else {
    SCREEN_PrintAt(15, 0, "WIFI ACCESS POINT");
#if defined(ESP32)
    SCREEN_PrintAt(10, 20, WIFI_AP_SSID);
#elif defined(ESP8266)
    SCREEN_PrintAt(2, 20, WIFI_AP_SSID);
#endif
    SCREEN_PrintAt(30, 40, WiFi.softAPIP().toString().c_str());
  }
  SCREEN_Display();
}

void WIFI_AccessPoint()
{
  WiFi.mode(WIFI_AP);
  WiFi.softAP(WIFI_AP_SSID, WIFI_AP_PASSWORD);
  // ESP_LOGI("", "WiFi Access Point started! SSID: %s - Password: %s\n", WIFI_AP_SSID, WIFI_AP_PASSWORD);
}

void WIFI_Init()
{
  String ssid = DB_GetWifiSSID();
  String pass = DB_GetWifiPass();
  if (LocalValidateWifiCredentials(ssid, pass))
  {
    WiFi.mode(WIFI_STA);
    WiFi.begin(ssid, pass);
    // ESP_LOGI("", "Connecting to: %s - Pass: %s", ssid.c_str(), pass.c_str());

    SCREEN_Clear();
    SCREEN_PrintAt(0, 0, "WiFi connecting to");
    SCREEN_PrintAt(0, 10, ssid.c_str(), DISPLAY_SCREEN);

    unsigned long long lconnecttime = millis();
    while (WiFi.status() != WL_CONNECTED) {
      delay(500);
      if (millis() - lconnecttime > WIFI_CONNECT_TIMEOUT) {
        // ESP_LOGI("", "Cannot connect WiFi in %d (s). Switch to Access Point mode.", (WIFI_CONNECT_TIMEOUT / TIME_SECOND));
        WIFI_AccessPoint();
        break;
      }
    }

    // ESP_LOGI("", "Connected - Local IP address: %s\n", WiFi.localIP().toString().c_str());
  }
  else
  {
    WIFI_AccessPoint();
  }

  /* Display WiFi Status */
  LocalDisplayWifiStatus();

  /* Homepage */
  _server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
    AsyncWebServerResponse *response = request->beginResponse_P(200, "text/html", html_index_gz, sizeof(html_index_gz));
    response->addHeader("Content-Encoding", "gzip");
    request->send(response);
  });

  /* Images */
  _server.on("/btn-group.svg", HTTP_GET, [](AsyncWebServerRequest *request){
    AsyncWebServerResponse *response = request->beginResponse_P(200, "image/svg+xml", btn_group_svg, sizeof(btn_group_svg));
    response->addHeader("Content-Length", String(sizeof(btn_group_svg)));
    request->send(response);
  });
  _server.on("/settings.svg", HTTP_GET, [](AsyncWebServerRequest *request){
    AsyncWebServerResponse *response = request->beginResponse_P(200, "image/svg+xml", settings_svg, sizeof(settings_svg));
    response->addHeader("Content-Length", String(sizeof(settings_svg)));
    request->send(response);
  });

  
  /* Configure */
  _server.on("/get-started", HTTP_POST, [](AsyncWebServerRequest *request) {
    _portalStarted = true;
    request->send(200);
  });
  _server.on("/save-wifi", HTTP_POST, [](AsyncWebServerRequest *request) {
    String msg = "";
    if (request->hasParam("ssid") && request->hasParam("pw")) {
      String ssid = request->getParam("ssid")->value();
      String pw = request->getParam("pw")->value();
      if (LocalValidateWifiCredentials(ssid, pw)) {
        DB_UpdateWifiCredentials(ssid, pw);
        msg = "WiFi Credentials updated successfully!";
      } else { msg = "Invalid WiFi Credentials!"; }
    } else { msg = "Invalid request!"; }
    request->send(200, "text/plain", msg);
  });

  /* DNS Server for Captive Portal */
#if defined(CAPTIVE_PORTAL_ENABLED)
  _dnsServer.start(DNS_SERVER_PORT, "*", WiFi.getMode() == WIFI_AP? WiFi.softAPIP() : WiFi.localIP());
  _server.addHandler(new CaptiveRequestHandler());
#endif

  /* WebSocket */
  _ws.onEvent(onEvent);
  _server.addHandler(&_ws);

  /* Start server */
  _server.begin();

  while ( !_portalStarted )
  {
#if defined(CAPTIVE_PORTAL_ENABLED)
    _dnsServer.processNextRequest();
#endif
    WOKWI_DELAY;
    yield();
  }
}
#endif  //KEYS_CONTROL_WIFI


wifictrl.cpp

#pragma once

#if defined(KEYS_CONTROL_WIFI)
void WIFI_Init();

#endif  //KEYS_CONTROL_WIFI
