Arduino Touch Breakout-Spiel

Apps und Onlinedienste

Arduino-IDE

Über dieses Projekt

Dies ist eine kleine Version des klassischen Breakout-Videospiels für Arduino UNO und TFT-LCD-Bildschirm (240x320 Pixel), Treiber ILI9341 mit 8-Bit-Parallelkommunikation.

Das Spiel

Dieser Breakout hat mehrere Bildschirme mit verschiedenen konfigurierbaren Reihen und Spalten von Steinen, bis zu acht Reihen, wobei jede zwei Reihen eine andere Farbe hat, die mit verschiedenen Mustern ein- oder ausgeschaltet werden können. Mit einem einzelnen Ball muss der Spieler mit dem Touchpanel so viele Steine ​​wie möglich niederschlagen, indem er die Wände und/oder das Paddel darunter benutzt, um den Ball gegen die Steine ​​abzuprallen und sie zu eliminieren. Wenn das Paddel des Spielers den Abprall des Balls verfehlt, verliert er eine Runde.

Jede Reihe von Steinen bringt unterschiedliche Punkte.

uint8_t pointsForRow[] ={7, 7, 5, 5, 3, 3 , 1, 1}; 

Jedes Level kann die Paddelgröße und die Ballgröße konfigurieren. Die Ballgeschwindigkeit erhöht sich bei jedem Treffer, Sie können die Anfangsgeschwindigkeit für jeden Bildschirm konfigurieren. Abhängig von der Position des Schlägers, der den Ball trifft, ändert sich auch die horizontale Geschwindigkeit

Sie können als neue Bildschirme mit verschiedenen Wandmustern definieren:

Spielanleitung

Halten Sie das Gerät mit Ihren Händen und bewegen Sie das Paddel mit Ihren Daumen über dem Bildschirm nach links oder rechts.

Definiere einen neuen Bildschirm

Diese Struktur wird verwendet, um einen neuen Bildschirm zu definieren:

typedef struct game_type {
 int ballsize;
 int playerwidth;
 int playerheight;
 int exponent;
 int top;
 int Zeilen;
 int Spalten;
 int brickGap;
 int Leben;
 int wall[GAMES_NUMBER];
 int initVelx;
 int initVely;
} Spieltyp; 

und füge den neuen Bildschirm zum Set hinzu:

