diagram.json

#include "binary.h"
#include <HardwareSerial.h>
#include <LiquidCrystal_I2C.h>
#include <Arduino.h>
#include "DisplayEngine.h"

DisplayEngine::DisplayEngine()
  : lcd(0x27, 16, 2) {
  numPoints = 0;
}

void DisplayEngine::init() {
  Serial.begin(9600);
  Serial.println("init");
  lcd.init();       //Im Setup wird der LCD gestartet
  lcd.backlight();  //Hintergrundbeleuchtung einschalten (lcd.noBacklight(); schaltet die Beleuchtung aus).
}

void DisplayEngine::displayPoints() {

  for (int i = 0; i < numPoints; i++) {
    visible[i] = isOnField(xPos[i], yPos[i]);

    xField[i] = getXFieldNum(xPos[i]);
    yField[i] = getYFieldNum(yPos[i]);

    xPosInField[i] = getXInField(xPos[i]);
    yPosInField[i] = getYInField(yPos[i]);
  }

  int fields[] = { -1, -1, -1, -1, -1, -1, -1, -1 };

  bool fieldsOverwritten[32];
  for (int f = 0; f < 32; f++) fieldsOverwritten[f] = false;

  int numDifferentFields = 0;
  // declare different fields
  for (int i = 0; i < numPoints; i++) {
    if (!visible[i]) continue;
    int fieldNum = getFieldNum(xField[i], yField[i]);
    bool newField = true;
    for (int f = 0; f < numDifferentFields && newField; f++)
      if (fieldNum == fields[f]) newField = false;
    if (!newField) continue;

    fields[numDifferentFields] = fieldNum;
    fieldsOverwritten[fieldNum] = true;
    numDifferentFields++;
  }

  for (int x = 0; x < 16; x++) {
    for (int y = 0; y < 2; y++) {
      if (chars[x][y] != '\0') {
        fieldsOverwritten[x + y * 16] = true;
      };
    }
  }


  // lcd.clear();
  for (int f = 0; f < 32; f++) {
    if (!fieldsOverwritten[f]) {
      lcd.setCursor(f % 16, f / 16);
      lcd.write(' ');
    }
  }


  byte customChars[8][8];

  // Initialize all elements to 0
  for (int i = 0; i < 8; i++) {
    for (int j = 0; j < 8; j++) customChars[i][j] = 0;
  }

  // write pixels to chars
  for (int f = 0; f < numDifferentFields; f++) {
    for (int i = 0; i < numPoints; i++) {
      if (!visible[i]) continue;
      int fieldNum = getFieldNum(xField[i], yField[i]);
      if (fieldNum == fields[f]) addToBytes(customChars[f], xPosInField[i], yPosInField[i]);
    }
    if (chars[fields[f] % 16][fields[f] / 16]!='\0') continue;
    lcd.createChar(f, customChars[f]);
    lcd.setCursor(fields[f] % 16, fields[f] / 16);
    lcd.write(byte(f));
  }
  for (int x = 0; x < 16; x++) {
    for (int y = 0; y < 2; y++) {
      if (chars[x][y] != '\0') {
        lcd.setCursor(x, y);
        lcd.write(chars[x][y]);
      };
    }
  }
}

void DisplayEngine::addRect(int x, int y, int width, int height) {
  int numNewPoints = width * height;
  for (int i = 0; i < numNewPoints; i++) {
    xPos[i + numPoints] = i % width + x;
    yPos[i + numPoints] = i / width + y;
  }
  numPoints += numNewPoints;
}

void DisplayEngine::addText(int fieldX, int fieldY, String text) {
  for (int i = 0; i < text.length() && fieldX + i < 16; i++) {
    chars[fieldX + i][fieldY] = text.charAt(i);
  }
}

void DisplayEngine::clearAll() {
  for (int x = 0; x < 16; x++) {
    for (int y = 0; y < 2; y++) {
      chars[x][y] = '\0';
    }
  }
  numPoints = 0;
}

void DisplayEngine::addToBytes(char bytes[], int posX, int posY) {
  bytes[posY] |= 1 << (4 - posX);
}

int DisplayEngine::getXFieldNum(int xPos) {
  return xPos / 6;
}

int DisplayEngine::getYFieldNum(int yPos) {
  return yPos / 9;
}

int DisplayEngine::getXInField(int xPos) {
  return xPos % 6;
}
int DisplayEngine::getYInField(int yPos) {
  return yPos % 9;
}

bool DisplayEngine::isOnField(int xPos, int yPos) {
  bool xVisible = !((xPos + 1) % 6 == 0) && xPos >= 0 && xPos < 16 * 6;
  bool yVisible = !((yPos + 1) % 9 == 0) && yPos >= 0 && yPos < 2 * 9;

  return xVisible && yVisible;
}

int DisplayEngine::getFieldNum(int xField, int yField) {
  return yField * 16 + xField;
}

