Videojuego LCD Arduino

Este es un proyecto que se basa en un videojuego que encontré en Internet. Este proyecto tiene muchas características, como un timbre para emitir un pitido cuando tu personaje choca o salta sobre obstáculos. Además, para darle una sensación de videojuego, tiene un joystick (debe tener un botón) porque simplemente presiona el botón del joystick para saltar. ¡Este videojuego se trata de que lo has adivinado! (Un hombre corriendo y saltando sobre obstáculos y evitándolos). El objetivo de este juego es obtener la mayor cantidad de puntos posible (un punto por cada segundo que estés en el campo y evitar los obstáculos).

¿Qué se necesita?

Una placa arduino UNO
Una protoboard (o placa de pruebas)
Varios cables de conexión
Un cable con extremos USB-A y B
Un potenciómetro
Un joystick analógico
Un timbre
Una pantalla LCD Adafruit

Conecta los cables rojo y negro en los pines 5V y GND de la placa de arduino y lleva el polo positivo del timbre al pin 8. Conecta el cable negro del timbre a la placa de pruebas. Ahora coge el joystick y conéctalo con ayuda de un par de cables a ambas placas. Conecta un cable rojo en el pin VCC del joystick a la protoboard y otro negro en el pin GND del mismo. Agarra un cable amarillo y desde el pin SEL del joystick llévalo al pin 2.

Llega el turno de conectar la pantalla LCD. Sitúala en la placa de pruebas y conéctala a la placa de arduino a través de los pines 3, 4, 5, 6, 9, 10 y 11. Y por último, coloca el potenciómetro. Gracias a esta pieza consigues ver el hombrecillo y los obstáculos en la pantalla LCD

#include  <LiquidCrystal.h>

#define PIN_BUTTON 2 
#define PIN_AUTOPLAY 1 
#define PIN_BUZZER 8 
#define PIN_READWRITE 10 
#define PIN_CONTRAST 12 
#define SPRITE_RUN1 1 #define SPRITE_RUN2 2 #define SPRITE_JUMP 3 #define_PERITE_.         // Utilizar el '.' carácter para la cabeza #define SPRITE_JUMP_LOWER 4 #define SPRITE_TERRAIN_EMPTY ''       // usuario el carácter '' #define SPRITE_TERRAIN_SOLID 5 #define SPRITE_TERRAIN_SOLID_RIGHT 6 #define SPRITE_TERRAIN_SOLID_LEFT 7 #define HERO_HORIZONTAL_POSITION 1     // Horizontal posición del héroe en la pantalla #define TERRAIN_WIDTH 16 #define TERRAIN_EMPTY 0



#define TERRAIN_LOWER_BLOCK 1 
#define TERRAIN_UPPER_BLOCK 2 
#define HERO_POSITION_OFF 0           // héroe es invisible HERO_POSITION_RUN_LOWER_1 #define 1   // héroe se está ejecutando en la fila inferior (pose 1) #define HERO_POSITION_RUN_LOWER_2 2   // (pose 2) #define HERO_POSITION_JUMP_1 3        // partir un salto #define HERO_POSITION_JUMP_2 4        // A mitad de camino hacia arriba #define HERO_POSITION_JUMP_3 5        // El salto está en la fila superior #define HERO_POSITION_JUMP_4 6        // El salto está en la fila superior #define HERO_POSITION_JUMP_5 7 // El salto está en la fila superior #define HUMP___        JUMP_PRO_POSICIÓN_HUMP_3 5        //



// El salto está en la fila superior 
#define HERO_POSITION_JUMP_7 9        // A mitad de camino 
#define HERO_POSITION_JUMP_8 10       // A punto de aterrizar 
#define HERO_POSITION_RUN_UPPER_1 11 // Hero está corriendo en la fila superior (pose 1) #define HERO_POSITION_RUN_UPPER_2 12 // (pose 2) LiquidCrystal lcd ( 11 , 9 , 6 , 5 , 4 , 3 ); terreno char estático Arriba [ TERRAIN_WIDTH + 1 ]; estática Char terrainLower [


    
  TERRAIN_WIDTH  +  1 ]; 