game_type games[GAMES_NUMBER] =
 // ballsize, playerwidth, playerheight, exponent, top, rows, column, brickGap, lifes, wall[8], initVelx, initVely
{
 { 10, 60, 8, 6, 40 , 8, 8, 3, 3, {0x18, 0x66, 0xFF, 0xDB, 0xFF, 0x7E, 0x24, 0x3C} , 28, -28}, 

Wandmuster

Das Wandmuster ist als 8x8-Bit-Array definiert

ej.

{0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA} 

das entspricht diesem Bit-Array

1,0,1,0,1,0,1,0
1,0,1,0,1,0,1,0
1,0,1, 0,1,0,1,0
1,0,1,0,1,0,1,0
1,0,1,0,1,0,1,0
1,0,1,0,1,0,1,0
1,0,1,0,1,0,1,0
1,0,1,0,1,0 ,1,0 

Erzeugt diese Wand, beachten Sie, dass sie gespiegelt ist:

Hardware

Dieses Projekt verwendet ein 2,4-Zoll-TFT-LCD-Display von AZ-Delivery mit resistivem 4-Draht-Touchscreen und einem integrierten SD-Kartenleser. AZ-Delivery 2,4 Zoll TFT LCD-Display.

Mehr zu diesem Schild in meinem Artikel "Road testing an AZ-Delivery 2, 4 TFT LCD Touch Display"

Zusammenbau der Abschirmung

Sie müssen nur den Schirm über den Aduino stecken.

Bibliotheken

#include  // Kerngrafikbibliothek
#include 
#include  

Kalibrieren des Touchscreens

Sie müssen das Display kalibrieren, damit die Positionsinformationen beim Berühren des Displays korrekt sind. Die Bibliothek MCUFriend_kbv bietet ein Beispiel mit dem Namen "TouchScreen_Calibr_native". Das Beispiel sendet die Ergebnisse an die serielle Schnittstelle. Starten Sie den seriellen Monitor der Arduino IDE, damit Sie den vom Beispiel generierten Code kopieren können.

Folgen Sie den Anweisungen auf dem Touch-Display, drücken und halten Sie die angezeigten Positionsmarkierungen, die weiß hinterlegt sind. Nachdem Sie alle Positionsmarken gesetzt haben, wird Ihnen die Kalibrierung des Displays auf dem Touch-Display und über die serielle Schnittstelle ausgegeben.

Für dieses Projekt benötigen Sie die Daten für die "Hochformatkalibrierung".

TouchScreen.h GFX-Kalibrierung
Herstellung aller Steuer- und Buspins INPUT_PULLUP
Typischer 30k Analog-Pullup mit entsprechendem Pin
würde Low lesen, wenn Digital auf LOW geschrieben wird
z.B. liest ~25 für 300R X-Richtung
z.B. liest ~30 für 500R Y-Richtung
Testen:(A2, D8) =26
Testen:(A3, D9) =28
ID =0x9341
cx=153 cy=103 cz=534 X, Y, Druck
cx=150 cy=475 cz=406 X, Y, Druck
cx=155 cy=868 cz=231 X, Y, Druck
cx=517 cy=103 cz=561 X, Y, Druck
cx=535 cy=855 cz=364 X, Y, Druck
cx=884 cy=88 cz=650 X, Y, Druck
cx=908 cy=478 cz=557 X, Y, Druck
cx=902 cy=864 cz=488 X, Y, Druck
*** COPY-PASTE vom seriellen Terminal:
konst int XP=8,XM=A2,YP=A3,YM=9; //240x320 ID=0x9341
const int TS_LEFT=118,TS_RT=931,TS_TOP=72,TS_BOT=887;
PORTRAIT KALIBRIERUNG 240 x 320
x =map(px, LEFT=118 , RT=931, 0, 240)
y =map(py, TOP=72, BOT=887, 0, 320)
LANDSCHAFTSKALIBRIERUNG 320 x 240
x =map(py, LINKS=72, RT=887, 0, 320)
y =map(px, TOP=931, BOT=118, 0, 240) 

Animation

Um das Bild im Laufe der Zeit über den Bildschirm zu bewegen, verwenden Sie eine statische Geschwindigkeit und wenden diese in jedem Zeitschritt auf die Position eines Bildes an.

pos +=vel * dt;

Vermeiden von Gleitkomma-Arithmetik

Die Auflösung von ILI9341 beträgt 240 x 320, daher benötigen wir zwei 9-Bit-Ganzzahlen, um auf ein Pixel auf dem Bildschirm zu verweisen. Mit 16-Bit-Ganzzahlen haben wir 6 Bits frei, um einen Dezimalteil darzustellen.

nnnn nnnn nndd dddd

Wir nennen diese Zahl 6 den binären Exponenten. Und wir können diese sechs Bits verwenden, um einen Dezimalteil im Bereich von 0,000 bis 0,63 zu erhalten. Wir können also Integer-Mathematik verwenden, um Gleitkomma-Arithmetik zu vermeiden.

Um den ganzzahligen Teil der Zahl zu erhalten, machen wir eine arithmetische Verschiebung nach rechts.

Zahl>> Exponent

state.ballx +=state.velx;
 state.bally +=state.vely;

 // Ballkollisionen prüfen und beenden
 checkBallCollisions(game , &state, state.ballx>> game->exponent, state.bally>> game->exponent);
 checkBallExit(game, &state, state.ballx>> game->exponent, state.bally>> game ->Exponent); 

Demo-Modus

Entkommentieren Sie die Direktive definieren und der Schläger folgt dem Ball, wie in den Demo-Videos zu sehen:

#define DEMO_MODE 

Viel Spaß damit!

Erstelle neue Muster in Levels und teile sie!

Code

• Arduino-Ausbruch

Arduino-AusbruchArduino

/* Arduino Touch TFT Breakout Klassisches Breakout-Spiel Benötigte Teile:Ardunio UNO AZ-Delivery 2.4 TFT LCD Touch Display Arduino Shield oder kompatibel Dieser Beispielcode ist gemeinfrei. Geändert 07 11 2020 Von Enrique Albertos*/// #define DEMO_MODE#include  // Kerngrafikbibliothek#include #include #define BLACK 0x0000#define BLUE 0x001F#define ROT 0xF800#define GREEN 0x07E0#define CYAN 0x07FF#define MAGENTA 0xF81F#define YELLOW 0xFFE0#define WHITE 0xFFFF#define PRIMARY_COLOR 0x4A11#define PRIMARY_LIGHT_COLOR 0x7A17#define_PRMARY_CSMARY #define LCD_CD A2 // Command/Data geht an Analog 2#define LCD_WR A1 // LCD Write geht an Analog 1#define LCD_RD A0 // LCD Read geht an Analog 0#define LCD_RESET A4 // Kann alternativ einfach mit Arduinos Reset verbinden pinAdafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);#define LOWFLASH (definiert(__AVR_ATmega328P__) &&definiert(MCUFRIEND_KBV_H_))// Touchscreen Druckschwelle#define MINPRESSURE 40#define MAX 8, XM =A2, YP =A3, YM =9; //240x320 ID=0x9341const int16_t TS_LEFT =122, TS_RT =929, TS_TOP =77, TS_BOT =884;const TouchScreen ts =TouchScreen(XP, YP, XM, YM, 300);#define SCORE_SIZE 30char scoreFormat[] ="% 04d";typedef struct gameSize_type { int16_t x, y, width, height;} gameSize_type;gameSize_type gameSize;uint16_t backgroundColor =BLACK;int level;const uint8_t BIT_MASK[] ={0x01, 0x02, 0x04, 0x08, 0x010, 0x20, , 0x80};uint8_t pointsForRow[] ={7, 7, 5, 5, 3, 3 , 1, 1};#define GAMES_NUMBER 16typedef struct game_type { int ballsize; int Spielerbreite; int Spielerhöhe; int-Exponent; int oben; int-Reihen; int-Spalten; int brickGap; int Leben; int wall[GAMES_NUMBER]; int initVelx; int initVely;} game_type;game_type games[GAMES_NUMBER] =// ballsize, playerwidth, playerheight, exponent, top, rows, column, brickGap, lifes, wall[8], initVelx, initVely{ { 10, 60, 8, 6, 40 , 8, 8, 3, 3, {0x18, 0x66, 0xFF, 0xDB, 0xFF, 0x7E, 0x24, 0x3C} , 28, -28}, { 10, 50, 8, 6, 40 , 8, 8, 3 , 3, {0xFF, 0x99, 0xFF, 0xE7, 0xBD, 0xDB, 0xE7, 0xFF} , 28, -28}, { 10, 50, 8, 6, 40 , 8, 8, 3, 3, {0xAA, 0x55 , 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55} , 28, -28}, { 8, 50, 8, 6, 40 , 8, 8, 3, 3, {0xFF, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF} , 34, -34}, { 10, 40, 8, 6, 40 , 8, 8, 3, 3, {0xFF, 0xAA, 0xAA, 0xFF, 0xFF, 0xAA, 0xAA, 0xFF} , 28, -28}, { 10, 40, 8, 6, 40 , 8, 8, 3, 3, {0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA} , 28, -28}, { 12, 64, 8, 6, 60 , 4, 2, 3, 4, {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} , 20, -20}, { 12, 60, 8, 6 , 60 , 5, 3, 3, 4, {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} , 22, -22}, { 10, 56, 8, 6, 30 , 6, 4, 3, 4, {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} , 24, -24}, { 10, 52, 8, 6, 30 , 7, 5, 3, 4, {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} , 26, -26 }, { 8, 48, 8, 6, 30 , 8, 6, 3, 3, {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} , 28, -28}, { 8, 44, 8, 6, 30 , 8, 7, 3, 3, {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} , 30, -30}, { 8, 40, 8, 6, 30 , 8 , 8, 3, 3, {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} , 32, -32}, { 8, 36, 8, 6, 40 , 8, 8, 3, 3, {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} , 34, -34}, { 8, 36, 8, 6, 40 , 8, 8, 3, 3, {0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA} , 34, -34}};game_type* game;typedef struct game_state_type { uint16_t ballx; uint16_t bally; uint16_t ballxold; uint16_t ballyold; int velx; int vely; int-Playerx; int-Playerxold; int wallState[8]; int-Punktzahl; int Restleben; int oben; int unten; int-Wandplatte; int Wandunterseite; int Ziegelhöhe; int brickwidth;};game_state_type state;//////////////////////////////////////// ////////////////////// ARDUINO SETUP////////////////////////// ///////////////////////////////////void setup () { initTft (tft); gameSize ={0, 0, tft.width(), tft.height()}; newGame(&games[0], &state, tft);}//////////////////////////////////// /////////////////////////// ARDUINO LOOP///////////////////// ////////////////////////////////////////int selection =-1;void loop( void){selection =readUiSelection(game, &state, selection); drawPlayer(Spiel, &Zustand); // alte Position speichern, um alte Pixel zu entfernen state.playerxold =state.playerx; // neue Ballposition berechnen x1 =x0 + vx * dt // Höchstgeschwindigkeit prüfen if (abs( state.vely)> ((1 <exponent) - 1)) { state.vely =((1 <Exponent) - 1) * ((state.vely> 0) - (state.vely <0)); } if (abs( state.velx)> ((1 <Exponent) - 1)) { state.velx =((1 <Exponent) - 1) * ((state.velx> 0 ) – (state.velx <0)); } zustand.ballx +=zustand.velx; state.bally +=state.vely; // Ballkollisionen prüfen und checkBallCollisions beenden (game, &state, state.ballx>> game->exponent, state.bally>> game->exponent); checkBallExit(game, &state, state.ballx>> game->exponent, state.bally>> game->exponent); // Ball in neue Position ziehen drawBall(state.ballx>> game->exponent, state.bally>> game->exponent, state.ballxold>> game->exponent, state.ballyold>> game->exponent, game -> Ballgröße ); // alte Position speichern, um alte Pixel zu entfernen state.ballxold =state.ballx; zustand.ballyold =zustand.bally; // Geschwindigkeit erhöhen state.velx =(20 + (state.score>> 3 )) * ( (state.velx> 0) - (state.velx <0)); state.vely =(20 + (state.score>> 3 )) * ((state.vely> 0) – (state.vely <0)); // wenn keine Steine ​​zum nächsten Level gehen if (noBricks(game, &state) &&level lives, state->remainingLives); updateScore(Zustand->Score); setupWall(Spiel, Staat); touchToStart(); clearDialog(gameSize); updateLives(game->lives, state->remainingLives); updateScore(Zustand->Score); setupWall(game, state);}void setupStateSizes(game_type* game, game_state_type * state, Adafruit_TFTLCD &tft) { state->bottom =tft.height() - 30; state->brickwidth =tft.width() / game->columns; state->brickheight =tft.height() / 24;}void setupState(game_type* game, game_state_type * state, Adafruit_TFTLCD &tft) { setupStateSizes(game, state, tft); for (int i =0; i rows; i ++) { state->wallState[i] =0; } state->playerx =tft.width() / 2 - game->playerwidth / 2; state->remainingLives =Spiel->Leben; state->bally =state->bottom <exponent; state->ballyold =state->bottom <exponent; state->velx =game->initVelx; state->vely =game->initVely;}void updateLives(int Lives, int RestLives) { for (int i =0; i walltop =game->top + 40; state->wallbottom =state->walltop + game->rows * state->brickheight; for (int i =0; i rows; i++) { for (int j =0; j columns; j++) { if (isBrickIn(game->wall, j, i)) { setBrick (state->wallState, j, i); drawBrick(Zustand, j, i, Farben[i]); } } }}void drawBrick(game_state_type * state, int xBrick, int yBrickRow, uint16_t backgroundColor) { tft.fillRect((state->brickwidth * xBrick) + game->brickGap, state->walltop + (state->brickheight * yBrickRow) + game->brickGap , state->brickwidth - game->brickGap * 2, state->brickheight - game->brickGap * 2, backgroundColor);}boolean noBricks(game_type * game, game_state_type * state) { for ( int i =0; i rows; i++) { if (state->wallState[i]) return false; } return true;}void drawPlayer(game_type * game, game_state_type * state) { // Paint tft.fillRect(state->playerx, state->bottom, game->playerwidth, game->playerheight, YELLOW); if (state->playerx !=state->playerxold) { // alte Pixel entfernen if (state->playerx playerxold) { tft.fillRect(state->playerx + game->playerwidth, state->bottom , abs(state->playerx - state->playerxold), game->playerheight, backgroundColor); } else { tft.fillRect(state->playerxold, state->bottom, abs(state->playerx - state->playerxold), game->playerheight, backgroundColor); } }}void drawBall(int x, int y, int xold, int yold, int ballsize) { // alte Pixel entfernen //if (xold !=x &&yold !=y) { if (xold <=x &&yold <=y) { tft.fillRect(xold, yold, ballsize, y - yold, BLACK); tft.fillRect(xold , yold, x - xold, ballsize, BLACK); } else if (xold>=x &&yold>=y) { tft.fillRect (x + ballsize, yold, xold - x, ballsize, BLACK); tft.fillRect(xold , y + ballsize, ballsize, yold - y, BLACK); aufrechtzuerhalten. Sonst if (xold <=x &&yold>=y) {tft.fillRect(xold, yold, x - xold, ballsize, BLACK); tft.fillRect(xold , y + ballsize, ballsize, yold - y, BLACK); aufrechtzuerhalten. Sonst if (xold>=x &&yold <=y) {tft.fillRect(xold, yold, ballsize, y - yold, BLACK); tft.fillRect(x + ballsize, yold, xold - x, ballsize, BLACK); } // neuen Ball malen tft.fillRect(x , y, ballsize, ballsize, YELLOW); //}}void touchToStart() { drawBoxedString(0, 200, "BREAKOUT", 3, YELLOW, BLACK); drawBoxedString(0, 240, "TOUCH TO START", 2, ROT, BLACK); while (waitForTouch() <0) {}}void gameOverTouchToStart() { drawBoxedString(0, 180, "GAME OVER", 3, YELLOW, BLACK); drawBoxedString(0, 220, "TOUCH TO START", 2, ROT, BLACK); while (waitForTouch() <0) {}}void updateScore (int score) { char buffer[5]; snprintf(Puffer, Größe(Puffer), scoreFormat, score); drawBoxedString(tft.width() - 50, 6, buffer, 2, YELLOW, PRIMARY_DARK_COLOR);}void checkBrickCollision(game_type* game, game_state_type * state, uint16_t x, uint16_t y) { int x1 =x + game->ballsize; int y1 =y + Spiel->Ballgröße; int-Kollisionen =0; Kollisionen +=checkCornerCollision(game, state, x, y); Kollisionen +=checkCornerCollision(game, state, x1, y1); Kollisionen +=checkCornerCollision(game, state, x, y1); Kollisionen +=checkCornerCollision(game, state, x1, y); if (kollissionen> 0 ) { state->vely =(-1 * state->vely); if ((((x % state->brickwidth) ==0) &&( state->velx <0 )) || ((((x + game->ballsize) % state->brickwidth) ==0) &&( zustand->velx> 0 )) ) { zustand->velx =(-1 * zustand->velx); } }}int checkCornerCollision(game_type * game, game_state_type * state, uint16_t x, uint16_t y) { if ((y> state->walltop) &&(y wallbottom)) { int yBrickRow =(y - state->Wandplatte) / Zustand->Ziegelhöhe; int xBrickColumn =(x / state->brickwidth); if (isBrickIn(state->wallState, xBrickColumn, yBrickRow) ) { hitBrick(state, xBrickColumn, yBrickRow); 1 zurückgeben; } } return 0;}void hitBrick(game_state_type * state, int xBrick, int yBrickRow) { state->score +=pointsForRow[yBrickRow]; drawBrick(Zustand, xBrick, yBrickRow, WEISS); Verzögerung(16); drawBrick(state, xBrick, yBrickRow, BLUE); Verzögerung(8); drawBrick(state, xBrick, yBrickRow, backgroundColor); unsetBrick(state->wallState, xBrick, yBrickRow); updateScore(state->score);}void checkBorderCollision(game_type * game, game_state_type * state, uint16_t x, uint16_t y) { // Wandkollision prüfen if (x + game->ballsize>=tft.width()) { state ->velx =-abs(state->velx); } if (x <=0 ) { state->velx =abs(state->velx); } if (y <=SCORE_SIZE ) { state->vely =abs(state->vely); } if (((y + game->ballsize)>=state->bottom) &&((y + game->ballsize) <=(state->bottom + game->playerheight)) &&(x>=state->playerx) &&(x <=(state->playerx + game->playerwidth))) { // vel x in der Nähe der Spielergrenzen ändern if (x> (state->playerx + game->playerwidth - 6)) { state ->velx =Zustand ->velx - 1; } else if (x playerx + 6) { state->velx =state->velx + 1; } state->vely =-abs(state->vely); }}void checkBallCollisions(game_type * game, game_state_type * state, uint16_t x, uint16_t y) { checkBrickCollision(game, state, x, y); checkBorderCollision(game, state, x, y);}void checkBallExit(game_type * game, game_state_type * state, uint16_t x, uint16_t y) { if (((y + game->ballsize)>=tft.height())) { state->verbleibendeLives--; updateLives(game->lives, state->remainingLives); Verzögerung (500); state->vely =-abs(state->vely); }}void setBrick(int wall[], uint8_t x, uint8_t y) { wall[y] =wall[y] | BIT_MASK[x];}void unsetBrick(int wall[], uint8_t x, uint8_t y) { wall[y] =wall[y] &~BIT_MASK[x];}boolean isBrickIn(int wall[], uint8_t x, uint8_t y) { Rückwand[y] &BIT_MASK[x];}////////////////////////////////// ///////////////////////////// TFT-SETUP/////////////////// //////////////////////////////////////////void initTft(Adafruit_TFTLCD &tft) {tft.reset(); uint16_t ID =tft.readID(); tft.begin(ID); tft.setRotation(0);}///////////////////////////////////////// ////////////////////// Screen Painting Methoden///////////////////////// /////////////////////////////////////////////** Drucken Sie einen Text in Vorfarbe über ein ausgefülltes Feld mit Hintergrundfarbe. Die Rechteckgröße wird berechnet, um den gesamten Text ohne Ränder einzuschließen @param x horizontale Koordinate in Punkten linke obere Ecke @param y vertikale Koordinate in Punkten linke obere Ecke @param fontsize Schriftgröße des zu druckenden Textes @param foreColor Vorfarbe des zu druckenden Textes @param backgroundColor Farbe des gefüllten Rechtecks ​​@return void*/void drawBoxedString(const uint16_t x, const uint16_t y, const char* string, const uint16_t fontsize, const uint16_t foreColor, const uint16_t backgroundColor) { tft.setTextSize(fontsize); int16_t x1, y1; uint16_t w, h; tft.getTextBounds(string, x, y, &x1, &y1, &w, &h); tft.fillRect(x, y, w, h, backgroundColor); tft.setCursor(x, y); tft.setTextColor(foreColor); tft.print(string);}/** Bildschirm auf Standardhintergründe zurücksetzen @param void @return void*/void clearDialog(gameSize_type gameSize) { tft.fillRect(gameSize.x, gameSize.y, gameSize.width, gameSize .Höhe, Hintergrundfarbe); tft.fillRect(gameSize.x, gameSize.y, gameSize.width, SCORE_SIZE, PRIMARY_DARK_COLOR);}//////////////////////////// /////////////////////////////////// UI-AUSWAHL LESEN /////////// //////////////////////////////////////////////// //* Überprüft, ob der Benutzer eines der sichtbaren aktivierten UI-Elemente auswählt Der onTap-Callback des ausgewählten Elements wird aufgerufen und als gedrückt gesetzt @param lastSelected the last selection @return the new selection*/int readUiSelection(game_type * game, game_state_type * state, const int16_t lastSelected ) { int16_t xpos, ypos; //Bildschirmkoordinaten TSPoint tp =ts.getPoint(); // tp.x, tp.y sind ADC-Werte // Wenn Sie Pins teilen, müssen Sie die Richtungen der Touchscreen-Pins korrigieren pinMode (XM, OUTPUT); pinMode (YP, AUSGANG); // wir haben einen minimalen Druck, den wir für 'gültig' halten // Druck von 0 bedeutet kein Drücken! if (tp.z> MINPRESSURE &&tp.z  tft.width() / 2) { state->playerx +=2; } else { state->playerx -=2; } if (state->playerx>=tft.width() - game->playerwidth) state->playerx =tft.width() - game->playerwidth; if (state->playerx <0) state->playerx =0; 1 zurückgeben; }#ifdef DEMO_MODE state->playerx =(state->ballx>> game->exponent) - game->playerwidth / 2; if (state->playerx>=tft.width() - game->playerwidth) state->playerx =tft.width() - game->playerwidth; if (state->playerx <0) state->playerx =0;#endif return -1;}int waitForTouch() { int16_t xpos, ypos; //Bildschirmkoordinaten TSPoint tp =ts.getPoint(); // tp.x, tp.y sind ADC-Werte // Wenn Sie Pins teilen, müssen Sie die Richtungen der Touchscreen-Pins korrigieren pinMode (XM, OUTPUT); pinMode (YP, AUSGANG); // wir haben einen minimalen Druck, den wir als 'gültig' betrachten // Druck von 0 bedeutet kein Drücken! if (tp.z> MINDRUCK &&tp.z  

Schaltpläne