Progetto Arduino: videogame “Asteroid Shooter”

Pubblicato il Aggiornato il di giacomoCategorie:Arduino

Impugna il joystick e difendi la Terra dalla pioggia di asteroidi che appaiono rapidi e imprevedibili sullo schermo.

Versione 1.0 (“Target: 50”)

Strumenti

  • Arduino UNO
  • Matrice LED 8×8
  • Modulo joystick a doppio asse
  • Cavi elettrici e resistenze

I quadratini rossi, che rappresentano gli asteroidi, appaiono in maniera aleatoria in corrispondenza degli 8 punti cardinali della matrice LED. Direzionando il joystick contro un asteroide, lo si disintegra (il quadratino si spegne). Ogni 5 asteroidi abbattuti, la frequenza di apparizione di nuovi asteroidi aumenta. Lo scopo del gioco è disintegrare quanti più asteroidi possibile prima che siano presenti contemporaneamente 7 asteroidi sullo schermo. In tal caso, scorre la scritta “GAME OVER” e viene visualizzato il numero di asteroidi abbattuti, seguito da uno smiley che sorride se questo numero è pari almeno a 50.

Diagramma dei collegamenti

Codice

Clicca qui per visualizzare
#include "LedControl.h"

const int SW_pin = 2;
const int X_pin = 0;
const int Y_pin = 1;

int c = 700; // delay iniziale tra un asteroide e l’altro
int difficolta = 150; // riduzione del delay quando aumenta la difficoltà
long last = 0;
int level = 0; // numero di asteroidi abbattuti
int asteroidi = 0; // numero di asteroidi presenti
int lista[8] = {0, 0, 0, 0, 0, 0, 0, 0}; // memorizza quali asteroidi sono presenti

LedControl lc=LedControl(12,10,11,1);

void setup() {

  pinMode(SW_pin, INPUT);
  digitalWrite(SW_pin, HIGH);
  lc.shutdown(0,false);
  lc.setIntensity(0,8);
  lc.clearDisplay(0);
 
}

void writeGameOver() {

  byte a[]={B00000000, B00111110, B01000001, B01001001, B01111010, B00000000, // G
              B00000000, B01111110, B00010001, B00010001, B01111110, B00000000, // A
              B00000000, B01111111, B00000010, B00001100, B00000010, B01111111, B00000000, // M
              B00000000, B01111111, B01001001, B01001001, B01000001, B00000000, // E
              B00000000,B00000000,B00000000,B00000000,B00000000,B00000000, //
              B00000000, B00111110, B01000001, B01000001, B00111110, B00000000, // O
              B00000000, B00001111, B00110000, B01000000, B00110000, B00001111, B00000000, // V
              B00000000, B01111111, B01001001, B01001001, B01000001, B00000000, // E
              B00000000, B01111111, B00001001, B00001001, B01110110, B00000000, B00000000 // R
             };

  for(int i=0; i<=49; i+=1) {
  lc.setRow(0,0,a[i]);
  lc.setRow(0,1,a[i+1]);    
  lc.setRow(0,2,a[i+2]);    
  lc.setRow(0,3,a[i+3]);    
  lc.setRow(0,4,a[i+4]);    
  lc.setRow(0,5,a[i+5]);    
  lc.setRow(0,6,a[i+6]);    
  lc.setRow(0,7,a[i+7]);
  delay(120);  
  }
 
}


void writeSmile() {

  byte a[8]={B00000000,B00010000,B00100110,B01000000,B01000000,B00100110,B00010000,B00000000};

  lc.setRow(0,0,a[0]);
  lc.setRow(0,1,a[1]);
  lc.setRow(0,2,a[2]);
  lc.setRow(0,3,a[3]);
  lc.setRow(0,4,a[4]);
  lc.setRow(0,5,a[5]);
  lc.setRow(0,6,a[6]);
  lc.setRow(0,7,a[7]);

}


void writeSad() {

  byte a[8]={B00000000,B01000000,B00100110,B00100000,B00100000,B00100110,B01000000,B00000000};

  lc.setRow(0,0,a[0]);
  lc.setRow(0,1,a[1]);
  lc.setRow(0,2,a[2]);
  lc.setRow(0,3,a[3]);
  lc.setRow(0,4,a[4]);
  lc.setRow(0,5,a[5]);
  lc.setRow(0,6,a[6]);
  lc.setRow(0,7,a[7]);

}