DisplayEngine.cpp

#include "Arduino.h"
#include "WString.h"
#ifndef DISPLAYENGINE_H
#define DISPLAYENGINE_H
#include <LiquidCrystal_I2C.h>  // von "Frank de Brabander"
class DisplayEngine {
public:
  DisplayEngine();
  int numPoints;
  byte xPos[320];
  byte yPos[320];

  void displayPoints();
  void init();

  void addRect(int x, int y, int width, int height);
  void addText(int fieldX, int fieldY, String text);
  void clearAll();


private:
  LiquidCrystal_I2C lcd;

  char chars[16][2];

  bool visible[320];

  byte xField[320];
  byte yField[320];

  byte xPosInField[320];
  byte yPosInField[320];





  void addToBytes(char bytes[], int posX, int posY);
  int getXFieldNum(int xPos);

  int getYFieldNum(int yPos);

  int getXInField(int xPos);

  int getYInField(int yPos);

  bool isOnField(int xPos, int yPos);

  int getFieldNum(int xField, int yField);
};
#endif


DisplayEngine.h

#include <Arduino.h>
#include "Enemy.h"

Enemy::Enemy() {
  XPosition = 100;
  YPosition = 1;
  Speed = 1;
  PotiSpeed = 1;
  Grenze = -1;
};

void Enemy::Spawn() {
  YPosition = random(0, 1);
  if (XPosition < Grenze) {
    XPosition = 100;
  }
  NewGrenze();
};

void Enemy::ChangeSpeed(){};
void Enemy::SpawnTime(){};

void Enemy::NewGrenze() {
  Grenze = random(-5, -15);
};

Enemy.cpp


class Enemy {
public:
  Enemy();
  //keine X position nutig will die immer von richts starten
  int YPosition;
  int XPosition;
  int Speed;           //wie schnell die gegner bewegt.
  int PotiSpeed;  //geschwiendigkeit anderung
  int Grenze;


  void Spawn();        //zufall generator
  void ChangeSpeed();  //geschwiendigkeit anderung
  void SpawnTime();
  void NewGrenze();
};

Enemy.h

#include "pins_arduino.h"
#include "GameEngine.h"

static Enemy GameEngine::a = Enemy();
static Enemy GameEngine::b = Enemy();
static Enemy GameEngine::c = Enemy();
static Enemy GameEngine::d = Enemy();
static Enemy GameEngine::e = Enemy();



static void GameEngine::bewegen(){

};
static void GameEngine::display(DisplayEngine displayEngine){

};
static void GameEngine::simulate(){

};

GameEngine.cpp

#ifndef GAMEENGINE_H
#define GAMEENGINE_H
#include "Spieler.h"
#include "Enemy.h"
#include "DisplayEngine.h"

class GameEngine {
public:
  static double potiVal;
  static void bewegen();
  static Enemy a;
  static Enemy b;
  static Enemy c;
  static Enemy d;
  static Enemy e;
  static void display(DisplayEngine displayEngine);
  static void simulate();
private:
};
#endif

GameEngine.h

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

# Automatically added based on includes:
LiquidCrystal I2C

libraries.txt

#include <Wire.h>
#include <LiquidCrystal_I2C.h>  // von "Frank de Brabander"
#include "DisplayEngine.h"
#include "GameEngine.h"

unsigned long startTRefresh = millis();
unsigned long startTSim = millis();

int shiftX = 0;
int shiftY = 0;
int xSpeed = 1;
int ySpeed = 0;
double potiVal = 0;

DisplayEngine displayEngine = DisplayEngine();

void setup() {
  displayEngine.init();
}

void loop() {
  potiVal = analogRead(A0) / 1023.0;
  potiVal = (potiVal - 0.5) * 3 + 0.5;
  if (potiVal > 1) potiVal = 1;
  if (potiVal < 0) potiVal = 0;

  // gameengine.potiVal=potiVal;

  // Gameengine
  if (millis() - startTSim > 100) {
    startTSim = millis();
    // gameengine.simulate()
  }

  // Display update
  if (millis() - startTRefresh > 100) {
    startTRefresh = millis();
    Serial.println(potiVal);

    GameEngine::display(displayEngine);

    displayEngine.clearAll();
    displayEngine.addRect(0, int(potiVal * (9 * 2 - 5 - 1)), 5, 5);
    displayEngine.addText(0, 1, "H-A-L-L-O");
    displayEngine.displayPoints();
  }
}


Projekt.ino

#include "Spieler.h"

static int Spieler::XPosition=1;
static int Spieler::YPosition=1;
void Spieler::PlayerPositionAnderung(){
  
}


Spieler.cpp


class Spieler {
public:
  static int YPosition;
  static int XPosition;

  void PlayerPositionAnderung();
};

Spieler.h

Downloaded from https://wokwi.com/projects/357636248800132097

Simulate this project on https://wokwi.com