botón bool 
estático  Empujado = falso ;    
void initializeGraphics () { gráficos de bytes estáticos [] = { // Posición de ejecución 1 B01100 , B01100 , B00000 , B01110 , B11100 , B01100 , B11010 , B10011 , // Posición de ejecución 2 B01100 , B01100 , B00000 , B01100 , B01100 , B01100

 
    , 
B01100 , B01110 , // Saltar B01100 , B01100 , B00000 , B11110 , B01101 , B11111 , B10000 , B00000 , // Saltar más abajo B11110 , B01101 , B11111 , B10000 , B00000 , B00000 , B00000 , B00000 , // Ground B11111 , B11 , B11111 , B11111 , B11111 , B11111
    
  
    , 
B11111 , B11111 , // Ground right B00011 , B00011 , B00011 , B00011 , B00011 , B00011 , B00011 , B00011 , // Ground left B11000 , B11000 , B11000 , B11000 , B11000 , B11000 , B11000 , B11000 , }; int i ; // Omita usando el carácter 0, esto permite que lcd.print () se use // para dibujar rápidamente varios caracteres
    
   
  
  para  ( i  =  0 ;  i  <  7 ;  ++ i )  { 
lcd . createChar ( i + 1 , y gráficos [ i * 8 ]); } para ( i = 0 ; i < TERRAIN_WIDTH ; ++ i ) { terrenoUpper [ i ] = SPRITE_TERRAIN_EMPTY ; terreno inferior [ i ]
	       
  
     =  SPRITE_TERRAIN_EMPTY ; 
} } // Deslice el terreno hacia la izquierda en incrementos de medio carácter // anular avance Zona ( char * terreno , byte nuevo Zona ) { para ( int i = 0 ; i < TERRAIN_WIDTH ; ++ i ) { char current = terreno [ i ]; char next = ( i == TERRAIN_WIDTH - 1 )
  
       
          ?  nuevo  terreno :  terreno [ i + 1 ]; 
interruptor ( actual ) { caso SPRITE_TERRAIN_EMPTY : terreno [ i ] = ( siguiente == SPRITE_TERRAIN_SOLID ) ? SPRITE_TERRAIN_SOLID_RIGHT : SPRITE_TERRAIN_EMPTY ; romper ; caso SPRITE_TERRAIN_SOLID : terreno [ i ] = ( siguiente == SPRITE_TERRAIN_EMPTY ) ?
     
       
       
              SPRITE_TERRAIN_SOLID_LEFT  :  SPRITE_TERRAIN_SOLID ; 
romper ; caso SPRITE_TERRAIN_SOLID_RIGHT : terreno [ i ] = SPRITE_TERRAIN_SOLID ; romper ; caso SPRITE_TERRAIN_SOLID_LEFT : terreno [ i ] = SPRITE_TERRAIN_EMPTY ; romper ; } } } bool drawHero ( posición de byte , char * terrenosUpper , char * terrenosLower
        
    

      ,  puntaje int sin signo  ) {   
bool collide = false ; char upperSave = terrenoUpper [ HERO_HORIZONTAL_POSITION ]; char lowerSave = terreno inferior [ HERO_HORIZONTAL_POSITION ]; byte superior , inferior ; interruptor ( posición ) { case HERO_POSITION_OFF : upper = lower = SPRITE_TERRAIN_EMPTY ; romper ; caso
      
      
     HERO_POSITION_RUN_LOWER_1 : 
upper = SPRITE_TERRAIN_EMPTY ; inferior = SPRITE_RUN1 ; romper ; case HERO_POSITION_RUN_LOWER_2 : upper = SPRITE_TERRAIN_EMPTY ; inferior = SPRITE_RUN2 ; romper ; case HERO_POSITION_JUMP_1 : case HERO_POSITION_JUMP_8 : upper = SPRITE_TERRAIN_EMPTY ; inferior = SPRITE_JUMP ; romper ; caso HERO_POSITION_JUMP_2 :
        
  
     
    case  HERO_POSITION_JUMP_7 : 
upper = SPRITE_JUMP_UPPER ; inferior = SPRITE_JUMP_LOWER ; romper ; case HERO_POSITION_JUMP_3 : case HERO_POSITION_JUMP_4 : case HERO_POSITION_JUMP_5 : case HERO_POSITION_JUMP_6 : upper = SPRITE_JUMP ; inferior = SPRITE_TERRAIN_EMPTY ; romper ; case HERO_POSITION_RUN_UPPER_1 : upper = SPRITE_RUN1 ; inferior =
        
   
      
        SPRITE_TERRAIN_EMPTY ; 
romper ; case HERO_POSITION_RUN_UPPER_2 : upper = SPRITE_RUN2 ; inferior = SPRITE_TERRAIN_EMPTY ; romper ; } if ( upper ! = '' ) { terrenosUpper [ HERO_HORIZONTAL_POSITION ] = upper ; collide = ( upperSave == SPRITE_TERRAIN_EMPTY ) ? falso : verdadero ; } if ( inferior
      
         
  
    ! =  '' )  { 
terreno inferior [ HERO_HORIZONTAL_POSITION ] = inferior ; colisionar | = ( lowerSave == SPRITE_TERRAIN_EMPTY ) ? falso : verdadero ; } dígitos de bytes = ( puntuación > 9999 ) ? 5 : ( puntuación > 999 ) ? 4 : ( puntaje > 99 ) ? 3 : ( puntaje
      
            
                  >  9 )  ?  2  :  1 ; 
// Dibuja la escena terrenoUpper [ TERRAIN_WIDTH ] = '\ 0' ; terreno inferior [ TERRAIN_WIDTH ] = '\ 0' ; temp de char = terrenoUpper [ 16 - dígitos ]; terrenoUpper [ 16 - dígitos ] = '\ 0' ; lcd . setCursor ( 0 , 0 ); lcd . impresión
  
  
  
  ( terreno superior ); 
terrenoUpper [ 16 - dígitos ] = temp ; lcd . setCursor ( 0 , 1 ); lcd . imprimir ( terreno más bajo ); lcd . SetCursor ( 16 - dígitos , 0 ); lcd . imprimir ( puntaje ); terrenoUpper [ HERO_HORIZONTAL_POSITION ] = upperSave ; terrenoBajo [
      
  
    
  HERO_HORIZONTAL_POSITION ]  =  lowerSave ; 
volver chocar ; } // Maneje el botón presionar como una interrupción void buttonPush () { buttonPushed = true ; } configuración nula () { pinMode ( PIN_READWRITE , OUTPUT ); digitalWrite ( PIN_READWRITE , LOW ); pinMode ( PIN_CONTRAST , OUTPUT ); digitalWrite ( PIN_CONTRAST , LOW );
   


   
  pinMode ( PIN_BUTTON ,  INPUT ); 
