Floppy Bird : 3 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:05

Aujourd'hui, nous allons créer un jeu en utilisant un écran LCD TFT. Cela ressemblerait à un jeu très populaire et beaucoup de gens jouent encore à ce jeu. Le jeu s'appelle Flappy Bird mais ce jeu est un peu différent car l'interface utilisateur est différente ainsi que la façon dont le jeu fonctionne. J'ai appelé ce jeu Floppy Bird car cela pourrait entraîner des problèmes de droits d'auteur. Néanmoins, c'est un jeu vraiment amusant et il est facile à faire. J'ai fait cette instructable qui vous permettra de faire le jeu complètement et de le faire fonctionner comme je l'ai fait. Si vous avez des questions, veuillez commenter ci-dessous et j'essaierai de répondre à ces questions le plus rapidement possible.

Fournitures

- Arduino Mega 2560 et câble

- Arduino Mega Shield

- Arduino TFT LCD Compatible avec l'Arduino Mega 2560

- Carte SD

Étape 1: Assemblage de l'écran LCD TFT

Maintenant, nous pouvons commencer à assembler l'écran LCD TFT. Nous allons connecter l'écran LCD TFT au blindage, alors prenez d'abord l'écran LCD TFT et alignez-le essentiellement avec les broches du blindage. Une fois que vous avez aligné les broches, poussez l'écran LCD TFT vers le bas pour qu'il soit en place. Lorsque toutes les têtes d'épingle sont dans le blindage et que vous ne pouvez pas voir les têtes d'épingle, c'est à ce moment-là que vous savez que l'écran LCD TFT est correctement connecté. Ensuite, nous pouvons brancher le blindage sur l'Arduino Mega 2560. Alignez les broches du blindage sur l'Arduino Mega et branchez-le. Lorsque toutes les têtes de broche sont dans l'Arduino Mega et que vous ne pouvez pas voir les têtes de broche, c'est lorsque vous savez que l'écran LCD TFT est correctement connecté et qu'il est prêt à être allumé. Branchez l'Arduino pour voir si vous avez correctement connecté l'écran LCD, si l'écran LCD s'allume et que l'écran est blanc, alors félicitations, vous avez connecté avec succès l'écran LCD TFT et il est maintenant prêt à être programmé. Enfin, nous n'avons qu'une chose à faire, qui est de connecter la carte SD dans l'écran LCD. À l'arrière de l'écran LCD TFT, il y a un emplacement pour carte SD où vous pouvez simplement brancher la carte SD. Par conséquent, il suffit de le brancher et c'est fait.

Étape 2: Programmation de l'écran LCD TFT

Maintenant, nous allons programmer l'écran LCD pour qu'il lance le jeu et que nous puissions y jouer. Vous trouverez ci-dessous le code que vous devez compiler et télécharger à l'aide de l'IDE Arduino.

Problèmes que vous pourriez avoir:

Modifiez les paramètres de l'écran LCD TFT en fonction du modèle que vous possédez.

CODE COMPLET:

#include #include #include

//==== Création d'objets

UTFT monGLCD(ILI9341_16, 38, 39, 40, 41); //Les paramètres doivent être ajustés à votre modèle d'écran/bouclier URTouch myTouch(6, 5, 4, 3, 2);

//==== Définition des polices

extern uint8_t SmallFont; extern uint8_t BigFont; extern uint8_t SevenSegNumFont;

externe non signé int bird01[0x41A]; // Bitmap Oiseau

entier x, y; // Variables pour les coordonnées où l'affichage a été appuyé

// Disquette Oiseau

entier xP = 319; entier yP = 100; entier yB = 50; int MovingRate = 3; int FallRateInt = 0; taux de chute flottant = 0; score entier = 0; int lastSpeedUpScore = 0; int score le plus élevé; booléen screenPressed = false; booléen gameStarted = false;

