#include <FastLED.h>
#include "Global_Setup.h"
#include "Matrix.h"
#include "Buttons.h"
#include "Game.h"
#include "Sprites.h"
#include "Obstacles.h"
#include "Character.h"

// *** Creating objects ***
// Matrix objectName(fps);
Matrix matrix(25);
// Buttons objectName(firstPin, lastPin, readInterval, jumping, ducking);
Buttons buttons(2, 5, 10, false, false);
Obstacles obstacle("Alien", 30);
//Character character();

// *** GameObjects & Projectiles ***
// GameObject objectName(name, spriteArray, width, height, xPos, yPos, collisionLayer, visibility, standalone);
// collisionLayer (0-255)                 -> Higher can collide with lower, equal can't collide
// visibility (optinal, default: false)   -> If true, object is visible and will be displayed
// standalone (optional, default: false)  -> If true, object is not part of render queue and has to be displayed manually
GameObject spaceship("Player", spaceshipSprite, 8, 8, 11, 16, 10, true);
// GameObject cityBackground ("City", citySprite, 64, 14, 0, 10, 10, false);
GameObject enemy("Obstacle", enemySprite, 8, 8, 64, 16, 0, true);
GameObject raumschiff("Raumschiff", raumschiffSprite, 8, 8, 0, 10, 10, true, true);
Projectile *projectiles = (Projectile*) malloc(sizeof(Projectile) * PROJECTILE_COUNT);
GameObject city("City", citySprite, 64, 14, 0, 0, 18, true );
GameObject suburbs("Suburbs", suburbsSprite, 64, 14, 0, 0, 18, true );
GameObject nature("Nature", natureSprite, 64, 14, 0, 0, 18, true );
const byte fireButtonPin = 23;
bool fireButton, fireButtonBefore;

void setup() {
  Serial.begin(115200);
  randomSeed(analogRead(A0));
  pinMode(fireButtonPin, INPUT_PULLUP);

  matrix.init();
  buttons.init();
  
  // Add objects to render queue with matrix.add(&object)
  // Remove objects from render queue with matrix.remove(&object)
  /*for (int i = 0; i < PROJECTILE_COUNT; i++) {
    projectiles[i] = Projectile("Projectile #" + String(i), projectileSprite, 4, 1, 0, 0, 10);
    matrix.add(&projectiles[i]);
  }
  */
  matrix.add(&city);
  matrix.add(&suburbs);
  matrix.add(&nature);
  matrix.add(&spaceship);
  matrix.add(&enemy);
  matrix.printRenderQueue();

  obstacle.setTimestamp(millis());
  obstacle.setCount(1);

  // Manually draw object
  //matrix.drawObject(&raumschiff);
  // Manually erase object
  //matrix.eraseObject(&raumschiff);
  // Apply leds array to matrix
  //matrix.show();
}

void loop() {
  /*while (!choseChar) {
    matrix.drawObject();
    matrix.drawObject();
    
  }*/
  // Global system tick
  systemtime = millis();

  matrix.checkCollision(&spaceship);

  // Buttons
  buttons.update();
  buttons.moveObject(&spaceship);
 
 // Obstacles
  obstacle.moveObstacle(&enemy);
  obstacle.respawn(&enemy);
  

  // Fire logic (just an example)
  /*fireButton = !digitalRead(fireButtonPin);
  if (fireButton && fireButton != fireButtonBefore) {
    static byte projectileNo = 0;
    static bool wing;
    projectiles[projectileNo].setX(spaceship.getX() + 7);
    projectiles[projectileNo].setY(wing ? spaceship.getY() : spaceship.getY() + 7);
    projectiles[projectileNo].setVisible(true);
    wing = !wing;
    projectileNo++;
    projectileNo %= PROJECTILE_COUNT;    
  }
  fireButtonBefore = fireButton;
  */


  // Update projectiles
  for (int i = 0; i < PROJECTILE_COUNT; i++) {
    projectiles[i].update(30);
  }

  // Global timed rendering with render queue
  matrix.update();

}

TINF_Game_Engine.ino

diagram.json

#ifndef GLOBAL_H
#define GLOBAL_H

#define DEBUG
//#define DEBUG_DETAIL

typedef unsigned long time_t;
time_t systemtime = 0;

