Wir haben nun das Zeitalter der KI erreicht, weshalb hier weniger Lösungen und mehr das Technik Tagebuch Posts kommen.
Lösungen verlinke ich Kategorisch extra auf den weiteren Seiten des Blogs
Ich bin total aus den Socken, nachdem ich einen neuen Branch angelegt habe, damit die KI Claude, mein Projekt überarbeitet, um zum Beispiel mein Problem mit der Bildwiederholrate und dem Fehlenden Grafiken zu behen.
Verbessert? Auf jedenfall!
Nicht nur die Performance hat sich verbessert, Claude hat sogar die Grafiken von Blocken in richtige Sprites umgesetzt. Was vorher nur ein Schemenhaft war, hat jetzt Struktur bekommen.
Zudem hat Claude aus meinem Programmcode verstanden, dass bereits eine Implementierung für einen Kartenwechsel enthalten sind und der Wechsel durch Trigger Information abgerufen werden kann. Und in meinen Code Notizen stand bereits, dass ich vorhatte, dass die Spielfigur eine Kamera besorgen soll, um in der Umgebung Fotos zu knipsen.
Vorher und nachher
Aus den langweiligen Klötzchen Grafik wurde...
.. ein richtigen Pixelart Spiel.
Zur Umsetzung
Das ganz brauchte einen Prompt und ca. 20 Minuten Codebearbeitung durch Claude und dem KI Modell Opus 5.5, das zu dem Zeitpunkt das aktuellest ist.
Das Projekt kann vollständig über den Arduino Compiler und den Arduino ESPLORA Bibliotheken kompiliert werden. Der Arbeitspeicher wird für das Spiel bis an die Grenzen ausgereizt. Deshalb kann nicht mehr Inhalt implementiert werden, aber das reicht auch bereits für mich. Allein das Render der Sprites, ohne das die Figur Flimmert, hebt meine begeisterung und werde einiges neues lernen zur Steuerung des TFT Bildschirms, sobald ich Zeit habe den Code zu lesen.
In den Master Branch habe ich das Projekt noch nicht gemerge, da ich die Inhalte des Programmcode noch durchlesen muss und bei Bedarf noch Nach Kommentiere.
Irgendwann ist die Schmerzgrenze angekommen, dass der Code wie dieser im Bild geschrieben wurde und einige Schwierigkeiten beim Lesen bereiten. Fehlende Vorzeichen sowie Groß- und Kleinschreibung von Funktionsvariablen erschweren die Übersicht.
Neue Fassade
Der Programmcode den ich für diesen Teil zur Verfügung stelle, funktioniert wie bereits aus 'Von Händlern, Kisten und Münzen (Arduino Esplora, Part8)'. Der wesentliche Unterschied ist, dass der Code zurecht gerückt, größten Teils kommentiert und zusätzliche Trennlinien hinzugekommen sind. Natürlich werden in Zukunft auch alle anderen Beispiele nach diesem Codestyle geschrieben. Durch die Festlegung verschiedener Regeln beim Codeformat, sollte die Lesbarkeit deutlich verbessern.
Im Internet suchte ich einige Codebeispiele und las sie bezüglich dessen Aufbau und Formatierung. Zwar gibt es zu dem Thema bereits einige Codestyles, aber die Anforderung sollte ein Kompromiss für Hobby Entwickler sein.
Folgende Codeformat Vorgaben haben sich bei der Suche und Vergleich als Sinnvoll ergeben.
Beschreibung
Wie der Code aussehen könnte
1
If-Else Abfragen.
Auch wenn man sie in einer Zeile schreiben kann, ist die Form schlecht zu lesen. Auch wenn nur eine Sache behandelt wird.
if(stateValue > 0) {
doAnything(stateValue);
}
2
Kommentare zu einer Zeile
Nach einigen Vergleichen von Kommentierten Programmcode, empfand ich die rechts neben dem Code stehenden Kommentare als angenehm. Eine Prämisse hat diese Form jedoch. Da keine Auto Funktion vorhanden ist, dass die Kommentare in gleicher Höhe einrückt ist der Vorgang mit etwas Fleiß verbunden.
int16_t stateValue = 0; // local variable for todo anything
3
Kommentare über einer Funktionsmethode
Scrollt man durch den Code, dann helfen Trennlinien zwischen den Methoden. Wie lang die Trennlinie selbst sein soll, kann soweit bestimmt werden, wie sie für die Sichtbarkeit benötigt wird.
// ============================================
void loop() {
mCounter++;
}
4
Zusammenhängende Funktionsvariablen
Zusammengenutzte Variablen sollten auch möglich nahe zusammenliegen und auch ggf. eine Beschreibung haben.
// ============================================
// function variables
int16_t mCounter = 0; // it is only a counter
5
Wertetypen
Ist sicherlich mühseliger zu schreiben, aber gewährleistet das auch mit anderen Compiler dasselbe Ergebnis kommt. Das kann beim Verwenden eines 16Bit oder 32Bit Microcontrollers vorkommen, das beim kompilieren die Wertetypen anders übersetzt. Z.B. würde statt eines 'int16' ein 'int32' eingesetzt. Bei Berechnungen mit größeren Werten kann es da schon zu Rechenfehler kommen.
int8_t value8 = 123;
int16_t value16 = 123;
int32_t value32 = 123;
uint8_t valueU8 = 123;
uint16_t valueU16 = 123;
uint32_t valueU32 = 123;
6
Funktionsvariablen
Obwohl man möglichst versucht keine Globalen Variablen zu verwenden, bleibt es nicht aus. Bisher waren die von der Schreibweise von lokalen und globalen nicht zu unterscheiden.
Ein 'm' davor und der Variablenname groß geschrieben und schon lassen sich funktionsvariablen leichter zuordnen.
int8_t mMyFunctionVariable = 123;
void FunctionAndLocalVariable() {
int8_t myLocalVariable = 123;
}
7
#define
Um diesen Wert wiederum von den Funktionsvariablen zu unterscheiden, werden diese vollständig groß geschrieben. Bei mehreren Wörter, sollte ein Unterstrich geschrieben werden.
#define MY_DEFINE_VALUE 123
Ordnung ist das halbe Leben
Im Wesentlichen sollten man sich bewusst machen, dass der Programmcode ab einer gewissen Größe immer einer Ordnung folgen sollte. Das Projekt mit dem Arduino Esplora ist noch relativ klein und leicht zu Händeln, da bietet sich die Änderungen der Code Darstellung gut an und hilft auch bei der Selbstreflektion des eigenen geschriebenen Codes. Abgesehen haben wir heute größere Bildschirme und mehr als Ausreichend Festplattenspeicher, so dass kompaktes zusammenrücken und einsparen von Zeichen nicht mehr Zeitgemäß ist.
Der Inhalt zu den Beispiel kann sich mit der Zeit Ändern bzw. erfolgen weitere Codeformat Beispiele.
Ok, so richtiger Handel wird hier nicht stattfinden. Dafür reicht der Speicher nicht. Oder? In erster Linie sollen nur Grund Funktionen Umgesetzt werden. Ziel wird sein, wenn die Figur vor dem Händler oder einer Kiste steht, dann sollte sich der Inhalt Zeigen. Anschließend kann ein Objekt Ausgewählt und in die eigene Tasche übertragen werden. Leider passt das nicht alles in einen Blogpost, so dass der Inhalt mit der Waren Anzeige in einem späteren Post kommt.
Anforderung
Beim Händler können Gegenstände erworben werden und diese in Kisten abgelegt werden. Das erfordert einige mehr Programmcodezeilen und daher muss an der Stelle wieder eine neue Seite mit dem Namen 'TraderComponent' angelegt werden.
Am Anfang werden die Werte für Händler und Kisten hinterlegt, die später über den Flashspeicher abgerufen werden. Die Münzen werden hier ebenfalls abgelegt als Funktionsvariable, wird aber erst in einen späteren Post weiter behandelt. (im Folgender Programmcode sind Kommentare und Bilddaten gekürzt, ggf. schaut ihr am besten in die Github Sourcen)
Der Händler oder Händlerin sollten für die Kollisionsabfrage den selben Raum einnehmen, wie die eigene Spielfigur. Damit dies funktioniert und der Händler nicht wie ein Karten Block (Kachelgröße) registriert wird, ist eine kleine Erweiterung an der Methode "CanEnterArea" mit "checkCollideOther" notwendig. Etwas abwegig ist die Abfrage der Position, weil diese wiederum über das Byte Array der Karte weiterhin abgefragt wird. Dafür habe ich eine relativ simple Lösung (ggf. in den Github Source schauen)
Der Text bekommt sein Platz in einem eigenen Fenster Bereich. Für diese Funktion wird ebenfalls eine weiter Seite angelegt mit dem Namen "WindowComponent". Das Fenster (MessageBox) wird angezeigt, sobald man mit seiner gesteuerten Figur in den Kollisionsradius des Händlers kommt.
Solange der Dialog offen ist, sollte die Figur nicht mehr bewegbar sein und mit dem Joystick kann nur noch in den Taschenplätzen Navigiert werden. Nachdem der Spieler die Schließen-Option Auswählt, verschwindet das Fenster und die Figur sollte sich wieder frei bewegen können.
Was im folgenden Code nicht zu sehen ist, ist die Ausführung des Schließen der MessageBox über den Button 2 bzw. Switch 2.
Das Stehenbleiben der Figur muss wiederum auf der Hauptseite festgelegt werden. Dazu muss die Funktion für das Laufen erweitert werden, damit die Figur sich erst nach der Option "Schließen" bewegen kann. Zudem müssen alle Inhalte nach dem Schließen neu gerendert werden mit der Methode 'drawStack'.
void loop() {
…
// Wenn sich X oder Y Position unterscheiden, dann den zu bewegenden Punkt neu zeichnen.
if(!menueNavigation && lastPosX != lastPosXtemp || lastPosY != lastPosYtemp) {
drawStack(false);
}
else if(menueNavigation) {
menueNavigateWithDelay();
}
drawWindow(lastPosX > EsploraTFT.width() / 2);
drawCoinsStatus(false);
}
Der Dialog ist noch nicht ganz fertig. Die Taschenplätze sollten mit dem Joystick erreichbar sein. Das fehlt derzeitig auch für den Rucksack. Dies würde jedoch den Rahmen des Posts sprengen und kommt daher im übernächsten. Für den nächsten Part wird der Programmcode dringend aufgeräumt, auf dass ich näher eingehen will.
Was wäre ein Abenteuer ohne einen Rucksack, in dem man seine Gefundenen Gegenstände einsammeln kann. Um diese Funktion Übersichtlich zu halten, wird der Rucksack sechs Plätze haben. Im Vorfeld muss festgelegt werden, wie zunächst die Informationen im Rucksack gehalten werden. Auch hier wird weiterhin eine Datenbanklose Lösung erzielt. Die Gegenstände müssen als Abstrakt betrachtet werden, so dass diese auf wesentliche Informationen eingeschränkt wird.
Ein wichtiger Punkt wird sein, die Funktionsvariablen entsprechend zu kommentieren. Das wird später hilfreich sein, die Informationen auch wieder zu zuordnen.
Ein Objekt sollte Grundlegende Eigenschaften haben:
Name
Bild (ein 16x16 Pixel Sprite)
Beschreibung (sollte nur für bestimmte Gegenstände verwendet werden)
Verwendungszweck
Damit der Gegenstand Zugeordnet werden kann, ist zusätzlich eine Identifikationsnummer erforderlich oder auch kurz ID. Diese wird z.B. für den Rucksack Funktion verwendet. Allerdings muss die ID Nummer nicht als Funktionsvariable angelegt werden und steht nur als Kommentar zu den verwendeten Daten.
// ID 01
// Name
const PROGMEM char itemKey01[10] = "Schluessel";
// Icon / Bild
const PROGMEM byte itemKey01Icon[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,10,10,10,0,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,10,0,0,0,0,10,0,0,10,10,10,10,10,10,10,10,10,10,10,0,0,10,0,0,10,10,0,10,0,0,0,0,10,0,0,0,0,10,0,0,10,0,0,0,0,0,0,0,10,0,0,0,10,0,0,0,0,0,0,0,0,0,0,0,0,10,10,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
// Beschreibung
const PROGMEM char itemKey01Description[] = "Oeffnet eine Box";
// Verwendungszweck Id => kombinierte funktions abruf fur position und verknuepfte Box mit der selben Id
const PROGMEM uint16_t itemKey01Usage = 1;
// #######################################
// ID 02
// Name
const PROGMEM char itemCamera[6] = "Kamera";
// Icon / Bild
const PROGMEM byte itemCameraIcon[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,9,9,9,9,9,9,1,0,0,0,0,0,1,1,1,1,9,19,19,19,19,9,1,1,1,1,0,1,9,9,9,9,9,9,1,1,9,9,9,9,9,9,1,1,9,9,9,9,1,1,11,11,1,1,9,19,19,9,1,1,9,9,9,9,1,11,11,11,11,1,9,19,19,9,1,1,9,9,9,1,11,11,11,11,11,11,1,9,9,9,1,1,9,9,9,1,11,11,11,11,11,11,1,9,9,9,1,1,9,9,9,9,1,11,11,11,11,1,9,9,9,9,1,1,9,9,9,9,1,1,11,11,1,1,9,9,9,9,1,1,9,9,9,9,9,9,1,1,9,9,9,9,9,9,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 };
// Beschreibung
const PROGMEM char itemCameraDescription[] = "Mach ein paar Fotos!";
// Verwendungszweck
const PROGMEM uint16_t itemCameraUsage = 2;
Der Name ist klar, Bild muss sein und Beschreibung zu einem Objekt ist auch hilfreich. Aber wie sieht der Einsatz für die Eigenschaft 'Verwendungszweck' aus? Im Programmcode wird dort eine Nummer stehen. Hier kommt die Kollisionsabfrage ins Spiel.
Ein Fallbeispiel
Die Figur hat den Gegenstand 'Schlüssel' und kann damit eine Bestimmte Tür öffnen. Über die Kollisionsabfrage wird geprüft, ob das Hindernis eine Tür ist. Wenn ja, dann wird der Rucksack nach einem Objekt abgefragt, dass dem Verwendungszweck entspricht.
Weiteres zum Verwendungszweck, kommt im späteren Abschnitt und bleiben zunächst bei der Umsetzung Gegenstände einzusammeln.
Der Rucksack
Als erstes sollten die Taschenplätze im Unteren Bildschirm Bereich abgebildet werden. Im Aus übersichtlichen Gründen wird im Programmcode eine weitere Seite (Tab) angelegt mit dem Namen 'BackpackComponent'. Für die Anforderungen kommen einige Funktionen hinzu, um ein Item in den Rucksack zu schreiben, abzurufen oder zu entfernen.
// Grundeinstellung des Rucksackes
#define backpackPlacesCount 6
uint16_t backPlaces[backpackPlacesCount] = { 0, 0, 0, 0, 0, 0 };
byte tempIcon[256];
// … Item Objekte …
// Kopiert das array aus dem flash in den Arbeitsspeicher
void setItemIconToTemp(byte icon[]) {
for(int index = 0; index < 256; index++) {
tempIcon[index] = pgm_read_byte_near(icon + index);
}
}
// Pruefen ob das Item bereits vorhanden ist
boolean isItemInBackback(uint16_t itemId) {
for(byte index = 0; index < 6; index++) {
if(backPlaces[index] == itemId) { return true; }
}
return false;
}
// Legt das Item in die Tasche ab und Zeichnet es in einen offen Taschenplatz
bool setItemToBackpack(uint16_t itemId) {
if(isItemInBackback(itemId)) { return false; }
// id ablegen in ersten freien Taschenplatz
byte place = 0;
for(byte index = 0; index < sizeof(backPlaces); index++) {
if(backPlaces[index] == 0) {
backPlaces[index] = itemId;
place = index;
break;
}
}
byte relationPlaceX = 0;
byte relationPlaceY = 0;
setItemRelationPlace(place, &relationPlaceX, &relationPlaceY);
// Abruf des Icon zu dem Item
boolean isArrayCopy = true;
switch(itemId) {
case(1): { setItemIconToTemp(itemKey01Icon); break; } // Schluessel
case(2): { setItemIconToTemp(itemCameraIcon); break; } // Fotoapparat
case(3): { setItemIconToTemp(itemPhoto01Icon); break; } // Foto
default: { isArrayCopy = false; break; } // Nicht belegt, darf aber auch nicht eintreten
}
if(isArrayCopy) { drawTile(relationPlaceX, relationPlaceY, mapTileSize, mapTileSize, tempIcon, false); }
else { EsploraTFT.fillRect(relationPlaceX, relationPlaceY, mapTileSize, mapTileSize, 0xF800); }
// einen Rahmen darueber zeichnen
EsploraTFT.drawRect(relationPlaceX, relationPlaceY, mapTileSize, mapTileSize, mapNumberToColor(12));
return true;
}
// Holt die anfangs Position des Taschenplatzes das auf dem Bildschirm gerendert werden soll.
void setItemRelationPlace(byte place, byte* relationPlaceX, byte* relationPlaceY) {
if(place == 0 || place == 1 || place == 2) { *relationPlaceY = 96; } // erste Zeile
else if(place == 3 || place == 4 || place == 5) { *relationPlaceY = 112; } // zweite Zeile
if(place == 0 || place == 3) { *relationPlaceX = 0; } // erste Spalte
else if(place == 1 || place == 4) { *relationPlaceX = 16; } // zweite Spalte
else if(place == 2 || place == 5) { *relationPlaceX = 32; } // dritte Spalte
}
// Prueft die Karten Id mit einem Objekt aus dem Rucksack.
bool getItemToUsed(int16_t mapUsageId) {
int16_t itemId = 0;
// hole itemId aus der Karteneigenschaft ab.
if(mapUsageId == mapBarrierUsageDoor01) {
itemId = 1; // Id des zu verwendenden Schlussels
}
// pruefe die Tasche, ob das Item vorhanden ist und dann aus dem inventar nehmen
for(byte index = 0; index < sizeof(backPlaces); index++) {
// Item einmalig verwenden
if(itemId != 0 && backPlaces[index] == itemId) {
// Verwendungszweck
if(mapUsageId == mapBarrierUsageDoor01) {
mapBarrierDoorIsOpen = true;
backPlaces[index] = 0; // aus dem Inventar entfernen
}
}
}
if(mapUsageId == mapBarrierUsageDoor01 && mapBarrierDoorIsOpen == true) {
return true;
}
return false;
}
Die Tasche ist nun da. Jetzt fehlt noch das Einsammeln, dass mit Hilfe der Kollisionsabfrage ermöglicht. Bisher wurden nur die Werte für Begehbar und Wand geprüft. Auf der Karte kommt nun ein weiterer Wert hinzu, das für ein einzusammelndes Objekt steht. Damit wir diese Stelle wiedererkennen, muss auch das Rendern der Karte noch angepasst werden.
...
void renderMap(int positionX, int positionY, boolean renderAll) {
// zum probieren wird zunächst ein Grid gerendert.
byte index = 0;
for(byte y = 0; y < mapTileCountY; y++) {
for(byte x = 0; x < mapTileCountX; x++) {
if(((positionX >= (int)(x * mapTileSize) - (int)mapTileSize && positionX <= (int)(x + 1) * (int)mapTileSize &&
positionY >= (int)(y * mapTileSize) - (int)mapTileSize && positionY <= (int)(y + 1) * (int)mapTileSize)) ||
renderAll) {
byte bTile = pgm_read_byte_near(mapContent + index);
// TODO: Kartenspezifische abhangigkeit,
// Eigenschaften andern sich mit Kartenwechsel
if(bTile == 2 && mapKeyIsGet) { bTile = 0; }
if(bTile == 5 && mapBarrierDoorIsOpen) { bTile = 0; }
renderMapTile(x, y, bTile);
}
index++;
}
}
}
...
Momentan werden die zwei Werte noch direkt in der Funktion 'renderMap' aufgerufen. Die ergänzende Ausführung ist Simple. Solange sich noch die Objekte an ihren Stellen befinden, werden die Kacheln in der vorgesehenden Farbe eingefärbt. Die Funktion 'renderMapTile' benötigt daher weitere 'case´s'.
Die Kacheln, an dem eine Tür oder ein Schlüssel liegt, erfüllen zwei Eigenschaften. Die Kachel ist weiterhin begehbar und hat ein Objekt. Wurde das Objekt aufgenommen, wird jedoch im Karten Array der Wert nicht auf '0' gesetzt. Denn die Karte wird immer aus dem Flashspeicher geladen und kann nur gelesen werden. Deshalb werden neue Funktionsvariablen angelegt die den Status der Kachel wiedergeben. Das wird bereits in der Funktion 'renderMap' erledigt. Später erfüllen die Variablen auch für andere Karten dieselbe Rolle. Die Information wird jedoch für die Karte hinfällig, wenn sie verlassen wird. Aber dazu in einen späteren Post.
Die Kollisionsabfrage 'checkCollideNeighbor' wurde erweitert, um den Wert '2' und '5'. Die Werte '3' und '4' werden jetzt noch nicht verwendet, sollen aber später die selbe Eigenschaft haben, wie der Wert '2'. Der folgende Vorgang prüft ähnlich wie bei einer Kollision mit einer Wand. Allerdings wird hier nach einem Objekt geprüft, dass in der zu betretenden Kachel vorhanden ist.
...
if(bTile == 2) {
resultColide = checkCollide(positionX, positionY, mapOffsetX, mapOffsetY);
// Abruf des Objektes, dass zu der Karte gehoert an der Position.
if(!resultColide) {
if(setItemToBackpack(1)) {
mapKeyIsGet = true;
}
// nicht blockieren
resultColide = true;
}
}
...
Der Wert '5' benötigt ein anderes Vorgehen, hält sich jedoch ebenfalls simpel. Auch hier wird vorher abgefragt, ob ein Hindernis besteht. Wenn nicht, dann prüfe ob die Tür offen ist oder der Schlüssel die Tür öffnet. In diesem Fall verschwindet der braune Block.
...
if(bTile == 5) {
resultColide = checkCollide(positionX, positionY, mapOffsetX, mapOffsetY);
// Uebergabewert des Verwendungswecks > Tuer oeffnen.
// kollision aufheben
if(!resultColide) {
// ID 1 ist der Schlüssel und entscheidet,
// ob die Tuer sich oeffen laest.
resultColide = getItemToUsed(1);
}
}
...
Animationslos verschwindet die Tür. Hier färbt sich die braune Kachel in hell grün (sieht leider mehr grau aus), sowie die anderen Kacheln die begehbar sind. So dass sollte Inhaltlich vom Blogpost reichen. Das Thema ist länger geworden als vorgesehen und dabei habe ich einiges noch gekürzt. Alles weiter sowie Kommentar Beschreibungen sind in den Sourcen eingetragen, die ich wieder auf Github hoch geladen habe.
Dass die Grundfunktionen noch nicht reichen, dürfte klar sein und viele würden lieber ein Schwert ziehen und Monster bekämpfen. Aber, wie bereits ein weiser Mann Sprach: "Wie soll das Schwert richtig geschwungen werden, wenn das nicht mal mit einem Stock geht".
Sicherlich habt ihr entweder am Programcode oder beim Testen der Spielfunktionen bemerkt, dass die Kollisionsabfrage nur bedingt funktioniert. Sie ist zwar einfach, aber hier fehlt die Einschränkung, dass man sich nur von Block zu Block bewegen kann. Offen gestanden war ich kein Fan davon, das sich die Figur weiter bewegt bis der nächste Feld oder Kachel erreicht wurde.
Zu dem Thema Spieleprogrammierung und Kollisionsabfrage für 2D Spiele, können verschiedene Lösung im Internet gefunden werden. Ein Beispiel wird hier auf spieleprogrammierer.de/wiki beschrieben, wie man mit Geometrischen Objekten die Kollision Abfragen kann.
Die simple Form für die Kollisionserkennung ist das Verwenden von zwei Rechtecken. Im folgenden Code zeigt die Methode die wesentliche Abfrage von überschneidenden Rechtecken.
// Kachel Position mit zukuenftiger Position der Figur abgeleichen,
// durch ansetzten von Rechtecken und ob diese sich ueberschneiden.
boolean checkCollide(byte positionX, byte positionY, byte mapOffsetX, byte mapOffsetY) {
if(positionX < mapOffsetX + mapTileSize &&
positionX + 10 > mapOffsetX &&
positionY < mapOffsetY + mapTileSize &&
positionY + 16 > mapOffsetY)
{
// DEBUG: Nur fuer debug und visuelle kontrolle
EsploraTFT.drawRect(positionX, positionY, 10, 16, 0xFA8A);
return false;
}
return true;
}
Die Abfrage reicht jedoch nicht aus, um zu verhindern, dass die Figur wieder durch die Wand geht. Oft müssen auch übereinander oder nebeneinander liegende Kacheln zusätzlich geprüft werden. Für einen späteren Blogpost wird die Kachelgröße Reduziert von 16x16 auf 8x8. Spätestens dann wird die jetzige Abfrage erforderlich sein, alle Hindernisse zu erkennen. Das war leider nicht ganz ohne und zugegeben habe ich daran relativ viel Zeit damit verbracht, die Kollisionen durch zu debuggen.
// Prüfen, ob in diesem Bereich sich bewegt werden kann.
boolean CanEnterArea(int positionX, int positionY) {
boolean resultColide = true;
// umliegende Kacheln auf hindernis prüfen
// wenn hoch oder runter
if(directionX == 0) {
for(uint8_t i = 0; i < 3; i++) {
int tileX = (positionX + (collisionTiles[i] * mapTileSize)) / mapTileSize;
int tileY = -1;
int tileYTemp = tileY;
int positionYShift = 0;
while(tileY == tileYTemp && tileY != 0) {
if(directionY == -1) {
tileY = (positionY + directionY + positionYShift) / mapTileSize;
}
else { tileY = (positionY + directionY + 16 + positionYShift) / mapTileSize; }
positionYShift += mapTileSize * directionY;
}
resultColide = checkCollideNeighbor(positionX, positionY + directionY, tileX, tileY);
if(!resultColide) {
break;
}
}
}
// wenn links oder rechts
if(directionY == 0) {
for(uint8_t i = 0; i < 3; i++) {
int tileX = positionX / mapTileSize;
int tileY = (positionY + (collisionTiles[i] * mapTileSize)) / mapTileSize;
int tileXTemp = tileX;
int positionXShift = 0;
while(tileX == tileXTemp) {
if(directionX == -1) { tileX = (positionX + directionX + positionXShift) / mapTileSize; }
else { tileX = (positionX + directionX + 10 + positionXShift) / mapTileSize; }
positionXShift += mapTileSize * directionX;
}
resultColide = checkCollideNeighbor(positionX + directionX, positionY, tileX, tileY);
if(!resultColide) {
break;
}
}
}
return resultColide;
}
// Laedt aus dem Flashspeicher die Kachelelemente ab und
// prueft die Kollision mit neben anliegende Kacheln.
// Verhindert speziel den Fehhler zwischen zwei Kacheln, nur eine zu pruefen.
boolean checkCollideNeighbor(int positionX, int positionY, int tileX, int tileY) {
boolean resultColide = true;
int mapOffsetX = tileX * mapTileSize;
int mapOffsetY = tileY * mapTileSize;
int indexStart = (tileY * mapTileCountX) + tileX;
// hole die content Nummer ab um die kollisionsart zu bestimmen
byte bTile = pgm_read_byte_near(mapContent + indexStart);
if(bTile == 1 && resultColide) {
// DEBUG: Nur fuer debug und visuelle kontrolle
EsploraTFT.drawRect(mapOffsetX, mapOffsetY, mapTileSize, mapTileSize, 0xFA8A);
resultColide = checkCollide(positionX, positionY, mapOffsetX, mapOffsetY);
}
return resultColide;
}
Nun eckt die Figur in positiven Sinne überall an und kann sich nicht mehr wie ein Geist durch die Wand bewegen. In einen späteren Post wird die Kollisionsabfrage auch für Türen verwendet, um z.B. einen Kartenwechsel auszulösen.
Für Debug und Demo Zwecke, werden die Rechtecke mit eingezeichnet, die visuell die Kollision abbilden.
Der Clip zeigt die ungenaue Kollisionsabfrage, wie sie zuvor war. Wie bereits beschrieben, war diese simple und schnell umgesetzt.
Mit der implementieren der Abfrage von überschneidenden Rechtecken sieht das Ergebnis besser aus.
Der Arduino oder auch vielmehr der verwendete Mikrocontroller hat für viele Anwendungen genügend Arbeitsspeicher. Im ersten Teil der Blogpost Reihe verwendete ich einen Arduino Nano, der einen ATmega328 hat und einen Arbeitsspeicher von 2kByte besitzt. Der Arduino Esplora verwendet den ATmega32u4 der wiederum 2,5kByte Arbeitsspeicher aufweist. Trotz des etwas größeren Arbeitsspeichers muss für dieses Projekt dennoch sparsam damit umgegangen werden.
ATmega328P und ATmega32u4
Arbeitsspeicher verbrauch
Ein Sprite Bild besteht selbst aus 160 Bytes. Das klingt jetzt nicht viel, aber verbraucht den Arbeitsspeicher bereits mit über 6%. Würde man die Sprite Animation der Figur nicht mit dem Trick einzelner Bilder spiegeln, dann würden insgesamt 2,92kByte Arbeitsspeicher anfallen. Stattdessen werden momentan 1,12kB verwendet, dass allerdings für das Ziel immer noch zu viel ist. Und dann kommt noch die Karte mit 160 Bytes hinzu, die noch sehr grob ist. Da bleibt am Ende nicht viel übrig. Der jetzige Sketch verwendet ca. 1,575kBytes Arbeitsspeicher.
Vom Flashspeicher
Im Gegensatz zu dem insgesamten Flash Speicher mit 32kB, ist dieser gerade mal mit 12,45kB belegt. Damit liegt nahe, dass Sprites und weitere Daten am besten zur Laufzeit geladen werden. Hier kommt ein Kompromiss zustande über die Lesegeschwindigkeit von Flasch und RAM.
Eine kleine Umstellung und die Byte Array lassen sich aus dem Flashspeicher lesen, wenn diese zur Laufzeigt benötigt werden. Die folgenden Ergebnisse nach dem Kompilieren zeigen den Unterschied zwischen dem Sketch vom letzten Stand mit dem Anlegen der Karte und das gleiche jedoch nach der Umstellung mit PROGMEM.
Ohne PROGMEM
Mit PROGMEM
Weitere Informationen könnt ihr auf der Arduino Seite über PROGMEM erfahren.
Das folgende Code Ausschnitt zeigt die Änderung der Funktionsvariable eines Byte Array ergänzt wird.
Sobald alle Byte Arrays mit dem Präfix 'const' und 'PROGMEM' erweitert wurden, dürfte der Belegte Speicher deutlich gesunken sein. Ein Byte Array bleibt allerdings immer im Speicher, dass ist der Buffer oder wie im Beispiel 'tempArray' benannt wird aus dem Flash in das Byte Array geladen, das über eine einfache Funktion übertragen wird.
// kopiert den Array Inhalt vom Flashspeicher in den SRAM
Alle Funktionsvariablen die nicht zur aktuellen Ausführung verwendet werden, könnten über die Funktion erweitert werden. Also eine Spriteanimation rendert immer nur eines der angelegten Sprites.
Eine Figur durch einen leeren Raum zu steuern, ist auf Dauer sehr öde. Man kann nun den Hintergrund zunächst eine Farbe geben, ist aber dennoch sehr eintönig ist. Schauen wir uns andere Spiele an, könnte man meinen, dass alles in der Umgebung in Blöcken unterteilt ist.
Und so wird dies auch in diesem Beispiel umgesetzt. Die Karte wird Blockweise angelegt. Das ermöglicht uns weiterhin nur die Bereiche neu zu rendern, die sich auch geändert haben. Karten Eigenschaften
Mit der Unterteilung in Blöcken, kann ein Block verschiedene Eigenschaften aufweisen. Hier stellt die '0' die Frei Begehbaren Blocke da, in dem sich die Figur bewegen kann. Der Wert '1' wiederum stellt eine Mauer da, an dem die Figur nicht hindurch gehen kann. Die Fläche eines Blockes ist etwas größer als die der Figur. Daher weist die Kanten länge 16 Pixel mal 16 Pixel auf.
Ordnung ist das halbe Leben
Zunächst muss vorweg etwas Ordnung eingebracht werden. Zwar habe ich bereits mit dem letzten Post die Funktionen zu der Figur in einen eignen Tab/Seite eingesetzt, aber ich bin nicht weiter darauf eingegangen.
Damit nicht zu viel Code auf einer Seite ist, teilen wir die Inhalte in Zugehörigkeiten auf. Somit kommen die Funktionen/Methoden für die Farbe und das Ausfüllen eines Quadrates in einen eignen neuen Tab mit dem Namen 'RenderComponent'. Die Funktionen zur Karte werden unter 'MapComponent' abgelegt und 'FigureComponente' sollte nur noch die Inhalte zur Spielfigur haben.
Das Schreiben von Pixeln
Die Methode mit dem die Farbnummern, die die Farbwerte für die Ausgabe zurückgibt, kommt in den 'RenderComponent'. Die zuvor verwendete Funktion/Methode drawFigurArray wird zusammengefasst und um weitere Parameter erweitert, die dann drawTile genannt wird. Im späteren Blog Post Teil, wird die Funktion/Methode nicht nur für das Rendern der Figur eingesetzt.
void drawTile(int relationX, int relationY, byte tileWidth, byte tileHeight, byte tilePic[], boolean mirror) {
int index = 0;
for(int y = 0; y < tileHeight; y++) {
for(int x = 0; x < tileWidth; x++) {
int indexTarget = index;
if(mirror) {
indexTarget = index - x + (tileWidth - x) - 1;
}
byte colorNumber = tilePic[indexTarget];
// Nur Farbe
if(colorNumber != 0) {
EsploraTFT.drawPixel(relationX+x, relationY+y, mapNumberToColor(colorNumber));
}
index++;
}
}
}
uint16_t mapNumberToColor(byte c) {
uint16_t result = ST7735_RED;
switch(c) {
case(1):{ result = ST7735_BLACK; break; }
case(2):{ result = 0xF590; break; } // haut
case(3):{ result = 0x81E1; break; } // braun
case(4):{ result = 0xC2C2; break; } // hell braun
case(5):{ result = 0x8300; break; } // braun gelb
case(6):{ result = 0x5406; break; } // gruen
case(7):{ result = 0x32A4; break; } // dunkel gruen
case(8):{ result = 0xAE91; break; } // hell gruen
case(9):{ result = 0x2146; break; } // dunkel grau blau
case(10):{ result = 0x31E9; break; } // grau blau
case(11):{ result = 0x84B6; break; } // hell blau
case(13):{ result = 0xFC08; break; } // orange
case(14):{ result = 0xFA8A; break; } // hell rot
case(15):{ result = 0xD759; break; } // hell gruen 2
default: {
result = 0;
break;
}
}
return result;
}
Sprite Render Methode ändert sich
Nun sollte auch der Programmcode in 'FigureComponent' angepasst werden. Die Methode 'drawFigure' hatte zum Zeichnen die Methode 'drawFigureArray' und wird nun mit der Methode 'drawTile' aus dem Tab 'RenderComponent' ersetzt. Folgender Code zeigt einen Ausschnitt der Änderung. Wie zu sehen ist, wird nun die Breite und Höhe das Sprite übergeben und der Parameter für 'Clear' entfällt.
Für das Anlegen einer Karte wird ein weiteres Byte Array angelegt. Ein Byte stellt eine Kachel Information da. Wie bereits am Anfang des Posts beschrieben, ist '0' Begehbar und '1' wiederum nicht. Da pro Kachel 16 Pixel mal 16 Pixel groß ist, können in der Breite zehn Kachel Nebeneinander aufgestellt werden. Untereinander werden sechs Kacheln angelegt. Der Restliche Bereich unten bleibt frei für später kommende Spieldaten.
Über die Kacheln und anecken
Die erste Methode 'renderMap' liest das Array ein, dass die Karteninformation auf das Display Zeichnet. Mit 'canEnterArea' wird auf einfache Weise die zu betretende Kachel geprüft, ob diese begehbar ist. Wo die Funktion eingesetzt wird, komme ich in einen späteren Absatz . In einen späteren Absatz gehe beschreibe ich, wo diese Funktion ihren Einsatz findet.
Hier sei Angemerkt, dass die Kollisionsabfrage wirklich sehr simple ist, so dass ein durchlaufen unter Umständen dennoch möglich ist. Eine bessere Lösung zu diesen Thema, gehe ich jedoch erst in einen späteren Post darauf ein.
Zuletzt für das Zeichnen einer Kachel, unternimmt die Methode 'renderMapTile' eigentlich zwei Aufgaben. Sie ruft zu dem Byte eine Farbnummer ab und verwendet diesen Wert, um eine Kachel Ausgefüllt auf dem Display zu zeichnen. Genauere Beschreibungen zu den Funktionen und Variablen findet im Sourcecode.
// Karte
byte mapContent[160] = {
1,1,1,1,1,1,1,1,1,1,
1,0,1,0,0,0,0,0,0,1,
1,0,1,0,0,1,0,0,0,1,
1,0,1,0,0,1,1,1,0,1,
1,0,0,0,0,0,0,0,0,1,
1,1,1,1,1,1,1,1,1,1,
};
// Groeße einer Kachel
byte mapTileSize = 16;
// Anzahl Kacheln auf der X Achse
byte mapCountX = 10;
// Anzahl Kacheln auf der Y Achse
byte mapCountY = 6;
void renderMap(int positionX, int positionY, boolean renderAll) {
byte index = 0;
for(byte y = 0; y < mapCountY; y++) {
for(byte x = 0; x < mapCountX; x++) {
if(((positionX >= (int)(x * mapTileSize) - (int)mapTileSize && positionX <= (int)(x + 1) * (int)mapTileSize &&
positionY >= (int)(y * mapTileSize) - (int)mapTileSize && positionY <= (int)(y + 1) * (int)mapTileSize)) ||
renderAll) {
renderMapTile(x, y, mapContent[index]);
}
index++;
}
}
}
// Einfache Kollisionsabfrage
boolean canEnterArea(byte positionX, byte positionY) {
// Kachel Kordinate abrufen
byte tileX = positionX / 16;
byte tileY = positionY / 16;
// Index aus dem Array abfragen
byte index = (tileY * mapCountX) + tileX;
// ist das Feld begehbar
if(mapContent[index] == 0) {
return true;
}
return false;
}
// rendert die Kacheln Einfarbig.
void renderMapTile(byte x, byte y, byte mapSegment) {
byte mapTileColorNumber = 0;
switch(mapSegment) {
case(1): { mapTileColorNumber = 10; break; }
default: { mapTileColorNumber = 15; break; }
}
EsploraTFT.fillRect(x * mapTileSize, y * mapTileSize, mapTileSize, mapTileSize, mapNumberToColor(mapTileColorNumber));
}
Blockade prüfen
In der 'loop' Funktion wird je nach Ausrichtung die Position um einen hoch oder runter gezählt. Mit der neuen Funktion 'canEnterArea' aus dem Tab 'MapComponent' kann nun verhindert werden, dass die Figur nicht in eine Blockwand laufen kann. Der folgende Code zeigt die Bedingung für Links mit der neuen Funktion und der Parameter Übergabe über die nächste Position.
…
if(buttonLeft && !buttonRight && lastPosX > 0) {
// nach links und letzte Position Y ist groesser als '0'.
if(canEnterArea(lastPosX - 1, lastPosY)) {
lastPosX--;
}
}
…
Offenes und ausbessern
Es funktioniert zwar schon, aber so ganz Rund sind die gängigen Funktionen noch nicht. Die kollisionsabfrage funktioniert nicht unter jeder Bedingung und die Figur flimmert. Dennoch sind diese Groben Ausführungen keine Primären Probleme und werden daher später verbessert, sobald diese ein Problem darstellen.
Der Nächste Schritt ist die Arbeitsspeicherauslastung zu verbessern. Denn derzeitig werden noch nicht viele Inhalte angezeigt, aber der Arbeitsspeicher ist mit den jetzigen Inhalten ist fast voll. Nächster Post: Voller Arbeitsspeicher (Arduino Esplora, Part 5)
Im Internet habe ich nach einer Einfachen Lösung gesucht, wie mein ein Sprite bzw. Bild auf seine eigenen Anforderungen erstellen kann. Damit ist gemeint, dass eine durchgehende Farbpallette für das Eigene Ziel abbilde und Numerisch bezeichnen kann. Zudem sollte dies in einer Byte Folge ausgegeben werden, so dass ich diese im Programmcode ablegen kann.
Natürlich gibt es so ein Programm nicht. Im Grunde ist die Ausgabe eines Bildes durch ein Skript zu übersetzen relative einfach oder auch mal schnell ein eigenes kleines Programm schreiben. Denn das habe ich zunächst gemacht, um schnell eigene Sprites anzulegen. Also zwei Abende dran ran gesetzt und fertig war der Bildeditor. Die Benutzbarkeit beschränkte sich auf die mehr auf die Verwendung der Funktionen.
Mit der Zeit wurden dann noch ein paar Farben hinzugefügt und neu Sortiert, ansonsten hat sich nichts weiter geändert.
Übung ist trainieren
Irgendwann bekam es mich doch. Ich schrieb zu Übungszwecken weiter und räumte einiges an Programmcode auf, fügte ein paar weitere Funktionen hinzu und verpasste noch ein paar Optische Verbesserungen. Da ich nicht immer Zeit hatte, verstrichen Monate und ich stellte mal wieder fest, wenn man etwas ordentlich macht, dann kann dabei schon eine Menge Zeit vergehen. Oberflächlich wird man die Mühe nicht sehen, nur die Dinge die nicht funktionieren. Schließlich sind wir in Deutschland und gemeckert wird immer.
Wie verwende ich das Programm
Man schreibt ein Programm, kopiert sich die fertigen Code aus dem Beispiel, malt ein Bild und klickt auf Exportieren. Na gut, etwas mehr Detaillierter darf die Beschreibung dann doch sein.
Am besten verwendet ihr den folgenden Beispiel Programmcode. Je nach Größe des Bildes, müssen die Breite und Höhe angepasst werden. Das sind die Member Variablen 'pictureWidth' und 'pictureHeight', sowie auch die Array Größe und dessen eingetragenen Byte Werte. Im Beispiel ist ein Bild das 10 Pixel Breit und 16 Pixel hoch ist. Multipliziert man die beiden Werte, dann bekommen wir den Wert 160, dass hier die Byte Array Größe festlegt.
#include <SPI.h>
#include <TFT.h>
#include <Esplora.h>
// zu renderndes Bild
int pictureWidth = 10;
int pictureHeight = 16;
byte picture[160] = {
0,0,1,1,1,1,1,1,0,0,0,1,3,3,3,3,3,3,1,0,1,3,3,3,3,3,3,3,3,1,1,3,3,4,4,2,4,3,3,1,1,3,5,5,2,2,5,5,3,1,1,3,4,1,2,2,1,4,3,1,0,1,2,1,2,2,1,2,1,0,0,0,1,2,2,2,2,1,1,0,0,1,8,8,3,3,8,8,6,1,1,8,8,8,8,8,8,6,2,1,1,2,1,8,8,8,8,1,1,0,0,1,1,10,10,7,7,1,0,0,0,1,9,10,1,7,6,1,0,0,0,0,1,1,1,7,6,1,0,0,0,0,0,0,1,9,11,1,0,0,0,0,0,0,0,1,1,0,0,0
};
void setup() {
// init display
EsploraTFT.begin();
EsploraTFT.initR(INITR_BLACKTAB);
EsploraTFT.setRotation(1);
EsploraTFT.background(0, 0, 0);
}
void loop() {
drawPictureArray(40, 40, picture);
}
uint16_t mapNumberToColor(byte c) {
uint16_t result = ST7735_RED;
switch(c) {
case(1): { result = ST7735_BLACK; break; }
case(2): { result = 0xF590; break; } // haut
case(3): { result = 0x81E1; break; } // braun
case(4): { result = 0xC2C2; break; } // hell braun
case(5): { result = 0x8300; break; } // braun gelb
case(6): { result = 0x5406; break; } // gruen
case(7): { result = 0x32A4; break; } // dunkel gruen
case(8): { result = 0xAE91; break; } // hell gruen
case(9): { result = 0x2146; break; } // dunkel grau blau
case(10):{ result = 0x31E9; break; } // grau blau
case(11):{ result = 0x84B6; break; } // hell blau
case(12):{ result = 0xFFE0; break; } // gelb
case(13):{ result = 0xFC08; break; } // orange
case(14):{ result = 0xFA8A; break; } // hell rot
case(15):{ result = 0xD759; break; } // hell gruen 2
case(16):{ result = 0xF800; break; } // rot
case(17):{ result = 0x8208; break; } // dunkel braun
case(18):{ result = 0xC618; break; } // grau
case(19):{ result = 0xF7BE; break; } // sehr hell grau
case(20):{ result = 0xFE97; break; } // hell haut
default: {
result = 0;
break;
}
}
return result;
}
void drawPictureArray(int relationX, int relationY, byte pictureArray[]) {
int index = 0;
for(int y = 0; y < pictureHeight; y++) {
for(int x = 0; x < pictureWidth; x++) {
EsploraTFT.drawPixel(relationX+x, relationY+y, mapNumberToColor(pictureArray[index]));
index++;
}
}
}
Wenn ihr den Bild Editor Startet, dann wird gleich ein neues Bild von 10 mal 16 Pixel angelegt.
Über ‚Edit' kann die Größe des Pixelfeldes geändert werden. ACHTUNG: Nach Umstellung der Größe, gehen bereits eingetragene Pixel verloren.
Ist das Bild fertig, dann kann über File -> Export die Byte Kette selektiert und per STRG+C kopiert werden.
Über STRG+V wird zwischen den geschweifte Klammern der Member Variable 'picture' hinzugefügt. Ggf. Breite, Höhe und byte Array Größe anpassen und schon kann der Programmcode auf den Arduino Esplora geschrieben werden.
Sobald das Programm auf dem Arduino Esplora ausgeführt wird, sollte nun das Bild zu sehen sein, dass als Byte Kette hinein kopiert wurde.
Hinweise:
Im Programm sind bereits mehr Farben hinterlegt, da ich zu diesen Zeitpunkt mit dem Eigentlichen Projekt weiter gearbeitet und weitere Farben ergänzt habe.
Touch Fähigkeit wird noch bearbeitet.
Ein Bild mit Programmcode darf nicht mehr Bytes verbrauchen als der Maximale Arbeitsspeicher des Arduinos.
Der Bildeditor ist an für sich fertig. Fehler sind nicht ausgeschlossen und können über die Kommentar Funktion des Blogs eingetragen werden. Nächster Post: Karte anlegen (Arduino Esplora, Part 4)
Low Pixel Maker Download Anmerkung: Ich räume noch das kleine Programm auf. Sobald ich damit fertig bin, lade ich die Solution auf Github hoch.