void setup() {

// Lancer l'affichage monGLCD. InitLCD(); monGLCD.clrScr(); monTouche. InitTouch(); myTouch.setPrecision(PREC_MEDIUM); score le plus élevé = EEPROM.read(0); // Lit le score le plus élevé de l'EEPROM initiateGame(); // Lancer le jeu }

boucle vide() {

xP=xP-mouvementTaux; // xP - coordonnée x des piliers; plage: 319 - (-51) drawPilars(xP, yP); // Dessine les piliers // yB - coordonnée y de l'oiseau qui dépend de la valeur de la variable FallRate yB+=fallRateInt; taux de chute=taux de chute+0,4; // A chaque intégration, le taux de chute augmente afin que nous puissions l'effet de l'accélération/de la gravité fallRateInt= int(fallRate); // Vérifie la collision if(yB>=180 || yB<=0){ // top et bottom gameOver(); } if((xP=5) && (yB<=yP-2)){ // pilier supérieur gameOver(); } if((xP=5) && (yB>=yP+60)){ // pilier inférieur gameOver(); } // Dessine l'oiseau drawBird(yB);

// Après que le pilier a traversé l'écran

if (xPRESET=250) && (x=0) && (y=0) && (x=30) && (y=270){ myGLCD.setColor(0, 200, 20); monGLCD.fillRect(318, 0, x, y-1); monGLCD.setColor(0, 0, 0); monGLCD.drawRect(319, 0, x-1, y);

monGLCD.setColor(0, 200, 20);

monGLCD.fillRect(318, y+81, x, 203); monGLCD.setColor(0, 0, 0); monGLCD.drawRect(319, y+80, x-1, 204); } else if(x<=268) { // Dessine un rectangle bleu à droite du pilier myGLCD.setColor(114, 198, 206); monGLCD.fillRect(x+51, 0, x+60, y); // Dessine le pilier myGLCD.setColor(0, 200, 20); monGLCD.fillRect(x+49, 1, x+1, y-1); // Dessine le cadre noir du pilier myGLCD.setColor(0, 0, 0); monGLCD.drawRect(x+50, 0, x, y); // Dessine le rectangle bleu à gauche du pilier myGLCD.setColor(114, 198, 206); monGLCD.fillRect(x-1, 0, x-3, y);

// Le pilier du bas

monGLCD.setColor(114, 198, 206); monGLCD.fillRect(x+51, y+80, x+60, 204); monGLCD.setColor(0, 200, 20); monGLCD.fillRect(x+49, y+81, x+1, 203); monGLCD.setColor(0, 0, 0); monGLCD.drawRect(x+50, y+80, x, 204); monGLCD.setColor(114, 198, 206); monGLCD.fillRect(x-1, y+80, x-3, 204); } // Dessine la partition myGLCD.setColor(0, 0, 0); monGLCD.setBackColor(221, 216, 148); monGLCD.setFont(BigFont); monGLCD.printNumI(score, 100, 220); }

//====== drawBird() - Fonction personnalisée

void drawBird(int y) { // Dessine l'oiseau - bitmap myGLCD.drawBitmap (50, y, 35, 30, bird01); // Dessine des rectangles bleus au-dessus et au-dessous de l'oiseau afin d'effacer son état précédent myGLCD.setColor(114, 198, 206); monGLCD.fillRoundRect(50, y, 85, y-6); monGLCD.fillRoundRect(50, y+30, 85, y+36); } //======== gameOver() - Fonction personnalisée void gameOver() { delay(3000); // 1 seconde // Efface l'écran et imprime le texte myGLCD.clrScr(); monGLCD.setColor(255, 255, 255); monGLCD.setBackColor(0, 0, 0); monGLCD.setFont(BigFont); monGLCD.print("GAME OVER", CENTRE, 40); monGLCD.print("Score:", 100, 80); monGLCD.printNumI(score, 200, 80); monGLCD.print("Redémarrage…", CENTRE, 120); monGLCD.setFont(SevenSegNumFont); monGLCD.printNumI(2, CENTRE, 150); retard(1000); monGLCD.printNumI(1, CENTRE, 150); retard(1000); // Écrit le score le plus élevé dans l'EEPROM if (score > highScore) { highScore = score; EEPROM.write(0, score le plus élevé); } // Réinitialise les variables pour démarrer les valeurs de position xP=319; yB=50; taux de chute=0; note = 0; lastSpeedUpScore = 0; tauxmouvement = 3; gameStarted = false; // Redémarrer le jeu initiateGame(); }

Étape 3: Terminé

Nous avons fait le circuit et compilé le code. Maintenant, nous n'avons plus qu'à brancher le méga Arduino et jouer au jeu.

Ici, j'ai un lien vers une vidéo qui montre comment fonctionne ce jeu et ce qu'il faut faire pour le configurer:

drive.google.com/file/d/18hKQ8v2w2OkM_std-…

Faites-moi savoir si vous avez des problèmes ci-dessous.