enum Direction {
  UP = 1 << 0,
  LEFT = 1 << 1,
  DOWN = 1 << 2,
  RIGHT = 1 << 3
};

#define PROJECTILE_COUNT 3
#define RENDER_QUEUE_COUNT (PROJECTILE_COUNT + 5)

// Matrix Setup
#define MATRIX_WIDTH    64
#define MATRIX_HEIGHT   32
#define NUM_PANELS      8
#define NUM_LEDS        (MATRIX_WIDTH * MATRIX_HEIGHT)
#define STRIP_LEDS      (NUM_LEDS / NUM_PANELS)
#define LED1_PIN        6
#define LED2_PIN        7
#define LED3_PIN        8
#define LED4_PIN        9
#define LED5_PIN        10
#define LED6_PIN        11
#define LED7_PIN        12
#define LED8_PIN        13
#define COLOR_ORDER     GRB
#define CHIPSET         WS2811
#define BRIGHTNESS      200

// Mechanics Setup 
#define JUMPDELAY       1000  
#define DUCKDELAY       1000

#endif

Global_Setup.h

Sprites.h

#ifndef BUTTONS_H
#define BUTTONS_H

#include "Global_Setup.h"
#include "Game.h"

class Buttons {
  private:
    byte _firstPin;
    byte _lastPin;
    byte _readInterval;
    byte _buttons = 0;
    byte _buttonsHistory;
    bool _jumping;
    bool _ducking;
    time_t _timestamp;

  public:
    Buttons(byte firstPin, byte lastPin, byte readInterval, bool jumping, bool ducking) {
      setFirstPin(firstPin);
      setLastPin(lastPin);
      setReadInterval(readInterval);
      setJumping(jumping);
      setDucking(ducking);
    }

    void setFirstPin(byte firstPin) {
      _firstPin = firstPin;
    }
    void setLastPin(byte lastPin) {
      _lastPin = lastPin;
    }
    void setReadInterval(byte readInterval) {
      _readInterval = readInterval;
    }
    void setTimestamp(time_t timestamp) {
      _timestamp = timestamp;
    }
    void setJumping (bool jumping) {
      _jumping = jumping;
    }
    void setDucking (bool ducking) {
      _ducking = ducking;
    }


    byte getFirstPin() {
      return _firstPin;
    }
    byte getLastPin() {
      return _lastPin;
    }
    byte getReadInterval() {
      return _readInterval;
    }
    time_t getTimestamp() {
      return _timestamp;
    }
    bool getJumping() {
      return _jumping;
    }
    bool getDucking() {
      return _ducking;
    }

    // Main methods
    void init() {
      for (byte i = getFirstPin(); i <= getLastPin(); i++) {
        pinMode(i, INPUT_PULLUP);
      }
    }

    void update() {
      uint8_t bitSet = 1;
      _buttons = 0;
      for (int i = 0; i < 4; i++) {
        if (!digitalRead(i + 2)) {
          _buttons |= bitSet;
        }
        bitSet <<= 1;
      }
    }

    int pressedOnce() {
      if (_buttons != _buttonsHistory) {
        _buttonsHistory = _buttons;
        return _buttons;
      }
      return 0;
    }

    int pressed() {
      if (systemtime - getTimestamp() >= getReadInterval()) {
        setTimestamp(systemtime);
        return _buttons;
      }
      return 0;
    }

    void print() {
      Serial.println(_buttons, BIN);
    }

    void moveObject(GameObject *object) {
      //byte buttonPressed = pressed();
      byte buttonPressed = pressedOnce();
      if (buttonPressed & UP && !getJumping() && !getDucking()) {
        setJumping(true);
        setTimestamp(systemtime);
        object->setY(object->getY() - 12);
      }
      if (getJumping()) {
        if (systemtime - getTimestamp() >= JUMPDELAY) {
          object->setY(object->getY() + 12);
          setJumping(false);
        }
      }
      if (buttonPressed & DOWN && !getJumping() && !getDucking()) {
        setDucking(true);
        setTimestamp(systemtime);
        object->setY(object->getY() + 5);
      }
      if (getDucking()) {
        if (systemtime - getTimestamp() >= DUCKDELAY) {
          object->setY(object->getY() - 5);
          setDucking(false);
        }
      }
    }
};

#endif

Buttons.h

#ifndef MATRIX_H
#define MATRIX_H