digitalWrite ( PIN_BUTTON , HIGH ); pinMode ( PIN_AUTOPLAY , OUTPUT ); digitalWrite ( PIN_AUTOPLAY , HIGH ); pinMode ( PIN_BUZZER , OUTPUT ); // inicializa el pin del zumbador como una salida digitalWrite ( PIN_BUZZER , LOW ); // El pin digital 2 se asigna para interrumpir 0 attachInterrupt ( 0 / * PIN_BUTTON * / ,
   
  
   buttonPush ,  FALLING ); 
initializeGraphics (); lcd . comenzar ( 16 , 2 ); } bucle vacío () { byte estático heroPos = HERO_POSITION_RUN_LOWER_1 ; byte estático nuevo Tipo de terreno = TERRAIN_EMPTY ; byte estático newDurationDuration = 1 ; bool estático jugando = falso ; parpadeo estático de bool = falso ;
  
    
   distancia int estática sin signo  = 0 ;    
if ( ! playing ) { drawHero (( parpadeo ) ? HERO_POSITION_OFF : heroPos , terrenoUpper , terrenoLower , distancia >> 3 ); if ( parpadeo ) { lcd . setCursor ( 0 , 0 ); lcd . imprimir ( "Presione Inicio" ); } retraso (
  
    
    
    250 ); 
parpadeo = ! parpadear ; if ( buttonPushed ) { initializeGraphics (); heroPos = HERO_POSITION_RUN_LOWER_1 ; jugando = verdadero ; buttonPushed = false ; distancia = 0 ; } retorno ; } // Desplaza el terreno hacia la izquierda Avance del terreno ( terreno inferior , tipo de terreno nuevo == TERRAIN_LOWER_BLOCK ? SPRITE_TERRAIN_SOLID :
      
   
  
         SPRITE_TERRAIN_EMPTY ); 
Avance de terreno ( terreno superior , nuevo tipo de terreno == TERRAIN_UPPER_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY ); // Hacer un nuevo terreno para ingresar a la derecha if ( - newDigraciónDervalo == 0 ) { if ( newTypeTinter == TERRAIN_EMPTY ) { newTitterType = ( random ( 3 ) == 0 ) ? TERRAIN_UPPER_BLOCK :
         
  
        
              TERRAIN_LOWER_BLOCK ; 
nuevaDuración del terreno = 2 + aleatorio ( 10 ); } else { new TerraType = TERRAIN_EMPTY ; nuevaDuración del terreno = 10 + aleatorio ( 10 ); } } if ( buttonPushed ) { if ( heroPos <= HERO_POSITION_RUN_LOWER_2 ) heroPos = HERO_POSITION_JUMP_1 ; buttonPushed = false ; digitalWrite
          
  
          
      
    ( PIN_BUZZER , ALTO );  
} if ( drawHero ( heroPos , terrenoUpper , terrenoLower , distancia >> 3 )) { playing = false ; // El héroe chocó con algo. Demasiado. para ( int i = 0 ; i <= 2 ; i ++ ) { digitalWrite ( PIN_BUZZER , HIGH ); retraso ( 100
    

      ); 
digitalWrite ( PIN_BUZZER , LOW ); retraso ( 100 ); } } else { if ( heroPos == HERO_POSITION_RUN_LOWER_2 || heroPos == HERO_POSITION_JUMP_8 ) { heroPos = HERO_POSITION_RUN_LOWER_1 ; } else if (( heroPos > = HERO_POSITION_JUMP_3 && heroPos <= HERO_POSITION_JUMP_5 ) && terrenoLower [ HERO_HORIZONTAL_POSITION
       
        
        
               ]  ! =  SPRITE_TERRAIN_EMPTY )  { 
heroPos = HERO_POSITION_RUN_UPPER_1 ; } else if ( heroPos > = HERO_POSITION_RUN_UPPER_1 && terrenosLower [ HERO_HORIZONTAL_POSITION ] == SPRITE_TERRAIN_EMPTY ) { heroPos = HERO_POSITION_JUMP_5 ; } else if ( heroPos == HERO_POSITION_RUN_UPPER_2 ) { heroPos = HERO_POSITION_RUN_UPPER_1 ; } más
        
     
      { 
++ heroPos ; } ++ distancia ; digitalWrite ( PIN_AUTOPLAY , terreno inferior [ HERO_HORIZONTAL_POSITION + 2 ] == SPRITE_TERRAIN_EMPTY ? HIGH : LOW ); } retraso ( 100 ); digitalWrite ( PIN_BUZZER , LOW )

 }