void pallino(int n) { // disegna l’asteroide sulla matrice
  if(n==1) {
    lc.setLed(0,0,7,1);
    lc.setLed(0,0,6,1);
    lc.setLed(0,1,6,1);
    lc.setLed(0,1,7,1);    
  }
  if(n==2) {
    lc.setLed(0,3,6,1);
    lc.setLed(0,3,7,1);
    lc.setLed(0,4,6,1);
    lc.setLed(0,4,7,1);    
  }
  if(n==3) {
    lc.setLed(0,7,6,1);
    lc.setLed(0,7,7,1);
    lc.setLed(0,6,6,1);
    lc.setLed(0,6,7,1);    
  }
  if(n==4) {
    lc.setLed(0,7,3,1);
    lc.setLed(0,7,4,1);
    lc.setLed(0,6,3,1);
    lc.setLed(0,6,4,1);    
  }
  if(n==5) {
    lc.setLed(0,6,0,1);
    lc.setLed(0,7,0,1);
    lc.setLed(0,6,1,1);
    lc.setLed(0,7,1,1);    
  }
  if(n==6) {
    lc.setLed(0,3,0,1);
    lc.setLed(0,4,0,1);
    lc.setLed(0,3,1,1);
    lc.setLed(0,4,1,1);    
  }
  if(n==7) {
    lc.setLed(0,0,0,1);
    lc.setLed(0,0,1,1);
    lc.setLed(0,1,0,1);
    lc.setLed(0,1,1,1);    
  }
  if(n==8) {
    lc.setLed(0,0,3,1);
    lc.setLed(0,0,4,1);
    lc.setLed(0,1,3,1);
    lc.setLed(0,1,4,1);    
  }
}

void clearpallino(int n) { // cancella l’asteroide dalla matrice
  if(n==1) {
    lc.setLed(0,0,7,0);
    lc.setLed(0,0,6,0);
    lc.setLed(0,1,6,0);
    lc.setLed(0,1,7,0);    
  }
  if(n==2) {
    lc.setLed(0,3,6,0);
    lc.setLed(0,3,7,0);
    lc.setLed(0,4,6,0);
    lc.setLed(0,4,7,0);    
  }
  if(n==3) {
    lc.setLed(0,7,6,0);
    lc.setLed(0,7,7,0);
    lc.setLed(0,6,6,0);
    lc.setLed(0,6,7,0);    
  }
  if(n==4) {
    lc.setLed(0,7,3,0);
    lc.setLed(0,7,4,0);
    lc.setLed(0,6,3,0);
    lc.setLed(0,6,4,0);    
  }
  if(n==5) {
    lc.setLed(0,6,0,0);
    lc.setLed(0,7,0,0);
    lc.setLed(0,6,1,0);
    lc.setLed(0,7,1,0);    
  }
  if(n==6) {
    lc.setLed(0,3,0,0);
    lc.setLed(0,4,0,0);
    lc.setLed(0,3,1,0);
    lc.setLed(0,4,1,0);    
  }
  if(n==7) {
    lc.setLed(0,0,0,0);
    lc.setLed(0,0,1,0);
    lc.setLed(0,1,0,0);
    lc.setLed(0,1,1,0);    
  }
  if(n==8) {
    lc.setLed(0,0,3,0);
    lc.setLed(0,0,4,0);
    lc.setLed(0,1,3,0);
    lc.setLed(0,1,4,0);    
  }
}


void writeDigit(int i, int m, int r) {
  switch(i) {
    case 0:
    lc.setRow(m,r,B00111110);
    lc.setRow(m,r+1,B00100010);
    lc.setRow(m,r+2,B00111110);
    break;
    case 1:
    lc.setRow(m,r,B00000000);
    lc.setRow(m,r+1,B00000000);
    lc.setRow(m,r+2,B00111110);
    break;
    case 2:
    lc.setRow(m,r,B00111010);
    lc.setRow(m,r+1,B00101010);
    lc.setRow(m,r+2,B00101110);
    break;
    case 3:
    lc.setRow(m,r,B00101010);
    lc.setRow(m,r+1,B00101010);
    lc.setRow(m,r+2,B00111110);
    break;
    case 4:
    lc.setRow(m,r,B00001110);
    lc.setRow(m,r+1,B00001000);
    lc.setRow(m,r+2,B00111110);
    break;
    case 5:
    lc.setRow(m,r,B00101110);
    lc.setRow(m,r+1,B00101010);
    lc.setRow(m,r+2,B00111010);
    break;
    case 6:
    lc.setRow(m,r,B00111110);
    lc.setRow(m,r+1,B00101010);
    lc.setRow(m,r+2,B00111010);
    break;
    case 7:
    lc.setRow(m,r,B00000010);
    lc.setRow(m,r+1,B00000010);
    lc.setRow(m,r+2,B00111110);
    break;
    case 8:
    lc.setRow(m,r,B00111110);
    lc.setRow(m,r+1,B00101010);
    lc.setRow(m,r+2,B00111110);
    break;
    case 9:
    lc.setRow(m,r,B00101110);
    lc.setRow(m,r+1,B00101010);
    lc.setRow(m,r+2,B00111110);
    break;
  }
}