#include <FastLED.h>

#include "Global_Setup.h"
#include "Game.h"

CRGB leds[NUM_LEDS];
uint8_t dirtyPanels = -1;

class Matrix {
  private:
    byte _fps;
    time_t _timestamp;
    GameObject *_renderQueue[RENDER_QUEUE_COUNT];

  public:
    Matrix(byte fps) {
      setFps(1000 / fps);
    }

    // Setter
    void setFps(byte fps) {
      _fps = fps;
    }
    void setTimestamp(time_t timestamp) {
      _timestamp = timestamp;
    }

    // Getter
    byte getFps() {
      return _fps;
    }
    time_t getTimestamp() {
      return _timestamp;
    }

    // Main methods
    void init() {
      FastLED.addLeds<CHIPSET, LED1_PIN, COLOR_ORDER>(leds + 0 * STRIP_LEDS, STRIP_LEDS);
      FastLED.addLeds<CHIPSET, LED2_PIN, COLOR_ORDER>(leds + 1 * STRIP_LEDS, STRIP_LEDS);
      FastLED.addLeds<CHIPSET, LED3_PIN, COLOR_ORDER>(leds + 2 * STRIP_LEDS, STRIP_LEDS);
      FastLED.addLeds<CHIPSET, LED4_PIN, COLOR_ORDER>(leds + 3 * STRIP_LEDS, STRIP_LEDS);
      FastLED.addLeds<CHIPSET, LED5_PIN, COLOR_ORDER>(leds + 4 * STRIP_LEDS, STRIP_LEDS);
      FastLED.addLeds<CHIPSET, LED6_PIN, COLOR_ORDER>(leds + 5 * STRIP_LEDS, STRIP_LEDS);
      FastLED.addLeds<CHIPSET, LED7_PIN, COLOR_ORDER>(leds + 6 * STRIP_LEDS, STRIP_LEDS);
      FastLED.addLeds<CHIPSET, LED8_PIN, COLOR_ORDER>(leds + 7 * STRIP_LEDS, STRIP_LEDS);
      FastLED.setCorrection(UncorrectedColor);
      FastLED.setTemperature(UncorrectedTemperature);
      FastLED.setDither(DISABLE_DITHER);
      FastLED.setBrightness(BRIGHTNESS);
    }

    void add(GameObject *object) {
      static byte count = 0;
      bool added = false;

      if (!object->getAdded()) {
        for (int i = 0; i < RENDER_QUEUE_COUNT; i++) {
          if (_renderQueue[i] == nullptr) {
            _renderQueue[i] = object;
            object->setAdded(true);
#ifdef DEBUG
            Serial.println("[✓] " + object->getName() + " has been added to render queue");
#endif
            added = true;
            break;
          }
        }
      }
      if (!added) {
#ifdef DEBUG
        Serial.println("[!] Render queue full, unable to add object \"" + object->getName() + "\"");
#endif
      }
    }

    void remove(GameObject *object) {
      for (int i = 0; i < RENDER_QUEUE_COUNT; i++) {
        if (_renderQueue[i] == object) {
          _renderQueue[i] = nullptr;
          object->setAdded(false);
          Serial.println("[-] " + object->getName() + " has been removed from render queue.");
          break;
        }
      }
    }

    void printRenderQueue() {
      Serial.println("\n*** Render Queue ***");
      for (int i = 0; i < RENDER_QUEUE_COUNT; i++) {
        Serial.print("Obj #" + String(i) + ": ");
        Serial.println(_renderQueue[i] != nullptr ? _renderQueue[i]->getName() : "<empty>");
      }
      Serial.println("");
    }

    int16_t xy(int16_t x, int16_t y) {
      if (x >= 0 && x < MATRIX_WIDTH && y >= 0 && y < MATRIX_HEIGHT) {
        return x + (y * MATRIX_WIDTH);
      } else {
        return -1;
      }
    }

