- Piano di gioco:
- Schema elettrico:
- Prerequisiti:
- Programmazione di Arduino per Space Race Game:
- Gioco Arduino Space Racer funzionante:
La programmazione è sempre stata divertente ed è migliorata molto con piattaforme di sviluppo come Arduino. Quasi tutti i programmatori qui fuori avrebbero provato a sviluppare un qualche tipo di gioco usando il linguaggio che stanno imparando / praticando. Questo li aiuta a mettere a punto le loro capacità di programmazione in modo divertente ma produttivo. Sono stato un grande fan di Arduino da quando ci sono stato presentato e ho sempre voluto provare qualcosa di interessante con esso, quando ho scoperto quanto può essere bello con un LCD grafico come Nokia 5110 insieme ad Arduino la mia idea di sviluppare un gioco È stato un modo interessante per mettere a punto poche abilità di programmazione e divertirsi allo stesso tempo, quindi anche se voi ragazzi potreste essere interessati allo sviluppo del vostro gioco. Quindi in questo tutorial impareremo come creare un gioco decente usando Arduino e LCD grafici.
Abbiamo già costruito quel vecchio gioco Snake usando Arduino, quindi questa volta stiamo provando qualcosa di nuovo e abbiamo chiamato questo gioco come Space Race Game in cui devi tenere la tua nave al sicuro dalle navi nemiche usando il joystick.
Piano di gioco:
Prima di iniziare, è molto importante pianificare come funzionerebbe effettivamente il gioco. Ho scelto il display LCD grafico e il joystick Nokia5110 per la mia selezione hardware. Presumo in questo tutorial che tu abbia anche selezionato lo stesso. Poiché il Nokia 5110 non ha molto spazio, abbiamo pianificato l'intero gioco all'interno della risoluzione di 84 * 48 pixel del nostro display. Abbiamo già realizzato tutorial su come interfacciare LCD Nokia 5110 con Arduino e Joystick con Arduino.
All'interno di questo spazio dobbiamo adattarsi strettamente all'area di gioco e all'area del tabellone segnapunti che mostrerà cose come punteggio e cose del genere. È molto importante conoscere la posizione dei pixel in cui si posizionano gli elementi per tenere traccia delle posizioni dei pixel e aggiornarli sullo schermo.
Una volta deciso l'aspetto della schermata di gioco, dobbiamo decidere i personaggi nel nostro gioco. Per il mio gioco ne abbiamo solo due, il personaggio del giocatore che è un'astronave e un personaggio nemico che dovrebbe assomigliare a un'astronave aliena. Il Nokia LCD può visualizzare immagini bitmap, quindi ho deciso di utilizzare questa opzione per visualizzare la mia nave spaziale ei nemici.
Quindi avremo una nave spaziale che sta correndo attraverso le astronavi aliene, questa astronave avrà tre corsie da cambiare per evitare un colpo con gli alieni. In ogni momento gli alieni possono occupare solo due tracce e il giocatore dovrebbe essere in grado di guidare attraverso la pista libera. Una volta concluse queste idee si può procedere con l'hardware e poi con la programmazione.
Schema elettrico:
Il circuito per questo gioco Arduino è molto semplice; non ci resta che interfacciare il modulo LCD del Nokia 5110 e il Joystick con Arduino. Lo schema elettrico completo è mostrato di seguito
Il Nokia 5110 LCD funziona con 3,3 V e il modulo Joystick funziona con 5 V, quindi assicurati di collegare l'LCD solo con 3,3 V, perché 5 V potrebbe danneggiarlo in modo permanente. Il display LCD comunica con Arduino tramite protocollo SPI e il Joystick legge solo l'ADC per leggere la variazione di tensione. La configurazione della connessione sarà simile a questa di seguito
Prerequisiti:
Prima di immergerci nella parte di programmazione è importante che tu stia bene con il modulo Display e il Joystick, in modo che tu possa utilizzare i seguenti tutorial per saperne di più su di loro e poi tornare qui per assicurarti che le cose funzionino come noi ne ho bisogno!
- Interfaccia LCD del Nokia 5110 con Arduino
- Modulo joystick interfacciabile con Arduino
Programmazione di Arduino per Space Race Game:
Il programma completo del gioco si trova alla fine di questa pagina; puoi usarlo direttamente sul tuo IDE Arduino e caricarlo sulla tua Board. Ma se vuoi sapere cosa succede effettivamente all'interno del codice, leggi oltre.
Come sempre, iniziamo il nostro programma aggiungendo i nostri file di intestazione della libreria, abbiamo bisogno di tre librerie per questo progetto, di cui la libreria SPI viene aggiunta al tuo IDE per impostazione predefinita. Le altre due librerie devono essere scaricate dalla pagina Github di Adafruit. Se non sei sicuro di come aggiungere la libreria, segui il tutorial sull'interfacciamento LCD menzionato nella sezione dei prerequisiti.
#includere
Se hai seguito il tutorial dovresti sapere che è possibile visualizzare le immagini bitmap nell'LCD. Quindi dobbiamo convertire l'immagine richiesta in codice bitmap utilizzando il software menzionato nel tutorial, puoi selezionare qualsiasi immagine da Internet e usarla convertendola in codice bitmap. Assicurati che l'immagine sia abbastanza semplice da essere visualizzata sul nostro schermo LCD, controlla l'anteprima prima di provare effettivamente sullo schermo LCD. Nel nostro programma abbiamo usato due caratteri bitmap uno è l'astronave e l'altro è la nave nemica, il codice bitmap per entrambi è aggiunto nel nostro codice come mostrato di seguito.
// Bitmap dati per SpaceShip statico const char unsigned nave PROGMEM = { 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, }; // Dati bitmap per il carattere statico non firmato della nave nemica PROGMEM nemico = { B00000101, B11000000, B00001011, B11100000, B00000011, B11100000, B00110011, B11111000, B01111111, B11111100, B10111111, B11111010, B01110111, B11011100, B01111110, B11111100, B00111111, B11111100, B11101111, B11101110, B11000001, B00000110, B10000001, B00000010, B10000000, B00000010, B00000000, B00000000, };
Dobbiamo specificare i pin a cui è collegato il display LCD 5110 del Nokia. Il display viene comunicato utilizzando la comunicazione SPI, se si è seguito lo schema del circuito sopra, il codice per inizializzare il display LCD sarà il seguente, non è necessario modificarlo.
Display Adafruit_PCD8544 = Adafruit_PCD8544 (7, 6, 5, 4, 3); // Specifica i pin a cui è collegato l'LCD
All'interno della funzione di configurazione avviamo il monitor seriale a 9600 baud rate in modo da poter eseguire il debug delle cose e quindi inizializzare il display LCD. Dobbiamo anche impostare il contrasto del display LCD, ogni display funzionerà al meglio con un diverso livello di contrasto, quindi gioca con il valore per verificare quale si adatta meglio a te. Infine cancelliamo anche lo schermo del display per ricominciare da capo.
void setup () { Serial.begin (9600); // Monitor seriale per il debug di display.begin (); // Inizia la comunicazione LCD display.setContrast (30); // Imposta il contrasto del display display.clearDisplay (); // cancella lo schermo e inizia una nuova }
Non appena lo schermo viene cancellato, passiamo alla funzione loop e lì mostriamo la schermata di gioco. La schermata di gioco non è altro che che mostra uno scheletro di base per il gioco insieme al punteggio e al livello di velocità. Abbiamo utilizzato la funzione linea per disegnare tre linee come bordi ea destra mostriamo il punteggio del testo e la velocità proprio come i vecchi dispositivi di gioco portatili retrò.
void gamescreen () { // Disegna il bordo per lo schermo display.drawLine (0, 0, 0, 47, BLACK); display.drawLine (50, 0, 50, 47, NERO); display.drawLine (0, 47, 50, 47, NERO); // Immettere i testi predefiniti display.setTextSize (1); display.setTextColor (NERO); display.setCursor (52,2); display.println ("Speed"); display.setCursor (54,12); display.println (game_speed); display.setCursor (52,25); display.println ("Punteggio"); display.setCursor (54,35); display.println (punteggio); }
Successivamente dobbiamo ottenere l'input dall'utente per consentirgli di controllare la nave spaziale. L'input verrà ricevuto dal modulo Joystick che è collegato al pin A1. Il valore analogico del sensore sarà 512 se non viene spostato e aumenterà e diminuirà quando viene spostato lungo l'asse X. Utilizziamo questi valori per determinare se l'utente desidera spostarsi a sinistra oa destra. Dovresti leggere il tutorial sull'interfacciamento del joystick con Arduino menzionato nei prerequisiti se hai difficoltà a capire il programma seguente.
// Ricevi input dall'utente Joy_X = analogRead (A1); // Leggi il valore X dal Joystick if (Joy_X <312 && POS! = 1 && control == true) // Se il joystick si muove a destra {POS--; control = false;} // Decrementa la posizione dell'astronave else if (Joy_X> 712 && POS! = 3 && control == true) // Se il joystick si sposta a destra {POS ++; control = false;} // Incrementa la posizione dell'astronave else if (Joy_X> 502 && Joy_X <522) // Se il joystick torna alla posizione iniziale control = true; // Preparalo per la prossima mossa // Input dall'utente ricevuto
Dopo aver ottenuto la posizione dell'astronave dall'utente, dobbiamo posizionare l'astronave in quel particolare luogo. Usiamo la seguente funzione e passiamo il valore della posizione come parametro, quindi in base alla posizione in cui l'astronave è posizionata nella rispettiva traccia.
void player_car (char pos) // Posiziona l'astronave in base alla posizione selezionata dall'utente { if (pos == 1) display.drawBitmap (2, 32, ship, 15, 15, BLACK); if (pos == 2) display.drawBitmap (18, 32, ship, 15, 15, BLACK); if (pos == 3) display.drawBitmap (34, 32, ship, 15, 15, BLACK); }
Ora che la nostra astronave è posizionata sullo schermo ed è pronta per la corsa, dobbiamo introdurre le navi nemiche che gareggeranno insieme al giocatore. Ogni volta che una nave nemica ha attraversato lo schermo, diamo per scontato che sia morto e quando è morto dobbiamo creare una nuova astronave. La funzione seguente fa lo stesso. Crea una nuova posizione per due navi nemiche e le posiziona nella parte superiore dello schermo.
if (nemico_dead) // Il controllo delle navi nemiche sono morte {// Se sono morte nemico_0_pos = POS; // crea il primo nemico sopra l'astronave nemico_1_pos = random (0,4); // crea un nemico nascosto in qualche altro posto casuale nemico_phase = 0; // Porta il nemico in alto nemico_dead = false; // Il nemico è stato creato in modo che non siano più morti }
Dopo aver posizionato le navi nemiche nella parte superiore dello schermo dobbiamo abbassarlo in modo che lanci come se il nostro giocatore stesse correndo verso l'alto, per farlo dobbiamo solo aumentare la fase (il luogo in cui viene visualizzata l'immagine) scende lentamente. Lo stesso viene fatto per entrambe le navi nemiche come mostrato di seguito
nemic_ship (nemico_0_pos, nemico_phase); nemico_fase ++; // Posiziona il primo nemico sullo schermo e guidalo verso il basso nemico_ship (nemico_1_pos, nemico_phase); nemico_fase ++; // Posiziona il nemico nascosto sullo schermo e abbattilo
La funzione nemico_ship è mostrata di seguito, è molto simile alla funzione macchina del giocatore ma qui abbiamo due parametri. Uno è per posizionare il nemico su una pista e l'altro è per spostare il nemico verso il fondo.
void nemico_ship (int place, int phase) // Posiziona nemico_ship nel nuovo luogo e fase { if (place == 1) display.drawBitmap (2, phase, nemico, 15, 15, BLACK); if (luogo == 2) display.drawBitmap (18, fase, nemico, 15, 15, NERO); if (luogo == 3) display.drawBitmap (34, fase, nemico, 15, 15, NERO); }
Il pezzo di codice successivo dovrebbe verificare se la nave spaziale ha evitato la nave nemica. Per verificarlo dobbiamo conoscere la posizione delle navi nemiche e dell'astronave del giocatore. Dato che sappiamo tutto ciò, dobbiamo solo controllare se la posizione della nave spaziale è uguale a quella della nave nemica. Controlliamo questo solo se la nave nemica ha raggiunto vicino alla nave spaziale. Se il giocatore non ha evitato il nemico significa che il gioco è finito.
if (nemico_phase> 22 && ((nemico_0_pos == POS) - (nemico_1_pos == POS))) // Se l'astronave tocca uno qualsiasi dei nemici game_over (); // Mostra il gioco finito
Se il giocatore ha evitato il nemico con successo, allora dovremmo uccidere il nemico e dare al giocatore un punto. Per farlo controlliamo solo se il nemico è arrivato in fondo allo schermo e se lo fa lo uccidiamo usando il codice sottostante
if (nemico_phase> 40) // Se la nave spaziale sfugge ai nemici {nemico_dead = true; score ++;} // Aumenta il punteggio e uccidi i nemici
Che divertimento sarebbe se non aumentassimo la difficoltà del gioco man mano che otteniamo punteggi più alti. Quindi usiamo un'altra funzione che monitora il punteggio del giocatore e in base al punteggio aumenterà la velocità del gioco. La velocità è effettivamente controllata utilizzando la funzione di ritardo che controllerà l'intervallo di aggiornamento del gioco rendendolo così veloce o lento.
void Level_Controller () // Aumenta la velocità del gioco in base al punteggio. { if (score> = 0 && score <= 10) // If punteggio 0-10 { game_speed = 0; ritardo (80); // rallenta il gioco di 80 ms } if (punteggio> 10 && punteggio <= 20) // If punteggio 10-40 { game_speed = 1; ritardo (70); // rallenta il gioco di 70 ms } if (punteggio> 20 && punteggio <= 30) // If punteggio 20-40 { game_speed = 2; ritardo (60); // rallenta il gioco di 60 ms } if (punteggio> 30 && punteggio <= 40) // If punteggio 30-40 { game_speed = 3; ritardo (50); // rallenta il gioco di 50 ms } }
Gioco Arduino Space Racer funzionante:
Dopo esserti assicurato che l'hardware e il programma siano compresi, crea il circuito e carica il codice sulla scheda Arduino. Dovresti notare che il gioco si avvia come mostrato di seguito
Usa il joystick per sfuggire alla nave nemica muovendoti a sinistra oa destra. Per evitare ogni nemico aumenterai il tuo punteggio di uno. Quando il punteggio aumenta, aumenta anche la velocità del gioco, ovvero l'aumento della velocità di 10 ms per ogni 10 punti che ottieni. Puoi andare avanti e costruire su questo gioco per introdurre nuovi livelli o apportare alcune modifiche hardware per controllarlo attraverso il movimento usando un accelerometro. La creatività è l'unico limite. Come riferimento impari a usare l'accelerometro con Arduino qui.
Spero che tu abbia capito il progetto e ti sia piaciuto realizzarlo. Se hai riscontrato problemi nel farlo funzionare, sentiti libero di pubblicare il problema nella sezione commenti qui sotto o usa i forum per assistenza tecnica. Buon gioco !!
Controlla il codice completo e il video dimostrativo di seguito.