#include <FastLED.h>
#include "Global_Setup.h"
#include "Matrix.h"
#include "DButtons.h"     // Umbenannt Buttons(orig.) -> DButtons.h
#include "Game.h"
#include "Sprites.h"
//------------------------//
#include "Winehandler.h"  // Verwaltet das gesamte Spiel
//#include "Shelf.h"        // Objekt für ein (Wein-)Fach (vgl. Zelle)
#include "Joystick.h"     // Bündelt Analoge Joysticks in jeweils einem Objekt
#include "Buttons.h"      // Bündelt Knöpfe in einem Objekt. Modifizierte Version von DButtons.h

// *** Creating objects ***
// Matrix objectName(fps);
Matrix matrix(25);
// Buttons objectName(firstPin, lastPin, readInterval);
Buttons buttons(4, 5, READ_INTERVAL);


// *** 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 crosshair("Crosshair", crosshairSprite, 3, 3, 0, 0, 100, true, false);
GameObject redPixel("Pixel", redPixelSprite, 1, 1, 15, 15, 111, true, false);

Winehandler Winesweeper;

Joystick joy(VERT_PIN, HORZ_PIN, SEL_PIN, READ_INTERVAL);

void setup() {
  Serial.begin(115200);
  randomSeed(analogRead(A10));



  matrix.init();
  buttons.init();
  joy.init();
  Winesweeper.init();

  // Add objects to render queue with matrix.add(&object)
  // Remove objects from render queue with matrix.remove(&object)

  //matrix.add(&crosshair);
  matrix.add(&redPixel);
  matrix.printRenderQueue();

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

  // Initialize Joystick Library



  /*
    for(int i = 0; i <= MATRIX_WIDTH-1; i++) {
      for(int j = 0; j <= MATRIX_HEIGHT-1; j++) {
        bool value = Winesweeper.getParcel(i, j)->isWine();
        Serial.println("i: " + String(i) + " j: " + String(j) + " Wert: " + String(value));
      }
    }
  */
}


void loop() {
  // Global system tick
  systemtime = millis();


  //bool selPressed = digitalRead(SEL_PIN) == LOW;

  // selPressed is true if the joystick is pressed


  joy.update();
  joy.moveObject(&redPixel);


  buttons.update();


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

Winesweeper.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    32
#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

// Analog Joystick
#define VERT_PIN A0
#define HORZ_PIN A1
#define SEL_PIN  2

#define READ_INTERVAL 100

#endif

Global_Setup.h

#ifndef SPRITES_H
#define SPRITES_H

const uint32_t crosshairSprite[9] = {
	0x00ffffff, 0x00000100, 0x00fffffe, 
	0x00010000, 0x00ffffff, 0x00000001, 
	0x00feffff, 0x00000100, 0x00ffffff
};

const uint32_t redPixelSprite[1] = {
	0x00ff0000
};

const uint32_t greenPixelSprite[1] = {
	0x0000ff00
};

const uint32_t bluePixelSprite[1] = {
	0x000000ff
};

const uint32_t purplePixelSprite[1] = {
	0x009600E6
};

const uint32_t blackPixelSprite[1] = {
	0x00000000
};

#endif

Sprites.h

#ifndef DBUTTONS_H
#define DBUTTONS_H

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

class DButtons {
  private:
    byte _firstPin;
    byte _lastPin;
    byte _readInterval;
    byte _buttons = 0;
    byte _buttonsHistory;
    time_t _timestamp;

  public:
  DButtons(byte firstPin, byte lastPin, byte readInterval) {
    setFirstPin(firstPin);
    setLastPin(lastPin);
    setReadInterval(readInterval);
  }
  
  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;
  }

  byte getFirstPin() { return _firstPin; }
  byte getLastPin() { return _lastPin; }
  byte getReadInterval() { return _readInterval; }
  time_t getTimestamp() { return _timestamp; }

  // 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++) { // i < getLastPin - getFirstPin +1
      if (!digitalRead(i + 2)) {  // i + getFirstPin
        _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)    object->setY(object->getY() - 1);
    if (buttonPressed & LEFT)  object->setX(object->getX() - 1);
    if (buttonPressed & DOWN)  object->setY(object->getY() + 1); // auskommentieren für 2 Button
    if (buttonPressed & RIGHT) object->setX(object->getX() + 1); // auskommentieren für 2 Button
  }
};

#endif