    // Multiple matrices with selective rendering by sutaburosu
    void markXYDirty(int16_t minX, byte width, int16_t minY, byte height) {
      int16_t maxX = minX + width - 1;
      int16_t maxY = minY + height - 1;
      if (minX >= MATRIX_WIDTH || maxX < 0) return;
      if (minY >= MATRIX_HEIGHT || maxY < 0) return;
      if (minY < 0) minY = 0;
      if (maxY >= MATRIX_HEIGHT) maxY = MATRIX_HEIGHT - 1;
      int8_t minPanel = minY / (MATRIX_HEIGHT / NUM_PANELS);
      int8_t maxPanel = maxY / (MATRIX_HEIGHT / NUM_PANELS);
      uint8_t bitSet = 1 << minPanel;
      for (uint8_t panel = minPanel; panel <= maxPanel; panel++) {
        dirtyPanels |= bitSet;
        bitSet <<= 1;
      }
    }

    void drawGraphics(uint32_t *graphicsArray, byte width, byte height, int16_t xCoord, int16_t yCoord, bool erase) {
      for (int h = 0; h < height; h++) {
        for (int w = 0; w < width; w++) {
          int16_t xyPos = xy(xCoord + w, yCoord + h);
          if (xyPos >= 0 && xyPos < NUM_LEDS && *graphicsArray != 0) {
            if (erase) leds[xyPos] = 0;
            else leds[xyPos] = *graphicsArray;
          }
          graphicsArray++;
        }
      }
      markXYDirty(xCoord, width, yCoord, height);
    }

    void drawObject(GameObject *object) {
      drawGraphics(object->getGfxArray(), object->getWidth(), object->getHeight(), object->getX(), object->getY(), false);
    }

    void eraseObject(GameObject *object) {
      drawGraphics(object->getGfxArray(), object->getWidth(), object->getHeight(), object->getXOld(), object->getYOld(), true);
    }

    // Multiple matrices with selective rendering by sutaburosu
    void show() {
      static uint8_t previousDirty = 0;
      uint8_t totalDirty = previousDirty | dirtyPanels;
      previousDirty = dirtyPanels;
      dirtyPanels = 0;

      uint8_t panel = 0;
      while (totalDirty && panel < NUM_PANELS) {
        if (totalDirty & 1) FastLED[panel].showLeds(BRIGHTNESS);
        totalDirty >>= 1;
        panel++;
      }
    }

    void clear() {
      FastLED.clear();
    }

    void checkCollision(GameObject *col) {
      for (int i = 0; i < RENDER_QUEUE_COUNT; i++) {
        GameObject *obj = _renderQueue[i];
        if (col->getCollisionLayer() > obj->getCollisionLayer() && obj != col && obj != nullptr && obj->getVisible()) {
#ifdef DEBUG_DETAIL
          Serial.println("[?] Checking if " + col->getName() + " collides with " + obj->getName() + "...");
#endif
          byte colX = col->getX();
          byte colY = col->getY();
          byte colW = col->getWidth();
          byte colH = col->getHeight();
          byte objX = obj->getX();
          byte objY = obj->getY();
          byte objW = obj->getWidth();
          byte objH = obj->getHeight();

          if (colX < objX + objW &&
              colX + colW > objX &&
              colY < objY + objH &&
              colH + colY > objY) {
            eraseObject(obj);
            obj->setVisible(false);
#ifdef DEBUG
            Serial.println("[!] " + col->getName() + " has been hit by " + obj->getName() + ".");
#endif
          }
        }
      }
    }

    void update() {
      if (systemtime - getTimestamp() >= getFps()) {
        setTimestamp(systemtime);

        for (int i = 0; i < RENDER_QUEUE_COUNT; i++) {
          GameObject *obj = _renderQueue[i];
          if (obj != nullptr && obj->getVisible()) {
            if (obj->getX() != obj->getXOld() ||
                obj->getY() != obj->getYOld()) {
              checkCollision(obj);
              eraseObject(obj);
              drawObject(obj);
              obj->setXOld(obj->getX());
              obj->setYOld(obj->getY());
            }
          }
        }
        show();
      }
    }
};

#endif

Matrix.h

#ifndef GAME_H
#define GAME_H

#include "Global_Setup.h"

class GameObject {
  protected:
    String _name;
    byte _width, _height;
    int16_t _x, _y, _xOld, _yOld;
    uint32_t *_gfxArray;
    byte _collisionLayer;
    bool _added = false;
    bool _visible = false;