void writeNumber(int n, int m) {
  int u = n % 10;
  int d = n / 10;
  writeDigit(d, m, 0);
  writeDigit(u, m, 4);
}


void loop() {

  if(millis() - last > c) { // inserisce un nuovo asteroide…

    int z = random(1,9);

    while(lista[z-1]==1) { // …assicurandosi di piazzarlo in una posizione non occupata
      z = random(1,9);
    }
   
    pallino(z);
    lista[z-1] = 1;
    asteroidi = asteroidi + 1;
    last = millis();
   
  }

  if(asteroidi >= 7) { // game over
    writeGameOver();
    delay(1000);
    lc.clearDisplay(0);
    writeNumber(level, 0);
    delay(2000);
    lc.clearDisplay(0);
    if(level > 49) { writeSmile(); }
    if(level < 50) { writeSad(); }
    delay(2000);
    lc.clearDisplay(0);
   
    while(1==1) {    } // fine del gioco


  }
 
  if(analogRead(Y_pin)<100 && analogRead(X_pin)>900  && lista[0]==1) {
     clearpallino(1);  
     asteroidi = asteroidi - 1;
     lista[0] = 0;
     level = level+1;
     if(level%5 == 0) {  // la difficoltà aumenta ogni 5 livelli
       c = c - difficolta;
     }
  }
 
  if(analogRead(X_pin)>900 && analogRead(Y_pin)>350 && analogRead(Y_pin)<650  && lista[1]==1) {
     clearpallino(2);
     asteroidi = asteroidi - 1;
     lista[1] = 0;  
     level = level+1;
     if(level%5 == 0) {  // la difficoltà aumenta ogni 5 livelli
       c = c - difficolta;
     }
  }
 
  if(analogRead(Y_pin)>900 && analogRead(X_pin)>900  && lista[2]==1) {
     clearpallino(3);
     asteroidi = asteroidi - 1;
     lista[2] = 0;  
     level = level+1;
     if(level%5 == 0) {  // la difficoltà aumenta ogni 5 livelli
       c = c - difficolta;
     }
  }
 
  if(analogRead(Y_pin)>900 && analogRead(X_pin)>350 && analogRead(X_pin)<650  && lista[3]==1) {
     clearpallino(4);  
     asteroidi = asteroidi - 1;
     lista[3] = 0;
     level = level+1;
  if(level%5 == 0) {  // la difficoltà aumenta ogni 5 livelli
    c = c - difficolta;
  }
  }
 
  if(analogRead(Y_pin)>900 && analogRead(X_pin)<100  && lista[4]==1) {
     clearpallino(5);  
     asteroidi = asteroidi - 1;
     lista[4] = 0;
     level = level+1;
     if(level%5 == 0) {  // la difficoltà aumenta ogni 5 livelli
       c = c - difficolta;
     }
  }
   
  if(analogRead(X_pin)<100 && analogRead(Y_pin)>350 && analogRead(Y_pin)<650  && lista[5]==1) {
     clearpallino(6);  
     asteroidi = asteroidi - 1;
     lista[5] = 0;
     level = level+1;
     if(level%5 == 0) {  // la difficoltà aumenta ogni 5 livelli
       c = c - difficolta;
     }
  }
 
  if(analogRead(Y_pin)<100 && analogRead(X_pin)<100  && lista[6]==1) {
     clearpallino(7);      
     asteroidi = asteroidi - 1;
     lista[6] = 0;
     level = level+1;
     if(level%5 == 0) {  // la difficoltà aumenta ogni 5 livelli
       c = c - difficolta;
     }
  }
   
  if(analogRead(Y_pin)<100 && analogRead(X_pin)>350 && analogRead(X_pin)<650  && lista[7]==1) {
     clearpallino(8);  
     asteroidi = asteroidi - 1;
     lista[7] = 0;
     level = level+1;
     if(level%5 == 0) {  // la difficoltà aumenta ogni 5 livelli
       c = c - difficolta;
     }
  }

  if(c < 200) { // raggiunta la massima velocità possibile
    c = 200;
  }

  delay(10);

}

Galleria

giacomo

Commenti

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *