Ruimterace-game met behulp van het grafische display van arduino en nokia 5110

Programmeren is altijd leuk geweest en het is nu een stuk beter geworden met ontwikkelplatforms zoals Arduino. Bijna elke programmeur hier zou hebben geprobeerd een soort spel te ontwikkelen met de taal die ze leren / oefenen. Dit helpt hen om hun programmeervaardigheden op een leuke maar productieve manier af te stemmen. Ik ben een grote fan van Arduino sinds ik er kennis mee maakte en wilde er altijd iets leuks mee proberen, toen ik ontdekte hoe cool het kan worden met een grafisch LCD-scherm zoals de Nokia 5110 samen met Arduino, mijn idee om een ​​spel te ontwikkelen begon. Het was een interessante manier om een ​​paar programmeervaardigheden te verbeteren en tegelijkertijd plezier te hebben, dus hoewel jullie misschien ook geïnteresseerd zijn in het ontwikkelen van je spel. Daarom zullen we in deze tutorial leren hoe we fatsoenlijk spel kunnen maken met behulp van Arduino en grafische LCD's.

We hebben dat ouderwetse Snake-spel al gebouwd met Arduino, dus deze keer proberen we iets nieuws en we hebben dit spel Space Race Game genoemd, waarbij je je schip met een joystick moet beschermen tegen vijandelijke schepen.

Game Plan:

Voordat we beginnen, is het erg belangrijk om te plannen hoe je game echt zou werken. Ik ging met de Nokia5110 grafische LCD en joystick voor mijn hardware-selectie. Ik neem in deze tutorial aan dat je hetzelfde ook hebt geselecteerd. Omdat de Nokia 5110 niet veel ruimte heeft, hebben we ons hele spel gepland binnen de 84 * 48 pixelresolutie van ons scherm. We hebben al tutorials gemaakt over de interface van de Nokia 5110 LCD met Arduino en Joystick met Arduino.

Binnen deze ruimte moeten we goed passen in het spelgedeelte en het scorebord, waarop zaken als score en zo worden weergegeven. Het is erg belangrijk om de pixellocatie te weten waar u dingen plaatst om de pixellocaties bij te houden en deze op het scherm bij te werken.

Zodra het uiterlijk van het spelscherm is bepaald, moeten we de personages in ons spel beslissen. Voor mijn spel hebben we er maar twee, het spelerpersonage dat een ruimteschip is en een vijandelijk personage dat er ongeveer uitziet als een buitenaards ruimteschip. De Nokia LCD kan bitmapafbeeldingen weergeven, dus besloot ik die optie te gebruiken om mijn ruimteschip en de vijanden weer te geven.

Dus we zullen een ruimteschip hebben dat door de aliens-ruimteschepen racet, dit ruimteschip zal drie rijstroken hebben om te veranderen om een ​​treffer met de aliens te voorkomen. De aliens kunnen te allen tijde slechts twee sporen bezetten en de speler moet door het vrije spoor kunnen rijden. Zodra deze ideeën zijn afgerond, kunnen we doorgaan met de hardware en vervolgens met het programmeren.

Schakelschema:

Het circuit voor dit Arduino-spel is heel eenvoudig; we hoeven alleen de Nokia 5110 LCD-module en de joystick met Arduino te verbinden. Het volledige schakelschema wordt hieronder weergegeven

De Nokia 5110 LCD werkt met de 3.3V en de Joystick module werkt met 5V, dus zorg ervoor dat je de LCD alleen met 3.3V aansluit, want 5V kan het permanent beschadigen. Het LCD-scherm communiceert met Arduino via het SPI-protocol en de joystick leest alleen ADC om de verandering in spanning te lezen. De verbindingsopbouw ziet er hieronder ongeveer zo uit

Voorwaarden:

Voordat we in het programmeergedeelte duiken, is het belangrijk dat jullie handig zijn met de displaymodule en de joystick, zodat je de volgende tutorials kunt gebruiken om er meer over te weten en dan hier terug kunt komen om er zeker van te zijn dat alles werkt zoals wij heb het nodig!

• Nokia 5110 LCD-interface met Arduino
• Joystick-module die communiceert met Arduino