  public:
    GameObject(String name, uint32_t *gfxArray, byte width, byte height, int16_t x, int16_t y, byte collisionLayer, bool visible = false, bool standalone = false) {
      setName(name);
      setGfxArray(gfxArray);
      setWidth(width);
      setHeight(height);
      setX(x);
      setY(y);
      setCollisionLayer(collisionLayer);
      setVisible(visible);
      if (standalone) {
        setXOld(x);
        setYOld(y);
      } else {
        setXOld(-1);
        setYOld(-1);
      }
    }

    void setName(String name) {
      _name = name;
    }
    void setGfxArray(uint32_t *gfxArray) {
      _gfxArray = gfxArray;
    }
    void setWidth(byte width) {
      _width = width;
    }
    void setHeight(byte height) {
      _height = height;
    }
    void setX(int16_t x) {
      _x = x;
    }
    void setY(int16_t y) {
      _y = y;
    }
    void setXOld(int16_t xOld) {
      _xOld = xOld;
    }
    void setYOld(int16_t yOld) {
      _yOld = yOld;
    }
    void setCollisionLayer(byte collisionLayer) {
      _collisionLayer = collisionLayer;
    }
    void setAdded(bool added) {
      _added = added;
    }
    void setVisible(bool visible) {
      _visible = visible;
    }

    String getName() {
      return _name;
    }
    uint32_t* getGfxArray() {
      return _gfxArray;
    }
    byte getWidth() {
      return _width;
    }
    byte getHeight() {
      return _height;
    }
    int16_t getX() {
      return _x;
    }
    int16_t getY() {
      return _y;
    }
    int16_t getXOld() {
      return _xOld;
    }
    int16_t getYOld() {
      return _yOld;
    }
    byte getCollisionLayer() {
      return _collisionLayer;
    }
    bool getAdded() {
      return _added;
    }
    bool getVisible() {
      return _visible;
    }
};

class Projectile : public GameObject {
    using GameObject::GameObject;

  private:
    time_t _timestamp;

  public:
    void setTimestamp(time_t timestamp) {
      _timestamp = timestamp;
    }

    time_t getTimestamp() {
      return _timestamp;
    }

    void update(byte interval) {
      if (getVisible()) {
        if (systemtime - getTimestamp() >= interval) {
          if (getX() > MATRIX_WIDTH) setVisible(false);
          setTimestamp(systemtime);
          setX(getX() + 1);
        }
      }
    }
};

#endif

Game.h

#ifndef OBSTACLES_H
#define OBSTACLES_H

#include "Global_Setup.h"
#include "Game.h"

class Obstacles {
  private:
    String _name;
    int _speed;
    time_t _timestamp;
    int _count;


  public:

    Obstacles(String name, int speed) {
      setName(name);
      setSpeed(speed);
    }

    void setName(String name) {
      _name = name;
    }
    void setSpeed(int speed) {
      _speed = speed;
    }
    void setTimestamp(time_t timestamp) {
      _timestamp = timestamp;
    }
    void setCount(int count) {
      _count = count;
    }

    String getName() {
      return _name;
    }
    int getSpeed() {
      return _speed;
    }
    time_t getTimestamp() {
      return _timestamp;
    }
    int getCount() {
      return _count;
    }


    void moveObstacle (GameObject *object) {
      if (systemtime - getTimestamp() >= getSpeed()) {
        object->setX(object->getX() - 1);
        setTimestamp(systemtime);
      }
    }

    void respawn (GameObject *object) {
      if (object->getX() <= -object->getWidth()) {
        object->setX(64);
        object->setY(random(10, 25));
        Serial.println(object->getY());
        setCount(getCount() + 1);
        if (getCount() % 5 == 0) {
          setSpeed (getSpeed() - 5);
        }
      }
    }
};


#endif

Obstacles.h

#ifndef CHARACTER_H
#define CHARACTER_H
/*
bool choseChar = false;

class Character {
  private:
    String _name;
    uint32_t _playerModel;

	public:

	void setName(String name) {
		_name = name;
	}
	void setPlayerModel(uint32_t playerModel) {
		_playerModel = playerModel;
	}

	void getName() {
		return _name;
	}
	void getPlayerModel() {
		return _playerModel;
	}



  void setChar(byte choice) {
    if (choice == 1) {
    setName("character A");
    setPlayerModel(model A);
    }
    if (choice == 2) {
    setName("character B");
    setPlayerModel(model B);  
    }
  }


};*/
#endif

Character.h

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

# Automatically added based on includes:
FastLED
# ---