DButtons.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("[!] " + obj->getName() + " has been hit by " + col->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

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

# Automatically added based on includes:
FastLED


libraries.txt

#ifndef JOYSTICK_H
#define JOYSTICK_H

#include "Global_Setup.h"

class Joystick {
  protected:
    int _xMap, _yMap, _xValue, _yValue;
    byte _verticalPin, _horizontalPin, _selectPin, _readInterval;
    bool _isPressed, _isPressedHistory;
    time_t _timestamp;

  public:
    Joystick(byte vertPin, byte horzPin, byte selPin, byte readInterval) {
      setVerticalPin(vertPin);
      setHorizontalPin(horzPin);
      setSelectPin(selPin);
      setReadInterval(readInterval);
    }

    //Setter
    void setXmap() {
      _xMap = map(getXvalue(), 0, 1023, 1, -1);
    }

    void setYmap() {
      _yMap = map(getYvalue(), 0, 1023, 1, -1);
    }

    void setXvalue(int value) {
      _xValue = analogRead(value);
    }

    void setYvalue(int value) {
      _yValue = analogRead(value);
    }

    void setVerticalPin(byte Pin) {
      _verticalPin = Pin;
    }

    void setHorizontalPin(byte Pin) {
      _horizontalPin = Pin;
    }

    void setSelectPin(byte Pin) {
      _selectPin = Pin;
    }

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

    void setIsPressed(bool state) {
      _isPressed = state;
    }

    void setIsPressedOnce(bool state) {
      _isPressed = state;
    }

    void setReadInterval(byte interval) {
      _readInterval = interval;
    }

    void setIsPressedHistory(bool state) {
      _isPressedHistory = state;
    }

    // Getter
    int getXmap() {
      return _xMap;
    }

    int getYmap() {
      return _yMap;
    }

    int getXvalue() {
      return _xValue;
    }

    int getYvalue() {
      return _yValue;
    }

    byte getVerticalPin() {
      return _verticalPin;
    }

    byte getHorizontalPin() {
      return _horizontalPin;
    }

    byte getSelectPin() {
      return _selectPin;
    }

    time_t getTimestamp() {
      return _timestamp;
    }

    bool isPressed() {
      if (systemtime - getTimestamp() >= getReadInterval()) {
        setTimestamp(systemtime);
        return _isPressed;
      }
      return 0;
    }

    bool isPressedOnce() {
      if (_isPressed != _isPressedHistory) {
        _isPressedHistory = _isPressed;
        return _isPressed;
      }
      return 0;
    }

    byte getReadInterval() {
      return _readInterval;
    }

    void getIsPressedHistory() {
      return _isPressedHistory;
    }

    // Main methods
    void init() {
      pinMode(getSelectPin(), INPUT_PULLUP);
    }

    void update() {
      setXvalue(getHorizontalPin());
      setYvalue(getVerticalPin());
      setXmap();
      setYmap();

      uint8_t bitSet = 1;
      _isPressed = 0;
        if (!digitalRead(getSelectPin())) {
          _isPressed |= bitSet;
        }
    }

    void moveObject(GameObject *object) {
      if ((getXmap() > 0 || getXmap() < 0) && systemtime - getTimestamp() >= getReadInterval()) {
        setTimestamp(systemtime);
        object->setX(object->getX() + getXmap());
      }
      if ((getYmap() > 0 || getYmap() < 0) && systemtime - getTimestamp() >= getReadInterval()) {
        setTimestamp(systemtime);
        object->setY(object->getY() + getYmap());
      }
    }
};

#endif

Joystick.h

#ifndef GAMEHANDLER_H
#define GAMEHANDLER_H

#include "Global_Setup.h"
#include "Sprites.h"

class Winehandler {
  protected:
    GameObject *_parcel[MATRIX_WIDTH][MATRIX_HEIGHT];

    void makeParcel(int cols, int rows) {
      for (int i = 0; i <= cols - 1; i++) {
        for (int j = 0; j <= rows - 1; j++) {
          _parcel[i][j] = new GameObject("Cell #" + String(i * j + j), blackPixelSprite, 1, 1, i, j, 100, false, false);
        }
      }
    }

  public:
    Winehandler() {
    }

    //Setter

    // Getter
    GameObject *getParcel(int i, int j) {
      return _parcel[i][j];
    }

    // Main methods
    void init() {
      makeParcel(MATRIX_WIDTH, MATRIX_HEIGHT);
      for (int i = 0; i <= MATRIX_WIDTH - 1; i++) {
        for (int j = 0; j <= MATRIX_HEIGHT - 1; j++) {

          }
      }
    }
}

};

#endif

Winehandler.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;
    time_t _timestamp;

  public:
    Buttons(byte firstPin, byte lastPin, byte readInterval) {
      setFirstPin(firstPin);
      setLastPin(lastPin);
      setReadInterval(readInterval);
    }

    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;
    }

    byte getFirstPin() {
      return _firstPin;
    }
    byte getLastPin() {
      return _lastPin;
    }
    byte getReadInterval() {
      return _readInterval;
    }
    time_t getTimestamp() {
      return _timestamp;
    }

    // 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 < getLastPin() - getFirstPin() + 1; i++) {
        if (!digitalRead(i + getFirstPin())) {
          _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);
    }

    bool read(byte button) {
      if (bitRead(pressedOnce(), button)) { // pressed() oder pressedOnce()
        return true;
      } else {
        return false;
      }
    }
};

#endif