Arduino programmeren voor Space Race Game:

Het volledige programma voor het spel is te vinden aan het einde van deze pagina; je kunt het rechtstreeks op je Arduino IDE gebruiken en naar je bord uploaden. Maar als u wilt weten wat er werkelijk in de code gebeurt, lees dan verder.

Zoals altijd starten we ons programma met het toevoegen van onze bibliotheekkopbestanden, we hebben drie bibliotheken nodig voor dit project waarvan de SPI-bibliotheek standaard aan uw IDE wordt toegevoegd. De andere twee bibliotheken moeten worden gedownload van de Adafruit Github-pagina. Volg de handleiding voor LCD-interfacing die wordt vermeld in het gedeelte met vereisten als u niet zeker weet hoe u de bibliotheek moet toevoegen.

# omvatten // SPI librarey voor communicatie #include // Grafische lib voor LCD #include // Nokia 5110 LCD- bibliotheek

Als u de tutorial heeft gevolgd, moet u weten dat het mogelijk is om de bitmapafbeeldingen op het LCD-scherm weer te geven. Dus we moeten de vereiste afbeelding converteren naar bitmapcode met behulp van software die in de tutorial wordt genoemd, je kunt elke afbeelding van internet selecteren en deze gebruiken door ze naar bitmapcode te converteren. Zorg ervoor dat de afbeelding eenvoudig genoeg is om op ons LCD-scherm te worden weergegeven, controleer het voorbeeld voordat u het daadwerkelijk op het LCD-scherm probeert. In ons programma hebben we twee bitmap-tekens gebruikt, de ene is het ruimteschip en de andere is het vijandelijke schip, de bitmapcode voor beide is in onze code toegevoegd zoals hieronder weergegeven.

// Bitmap Gegevens voor SpaceShip static const unsigned char PROGMEM schip = { B00000000, B00000000, B00000001, B00000000, B00000011, B10000000, B00000010, B10000000, B00000010, B11000000, B00000111, B11000000, B00001101, B11100000, B00011111, B11110000, B00111111, B11111000, B01111111, B11111100, B01111111, B11111100, B01111111, B11111100, B00011111, B11110000, B00000111, B11100000, B00000000, B00000000, }; // Bitmapgegevens voor vijandschap statische const unsigned char PROGMEM vijand = { B00000101, B11000000, B00001011, B11100000, B00000011, B11100000, B00110011, B11111000, B01111111, B11111100, B10111111, B11111010, B01110111, B11011100, B01111110, B11111100, B00111111, B11111100, B11101111, B11101110, B11000001, B00000110, B10000001, B0000, B0000, B0000, B0000, B0000, B0000, B0000, B0000 }

We moeten de pinnen specificeren waarop het Nokia LCD 5110-display is aangesloten. Het display wordt gecommuniceerd met behulp van de SPI-communicatie, als u het bovenstaande schakelschema hebt gevolgd, is de code om het LCD-scherm te initialiseren als volgt, u hoeft deze niet te wijzigen.

Adafruit_PCD8544 display = Adafruit_PCD8544 (7, 6, 5, 4, 3); // Specificeer de pinnen waarop het LCD-scherm is aangesloten

Binnen de setup- functie starten we gewoon de seriële monitor op 9600 baudrate, zodat we dingen kunnen debuggen en vervolgens het LCD-scherm initialiseren. We moeten ook het contrast van het LCD-scherm instellen, elk scherm werkt het beste in een ander contrastniveau, dus speel met de waarde om te kijken welke het beste bij je past. Ten slotte maken we ook het scherm leeg om opnieuw te beginnen.

void setup () { Serial.begin (9600); // Seriële monitor voor foutopsporing display.begin (); // Begin met het LCD-communicatiedisplay. SetContrast (30); // Stel het contrast van het display in display.clearDisplay (); // wist het scherm en start nieuw }

Zodra het scherm leeg is, springen we in de loop- functie en daar laten we het spelscherm zien. Het spelscherm is niets anders dan een basisskelet voor het spel, samen met de score en het snelheidsniveau. We hebben de lijnfunctie gebruikt om drie lijnen als grenzen te tekenen en aan de rechterkant geven we de tekstscore en snelheid weer, net als de oude retro draagbare spelapparaten.

void gamescreen () { // Teken de rand voor schermweergave.drawLine (0, 0, 0, 47, ZWART); display.drawLine (50, 0, 50, 47, ZWART); display.drawLine (0, 47, 50, 47, ZWART); // Voer standaardteksten in display.setTextSize (1); display.setTextColor (ZWART); display.setCursor (52,2); display.println ("Snelheid"); display.setCursor (54,12); display.println (game_speed); display.setCursor (52,25); display.println ("Score"); display.setCursor (54,35); display.println (partituur); }

Vervolgens moeten we de input van de gebruiker krijgen om hem / haar in staat te stellen het ruimteschip te besturen. De input wordt ontvangen van de Joystick-module die is aangesloten op pin A1. De analoge waarde van de sensor is 512 als deze niet wordt bewogen en zal toenemen en afnemen als deze langs de X-as wordt bewogen. We gebruiken deze waarden om te bepalen of de gebruiker naar links of naar rechts wil gaan. U moet de Joystick-interface met Arduino-tutorial lezen die wordt genoemd in de vereisten als u het onderstaande programma moeilijk begrijpt.

// Krijg input van gebruiker Joy_X = analogRead (A1); // Lees de waarde X van Joystick if (Joy_X <312 && POS! = 1 && control == true) // Als joystick naar rechts beweegt {POS--; control = false;} // Positie van ruimteschip verlagen else if (Joy_X> 712 && POS! = 3 && control == true) // Als joystick naar rechts beweegt {POS ++; control = false;} // Verhogen positie van ruimteschip else if (Joy_X> 502 && Joy_X <522) // If joystick terug naar oorspronkelijke positie control = true; // Bereid het voor op de volgende zet // Invoer van de gebruiker ontvangen

Nadat we de positie van het ruimteschip van de gebruiker hebben gekregen, moeten we het ruimteschip op die specifieke plaats plaatsen. We gebruiken de onderstaande functie en geven de waarde van positie als parameter door, en vervolgens op basis van de positie waarin het ruimteschip in zijn respectieve track wordt geplaatst.

void player_car (char pos) // Plaats het ruimteschip op basis van de door de gebruiker geselecteerde positie { if (pos == 1) display.drawBitmap (2, 32, ship, 15, 15, BLACK); if (pos == 2) display.drawBitmap (18, 32, schip, 15, 15, ZWART); if (pos == 3) display.drawBitmap (34, 32, schip, 15, 15, ZWART); }

Nu ons ruimteschip op het scherm is geplaatst en klaar is om te racen, moeten we de vijandelijke schepen introduceren die samen met de speler zullen strijden. Elke keer dat een vijandelijk schip het scherm is overgestoken, nemen we aan dat hij dood is en als hij dood is, moeten we een nieuw ruimteschip maken. De onderstaande functie doet precies hetzelfde. Het creëert een nieuwe positie voor twee vijandelijke schepen en plaatst ze bovenaan het scherm.

if (vijand_dead) // Controleer of vijandelijke schepen dood zijn {// Als ze dood zijn vijand_0_pos = POS; // creëer eerste vijand boven het ruimteschip vijand_1_pos = random (0,4); // creëer een tweede vijand op een andere willekeurige plaats vijand_phase = 0; // Breng de vijand uit de top vijand_dead = false; // Vijand is gemaakt zodat ze niet meer dood zijn }

Nadat we de vijandelijke schepen bovenaan het scherm hebben geplaatst, moeten we het naar beneden halen zodat het lijkt alsof onze speler naar boven racet, om dat te doen, hoeven we alleen de fase (de plaats waar de afbeelding wordt weergegeven) te verhogen, zodat het komt langzaam naar beneden. Hetzelfde wordt gedaan voor beide vijandelijke schepen zoals hieronder getoond

vijand_schip (vijand_0_pos, vijand_fase); vijand_fase ++; // Plaats de eerste vijand op het scherm en drijf hem vijand_schip neer (vijand_1_pos, vijand_fase); vijand_fase ++; // Plaats de tweede vijand op het scherm en drijf hem neer

De functie vijand_schip wordt hieronder getoond, het lijkt erg op de speler auto-functie, maar hier hebben we twee parameters. De ene is om de vijand op een spoor te plaatsen en de andere is om de vijand naar de bodem te verplaatsen.

void vijand_ship (int place, int phase) // Plaats de vijand_ship in de nieuwe plaats en fase { if (place == 1) display.drawBitmap (2, fase, vijand, 15, 15, ZWART); if (plaats == 2) display.drawBitmap (18, fase, vijand, 15, 15, ZWART); if (plaats == 3) display.drawBitmap (34, fase, vijand, 15, 15, ZWART); }

Het volgende stuk code moet controleren of het ruimteschip het vijandelijke schip heeft ontweken. Om dit te controleren, moeten we de positie van vijandelijke schepen en het ruimteschip van de speler kennen. Omdat we alles weten, hoeven we alleen maar te controleren of de positie van het ruimteschip hetzelfde is als het vijandelijke schip. We controleren dit alleen als het vijandelijke schip het ruimteschip heeft bereikt. Als de speler de vijand niet heeft ontweken, betekent dit game over.

if (vijand_fase> 22 && ((vijand_0_pos == POS) - (vijand_1_pos == POS))) // Als het ruimteschip een van de vijandelijke game_over () aanraakt; // Geef game over

Als de speler de vijand met succes heeft ontweken, moeten we de vijand doden en de speler een punt geven. Om dit te doen, controleren we of de vijand de onderkant van het scherm heeft bereikt en als dat het geval is, doden we hem met behulp van de onderstaande code

if (vijand_fase> 40) // Als het ruimteschip ontsnapt aan de vijanden {vijand_dead = true; score ++;} // Verhoog de score en dood de vijanden

Wat zou het leuk zijn als we de moeilijkheidsgraad van het spel niet verhogen naarmate we hoge scores halen. We gebruiken dus een andere functie die vervolgens de score van de speler controleert en op basis van de score de snelheid van het spel verhoogt. De snelheid wordt feitelijk geregeld door de vertragingsfunctie te gebruiken, deze regelt het verversingsinterval van het spel en maakt het dus snel of langzaam.

void Level_Controller () // Verhoog de snelheid van het spel op basis van de score. { if (score> = 0 && score <= 10) // If score 0-10 { game_speed = 0; vertraging (80); // vertraag het spel met 80 ms } if (score> 10 && score <= 20) // If score 10-40 { game_speed = 1; vertraging (70); // vertraag het spel met 70 ms } if (score> 20 && score <= 30) // If score 20-40 { game_speed = 2; vertraging (60); // vertraag het spel met 60 ms } if (score> 30 && score <= 40) // If score 30-40 { game_speed = 3; vertraging (50); // vertraag het spel met 50 ms } }

Arduino Space Racer Game werkt:

Nadat u zeker weet dat de hardware en het programma begrepen zijn, bouwt u gewoon het circuit en uploadt u de code naar het Arduino-bord. Je zou moeten opmerken dat het spel begint, zoals hieronder wordt weergegeven

Gebruik de joystick om aan het vijandelijke schip te ontsnappen door naar links of rechts te bewegen. Om elke vijand te ontwijken, wordt je score met één verhoogd. Als de score hoog wordt, zal de snelheid van het spel ook toenemen, dat is de snelheidstoename met 10 ms voor elke 10 punten die je scoort. Je kunt doorgaan en op dit spel voortbouwen om nieuwe niveaus te introduceren of elk wat hardwarewijzigingen aanbrengen om het door beweging te besturen met behulp van een versnellingsmeter. Creativiteit is de enige limiet. Ter referentie leer je hier Accelerometer met Arduino gebruiken.

Ik hoop dat je het project hebt begrepen en met plezier hebt gebouwd. Als je problemen hebt ondervonden om dit te laten werken, kun je het probleem posten in de commentaarsectie hieronder of de forums gebruiken voor technische hulp. Veel plezier met gamen !!

Bekijk de volledige code en de demonstratievideo hieronder.