Juego OLED Reckless Racer Arduino, AdafruitGFX y conceptos básicos de mapas de bits: 6 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:40

En este tutorial veremos cómo usar mapas de bits usando la biblioteca Adafruit_GFX.c como una especie de sprites en un juego. El juego más simple que se nos ocurrió es un juego de autos que cambia de carril de desplazamiento lateral, al final nuestro beta tester y asistente de codificador se decidió por "Reckless Racer" como nombre, ya que es bastante imprudente conducir en sentido contrario por la autopista.

El diseño de nuestro circuito está en las imágenes incluidas arriba y se detalla en nuestro último proyecto / tutorial aquí Snake Instructables que describe cómo funciona el circuito.

vamos a requerir

Adafruit_GFX

Paint.net

Arduino IDE windowslinux

y por favor, eche un vistazo al tutorial de Snake para el resto del equipo.

Suministros

Juego de serpientes

Paso 1: Instalar Paint.net

Estamos usando paint.net ya que el software es gratuito, por lo que puede descargar Paint. Net aquí.

Para instalar paint.net, haga doble clic en el programa descargado y responda positivamente a continuación, sí, está bien, estoy de acuerdo y las imágenes de arriba le darán instrucciones.

Paso 2: Dibujar una pantalla de bienvenida simple

Cuando esté en paint.net, cree una nueva imagen haciendo clic en Archivo y luego en nuevo, establezca el tamaño de la imagen en 1260x620 (vea la primera imagen) haga clic en Aceptar cuando tenga su nueva página dibuje una pantalla de presentación usando solo 2 colores en blanco y negro con el lápiz herramienta (pic2), cuando haya dibujado (o pegado) la imagen de la pantalla de inicio, haga clic en la imagen y luego cambie el tamaño (imagen 4), en la ventana emergente cambie el tamaño de 1260x620 a 126x62 (2 píxeles más pequeño que su pantalla) (imagen 5) Haga clic en Aceptar.

luego haga clic en el menú Archivo y luego guárdelo como (imagen 6).

cuando aparezca la ventana emergente en el menú desplegable de tipo de archivo, seleccione BMP (mapa de bits). (imagen 7), escriba un nombre de archivo y haga clic en guardar, cuando aparezca la ventana emergente, establezca el difuminado en 0 y establezca en 8 bits, haga clic en Aceptar (imagen 8).

Paso 3: Conversión de BMP a archivo de mapa de bits C

Ahora tenemos que convertir nuestra imagen a un formato que el arduino pueda entender, hay muchas herramientas disponibles para hacer esto, pero mi lugar de "ir a" es la herramienta de conversión de mapa de bits del sitio web de is marlin …

marlinfw.org/tools/u8glib/converter.html

Entonces comenzamos esta sección usando el enlace de arriba para abrir el sitio web que se muestra en pic1

haga clic en elegir archivo y seleccione el mapa de bits que creó anteriormente (imagen 2)

El convertidor de mapa de bits marlin convertirá automáticamente su imagen en código c, haga doble clic izquierdo en el código que debe resaltar el código, luego haga clic derecho y haga clic en copiar (pic3)

siguiente Creamos clic derecho y creamos un nuevo documento de texto (pic4)

haga doble clic en el nuevo documento, cuando se abra, haga clic con el botón derecho y pegue el código (pic5)

a continuación tenemos que agregar la línea cerca de la parte superior del código #include esto nos permite guardar los datos del mapa de bits en la memoria flash en el arduino, luego cambiamos el nombre de #define width, height y name a algo más fácil de usar estos están resaltados en la foto 6, les cambiamos el nombre de los caracteres generados aleatoriamente les cambiamos el nombre al ejemplo subrayado a continuación

#define LOGOWIDTH

#define LOGOHEIGHT

const unsigned char LOGOPIC PROGMEM

Luego haga clic en el archivo y luego guárdelo como, guarde el archivo como logo.c cierre el bloc de notas, haga clic con el botón derecho en logo.cy haga clic en copiar.

Paso 4: Visualización de un LOGOTIPO usando DrawBitmap

Ahora cargamos el IDE de arduino y creamos un nuevo boceto y lo guardamos con el nombre logoexample.ino, luego como un truco en el ide de arduino, haga clic en el menú de archivo, luego guarde como, regrese a la carpeta del proyecto, haga clic con el botón derecho y pegue en el archivo.c (pic2) luego haga clic en cancelar, esto le ahorra tener que buscar la carpeta para pegar en el archivo.

escriba el siguiente código en el IDE de arduino o descárguelo en ino.

(recomendamos escribir en lugar de copiar y pegar o usar los archivos a continuación, es la mejor manera de aprender)

#include / * esto variará dependiendo de dónde almacene

el ino generalmente en la carpeta C: / Users / ~ username / Documents / Arduino / project ~ name

y así es como nos vinculamos a nuestro mapa de bits * /

#incluir

#incluir

uint8_t bmpX, bmpY = 0; / * reserva de memoria para enteros de 2 X 8 bits, solo necesitamos entradas de 8 bits

ya que el valor nunca es superior a 128 (píxeles), por lo que podemos ahorrar espacio utilizando entradas de 8 bits (que tiene un valor máximo de 255) * /

configuración vacía ()

{retraso (100); // dar tiempo a la pantalla, etc. para que se encienda la pantalla.begin (SSD1306_SWITCHCAPVCC, 0x3C); // esto es para inicializar la pantalla display.clearDisplay (); // comienza con una pantalla en blanco}

/ * tenga en cuenta que no tiene que escribir estos comentarios, ya que son para referencia …………..

el comando en el que nos vamos a enfocar es el display.drawBitmap, esto es lo que dibuja nuestra pantalla de bienvenida. (bmpX, es el valor del eje X en la pantalla donde estará el punto de anclaje X del mapa de bits y bmpX y bmpY son los valores que nos interesan para crear movimiento (bmpY, es el valor del eje Y en la pantalla donde el ancla Y El punto del mapa de bits será que obtengamos los nombres de referencia como los definimos en logo.c (LOGOPIC, es el nombre del mapa de bits en el archivo # incluido logo.c (LOGOWIDTH, es cuántos píxeles a lo largo de (X) dibujar el mapa de bits desde el punto de anclaje (LOGOHEIGHT, es cuántos píxeles hacia abajo (Y) para dibujar el mapa de bits desde el punto de anclaje los píxeles X e Y cruzados se pueden ingresar manualmente, pero es más fácil usar los predefinidos que recordarlos todos (1, el último valor es el color ya que la pantalla es mono 0 negro 1 blanco. Está bien, empiece a escribir desde la siguiente línea: ¬D lol * / void loop () {display.clearDisplay (); // en blanco la pantalla // mapa de bits extraído del arriba a la izquierda, x, y, nombre del mapa de bits, ancho X, alto Y, pantalla en color. esto realmente atrae el búfer a la pantalla siempre}

cargue su código arduino y confirme que está funcionando (pic3).

Paso 5: Mover un Sprite de mapa de bits

usando las instrucciones anteriores, use paint.net y haga un nuevo archivo de 30x15 píxeles (imagen 1) y dibuje un automóvil en bruto que nuestro joven diseñador comienza con el parabrisas primero (imágenes 2 y 3).

nuevamente guárdelo como un archivo bmp de Windows (como en el paso 2), conviértalo a un mapa de bits C (paso 3) y coloque el archivo car.c (o lo que usted decida) en la misma carpeta que un arduino ino recién creado (boceto) expediente.

(p.s. recuerde agregar la línea #include en car.c, esto solía atraparnos a menudo)

Primero vincule su equivalente de car.c

#incluir

#include #include Adafruit_GFX.h> // https://github.com/adafruit/Adafruit-GFX-Library #include Adafruit_SSD1306 //

Pantalla Adafruit_SSD1306 (128, 64); // establece la resolución de la pantalla

/ * bmpX / bmpY, necesitamos que sean variables, ya que cambiar estos valores y volver a dibujar

la pantalla es cómo creamos el efecto de animación de movimiento. hitSide y hitTop es cómo mantenemos el sprite en la pantalla * / uint8_t bmpX, bmpY = 0; // reserva memoria para 2 entradas de 8 bits (0-255) no necesitamos más 128 será el mayor número usado bool hitSide = 0; bool hitTop = 0;

configuración vacía ()

{retraso (100); // dar tiempo a la pantalla, etc. para que se encienda la pantalla.begin (SSD1306_SWITCHCAPVCC, 0x3C); // esto es para inicializar la pantalla display.clearDisplay (); // comienza con una pantalla en blanco

}

bucle vacío ()

{display.clearDisplay (); // en blanco la pantalla // mapa de bits dibujado desde la parte superior izquierda, x, y, nombre del mapa de bits, ancho X, alto Y, color display.drawBitmap (bmpX, bmpY, CARSPRITE, CARWIDTH, CARHEIGHT, 1); // display.display (); // esto realmente atrae el búfer a la pantalla siempre / * así es como rastreamos el borde de la pantalla y decidimos si agregar un píxel, mover de arriba a abajo) o eliminar un píxel (mover de abajo hacia arriba) * / switch (hitSide) // esto elige la dirección del coche basándose en el boole {case 0: bmpX ++; rotura;

caso 1:

bmpX--; rotura; } // estas 2 declaraciones if establecen el bool en verdadero o falso if (bmpX == 0) {hitSide = 0; } if (bmpX == 96) // el ancho de la pantalla menos el coche {hitSide = 1; } // igual que arriba para el eje Y if (bmpY == 0) {hitTop = 0; } if (bmpY == 49) // altura de la pantalla menos la altura del coche {hitTop = 1; } switch (hitTop) {caso 0: bmpY ++; rotura; caso 1: bmpY--; rotura; }

}

puedes ver el programa funcionando en el video adjunto

Paso 6: hacer el juego de conducción

Primero, comenzamos dibujando algunos autos u obstáculos diferentes como en las etapas anteriores del tutorial, haciéndolos 30x15 píxeles. Luego, los convertimos a mapas de bits c y los vinculamos en el código.

#include // estas rutas tendrán que cambiar dependiendo

// sobre dónde almacena los archivos // editar: acabo de descubrir que si reemplaza // con "" no necesita la ruta completa // con sus propias bibliotecas #include

#incluir

#include #incluya

#incluir

#include // https://github.com/adafruit/Adafruit-GFX-Library #include <Adafruit_SSD1306 //

Pantalla Adafruit_SSD1306 (128, 64); // definir los parámetros de visualización

definir las variables y valores fijos

// definir pines de entrada estos son los pines en el arduino que nunca cambian así que # define # define INTPIN 3 // solo los pines 2 y 3 pueden ser pines de interrupción en UNO #define UPPIN 4 // estos son pines conectados al interruptor relevante #define DWNPIN 5 #define LFTPIN 6 #define RHTPIN 7 #define SND 9 // define direcciones

#define DIRUP 1 // estos valores es lo que la "serpiente" mira para decidir-

#define DIRDOWN 2 // la dirección en la que viajará la serpiente #define DIRLEFT 3 #define DIRRIGHT 4

uint8_t dirPressed = 0; // valor para registrar la dirección para moverse en qué pin fue alto

// tienda booleana que pin subió

bool BUTUP = 0; bool BUTDWN = 0; bool BUTLFT = 0; bool BUTRHT = 0; // vars para la posición del coche uint8_t carPosX = 1; uint8_t carPosY = {0, 16, 32, 48}; // necesita un cambio de valor en la matriz

uint8_t lanePosArr = {0, 16, 32, 48}; // matriz para almacenar dónde está cada carril

uint8_t carPosYCnt = 0; uint8_t carYTmp = 0; // variables para las líneas de la carretera uint8_t roadLineX1 = 51; // estos están predefinidos al principio, luego las líneas aparecen sin interrupciones uint8_t roadLineX2 = 102; uint8_t roadLineX3 = 153; uint8_t roadLineX4 = 254; uint8_t roadLineX5 = 200;

// esta es la cantidad de píxeles que se mueve el área de juego a la vez

uint8_t drawSpeed = 4;

// vars para enemigo0

uint8_t enemigo0PosX = 255; uint8_t enemigo0PosY = 0; uint8_t enemigo1PosX = 255; uint8_t enemigo1PosY = 0; uint8_t enemigo2PosX = 255; uint8_t enemigo2PosY = 0;

// variable para asignar aleatoriamente un número de carril a los obstáculos

uint8_t laneGen = 0;

uint8_t laneGen0 = 0; uint8_t laneGen1 = 0; uint8_t laneGen2 = 0;

// contador de puntuación

puntuación larga = 0; // esta es la puntuación: / lol long compare = 0; // esto almacena el puntaje en el último nivel para compararlo con el puntaje alto largo = 25; uint8_t metreCnt = 0;

aquí es donde comenzamos las funciones

// este es el conjunto de comandos si la interrupción está activada void interruptressed () {delay (150); updateDirection (); } // actualiza qué valor está en la dirección var comprobando los bools de DIR // -------------------------- ACTUALIZAR DIRECCIÓN (jugador) - ------------------------- void updateDirection () {//Serial.println("updateDirection Called "); BUTUP = digitalRead (UPPIN); BUTDWN = digitalRead (DWNPIN); BUTLFT = lectura digital (LFTPIN); BUTRHT = lectura digital (RHTPIN); if (BUTUP == true) {dirPressed = DIRUP; } if (BUTDWN == true) {dirPressed = DIRDOWN; } if (BUTLFT == true) {dirPressed = DIRLEFT; } si (BUTRHT == verdadero) {dirPressed = DIRRIGHT; }

}

// ------------------------------- MOVER COCHE --------------- -------------------------

// esto actualizará la pantalla el mover el sprite del coche

void moveCar ()

{switch (dirPressed) {case DIRUP: carPosYCnt--; carPosY [carPosYCnt]; tono (SND, 100, 100); if (carPosYCnt == 255) {carPosYCnt = 0; } carYTmp = carPosY [carPosYCnt]; dirPressed = 0; // Serial.println ("carPosY up"); // Serial.println (carPosYCnt); rotura; caso DIRDOWN: carPosYCnt ++; tono (SND, 100, 100); if (carPosYCnt == 4) {carPosYCnt = 3; } // Serial.println ("carPosY"); // Serial.println (carPosYCnt); carYTmp = carPosY [carPosYCnt]; dirPressed = 0; rotura; // comentó el coche capaz de moverse hacia la izquierda y la derecha, la detección de colisiones aún no es tan buena / * case DIRLEFT: carPosX--; if (carPosX == 0) {carPosX = 1; } // Serial.println ("carPosX"); // Serial.println (carPosX); dirPressed = 0; rotura; * / case DIRRIGHT: // solo por diversión si presionas a la derecha el juego emitirá un tono de ruido (SND, 100, 50); // carPosX ++; // si (carPosX == 128) // {// carPosX = 127; //} // Serial.println ("carPosX"); // Serial.println (carPosX); // dirPressed = 0; rotura; } updateDisplay (); }

// -------------------------- POSICIÓN ALEATORIA X ------------------- -----------

uint8_t randomPosX () // estas 2 rutinas solo generan una posición aleatoria para los obstáculos

{uint8_t posValTmp = 0; posValTmp = aleatorio (129, 230); //Serial.println("random x "); //Serial.println(posValTmp); return (posValTmp); }

// --------------------------- POS Y ALEATORIA ------------------ ------------------

uint8_t randomPosY ()

{uint8_t laneVal = 0; laneVal = aleatorio (0, 4); // agregue un carril adicional para aleatoriedad, es decir, ningún objeto en la pantalla mientras esté en ese carril //Serial.println("RandomY "); //Serial.println(lanePosArr[laneVal]); return (lanePosArr [laneVal]); }// ------------------------------- ESTABLECER VELOCIDAD DEL JUEGO -------------- -------------- void setGameSpeed () // esto evita que el nivel supere el 20, lo que hace que el juego no se pueda jugar {if (drawSpeed <21) {drawSpeed = drawSpeed + 2; }}// ------------------------------------ DETECTAR CRASH ---------- ----------------------- void detectCrash () {

if (Enemigo0PosX = 0 && Enemigo0PosY == carYTmp)

{// Serial.println ("Game Over CRAASSSSHHHHHHHEEEEDDD en Traffic 0"); juego terminado(); } if (Enemigo1PosX = 0 && Enemigo1PosY == carYTmp) {//Serial.println("Game Over CRAASSSSHHHHHHHEEEEDDD en el tráfico 1 "); juego terminado(); } si (Enemigo2PosX = 0 && Enemigo2PosY == carYTmp) {//Serial.println("Game Over CRAASSSSHHHHHHHEEEEDDD en el tráfico 2 "); juego terminado(); }}

estas son las rutinas que dibujan la pantalla.

// ------------------------------- DIBUJAR CARRETERA --------------- --------------------- void drawRoad () // X, Y, length, width {display.fillRect (roadLineX1, 15, 30, 4, WHITE); display.fillRect (roadLineX1, 30, 30, 4, BLANCO); display.fillRect (roadLineX1, 45, 30, 4, BLANCO); display.fillRect (roadLineX2, 15, 30, 4, BLANCO); display.fillRect (roadLineX2, 30, 30, 4, BLANCO); display.fillRect (roadLineX2, 45, 30, 4, BLANCO); display.fillRect (roadLineX3, 15, 30, 4, BLANCO); display.fillRect (roadLineX3, 30, 30, 4, BLANCO); display.fillRect (roadLineX3, 45, 30, 4, BLANCO); display.fillRect (roadLineX4, 15, 30, 4, BLANCO); display.fillRect (roadLineX4, 30, 30, 4, BLANCO); display.fillRect (roadLineX4, 45, 30, 4, BLANCO); display.fillRect (roadLineX5, 15, 30, 4, BLANCO); display.fillRect (roadLineX5, 30, 30, 4, BLANCO); display.fillRect (roadLineX5, 45, 30, 4, BLANCO);

roadLineX1 = roadLineX1-drawSpeed;

roadLineX2 = roadLineX2-drawSpeed; roadLineX3 = roadLineX3-drawSpeed; roadLineX4 = roadLineX4-drawSpeed; roadLineX5 = roadLineX5-drawSpeed; display.display (); } // ----------------------------------------- DIBUJAR enemigos ---- --------------------------------------- void enemysDraw () {// X, Y, bmp nombre, ancho, alto, color display.drawBitmap (enemigo0PosX, enemigo0PosY, ENEMY0, ENEMY0_WIDTH, ENEMY0_HEIGHT, 1); Enemigo0PosX = Enemigo0PosX-drawSpeed; display.drawBitmap (Enemigo1PosX, Enemigo1PosY, ENEMY1, ENEMY1_WIDTH, ENEMY1_HEIGHT, 1); Enemigo1PosX = Enemigo1PosX-drawSpeed; display.drawBitmap (Enemigo2PosX, Enemigo2PosY, ENEMY2, ENEMY2_WIDTH, ENEMY2_HEIGHT, 1); Enemigo2PosX = Enemigo2PosX-drawSpeed; display.display (); if (Enemigo0PosX> 231 && Enemigo0PosX231 && Enemigo1PosX <255) {Enemigo1PosX = randomPosX (); enemigo1PosY = aleatorioPosY (); checkDuplicate (); }

if (Enemigo2PosX> 231 && Enemigo2PosX <255) {Enemigo2PosX = randomPosX (); enemigo2PosY = randomPosY (); }} // ------------------------------------ ACTUALIZAR PANTALLA -------- ---------------------------------------- void updateDisplay () {display.clearDisplay (); display.drawBitmap (carPosX, carPosY [carPosYCnt], CARSPRITE, 30, 15, 1); display.fillRect (100, 0, 28, 10, NEGRO); display.setCursor (100, 0); display.setTextColor (BLANCO, NEGRO); display.println (puntuación); display.display ();

}

// ------------------------- espera el bucle de prensa ------------------- ------

// este es el código de la pantalla de inicio void waitForPress () {splashScreen (); bool esperando = 0; // el ciclo termina cuando esto es cierto display.clearDisplay (); while (esperando == 0) {

display.fillRect (19, 20, 90, 32, NEGRO); // fondo en blanco para el texto

display.setTextColor (BLANCO); display.setCursor (23, 24); display.setTextSize (0); display.println ("Temerario"); display.setCursor (36, 34); display.println ("Corredor"); display.drawBitmap (74, 24, CARSPRITE, CARWIDTH, CARHEIGHT, 1); // x y w h r col display.drawRoundRect (21, 21, 86, 23, 4, BLANCO); // Serpiente de borde display.drawRect (19, 20, 90, 33, BLANCO); // cuadro de borde - 3 display.setCursor (25, 43); display.setTextSize (0); // la fuente vuelve a la pantalla normal.println ("presione cualquier tecla"); display.fillRect (0, 0, 127, 8, NEGRO); display.setCursor (10, 0); display.print ("Puntaje alto:"); // muestra la puntuación más alta display.print (highScore); display.display (); esperando = digitalRead (INTPIN); // verifica si la tecla presionada esperando cambiará a 1 finalizando mientras dirPressed = 0; // botón de reinicio presionar en ninguna dirección}} // -------------------------------------- ----- ACTUALIZAR JUEGO ----------------------------------------- void updateGame () {moveCar (); drawRoad (); enemysDraw (); // enemigo1Draw (); // enemigo2Draw (); metreCnt ++; detectCrash (); if (metreCnt == 5) // agrega un punto por cada 10 ciclos para registrar la puntuación {metreCnt = 0; puntuación ++; } if (score == compare + 5) // acelera el juego cada 5 puntos hasta un máximo de 20 speed {compare = score; setGameSpeed (); } noTone (SND); updateDisplay ();

}

// ------------------------------ JUEGO TERMINADO---------------- ------------------------------

// esta rutina dibuja las líneas alrededor del coche héroe muerto y luego muestra el juego en la pantalla

void gameOver ()

{tono (SND, 200, 200); // reproducir sonido uint8_t linePosX, linePosY, pixwidth, pixheight = 0; // establece vars para dibujar cuadros alrededor del coche linePosX = carPosY; linePosY = carYTmp; pixwidth = 30; pixheight = 15; display.drawRect (linePosX, linePosY, pixwidth, pixheight, WHITE); display.display (); for (int i = 0; i <= 26; i ++) // esto rodea el coche en rectángulos simulando una explosión {linePosX = linePosX-2; linePosY = linePosY-2; pixwidth = pixwidth + 4; pixheight = pixheight + 4; display.drawRect (linePosX, linePosY, pixwidth, pixheight, BLACK); display.drawRect (linePosX, linePosY, pixwidth, pixheight, WHITE); display.display (); tono (SND, i * 20, 50); retraso (10); } display.setTextSize (2); display.setTextColor (BLANCO, NEGRO); display.setCursor (10, 23); tono (SND, 50, 500); display.print ("JUEGO"); display.display (); retraso (500); tono (SND, 40, 500); display.print ("OVER"); display.setTextSize (0); display.display (); retraso (3000); reinicia el juego(); waitForPress (); }

// ----------------------------------------- REINICIA EL JUEGO ----- -------------------------------------------------- -----

void restartGame () // esto copia la puntuación más alta y restablece todas las estadísticas y genera posiciones aleatorias

{if (puntaje> = puntaje alto) // verifique si el puntaje es mayor que el puntaje alto {puntaje alto = puntaje; // declaración única para actualizar la puntuación alta}

puntuación = 0;

drawSpeed = 4; metreCnt = 0; carPosYCnt = 0; enemigo0PosX = randomPosX (); enemigo0PosY = randomPosY (); Enemigo1PosX = randomPosX (); enemigo1PosY = aleatorioPosY (); Enemigo2PosX = randomPosX (); enemigo2PosY = randomPosY (); noTone (SND);

checkDuplicate ();

}

// ------------------------------------------------ - VER DUPLICADO ----------------------------------------------- ------ void checkDuplicate () // estos comprueban si los obstáculos ocupan el mismo espacio de juego {// Serial.println ("duplicado comprobado"); if (Enemigo2PosX> 230 && Enemigo2PosX <255) {while (Enemigo2PosY == Enemigo1PosY || Enemigo2PosY == Enemigo0PosY) {Enemigo2PosY = randomPosY (); }}

if (enemigo0PosX> 230 && enemigo0PosX230 && enemigo2PosXenemigo1PosX && enemigo2PosX230 && enemigo0PosXenemigo1PosX && enemigo0PosX

//------------------------------------------- PANTALLA DE BIENVENIDA --- --------------------------------

void splashScreen ()

{display.clearDisplay (); display.drawBitmap (0, 0, CRASH, CRASHWIDTH, CRASHHEIGHT, 1); display.display (); retraso (2000); } // ----------------------------------------------- CONFIGURACIÓN ------------------------------------------------- ----------- configuración vacía () {retraso (100); // dejar que las cosas comiencen // Serial.begin (9600); // Descomenta esto y todo el Serial. comandos para visualización de diagnóstico de fallas.begin (SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay (); display.setTextColor (BLANCO, NEGRO); display.setTextWrap (falso); display.dim (0); pinMode (INTPIN, INPUT); pinMode (UPPIN, ENTRADA); pinMode (DWNPIN, ENTRADA); pinMode (LFTPIN, ENTRADA); pinMode (RHTPIN, ENTRADA);

attachInterrupt (digitalPinToInterrupt (INTPIN), interrumpido, RISING);

// colocar obstrucciones al azar enemigo0PosX = randomPosX (); enemigo0PosY = randomPosY (); Enemigo1PosX = randomPosX (); enemigo1PosY = aleatorioPosY (); Enemigo2PosX = randomPosX (); enemigo2PosY = randomPosY (); checkDuplicate (); // comprobar si hay ubicaciones duplicadas // Serial.println ("configuración completa"); Pantalla de bienvenida(); waitForPress (); } // ----------------------------------------------- ----- CÍRCULO -------------------------------------------- ----------

bucle vacío ()

{updateGame (); }

y eso es todo, cualquier modificación y comentario será bienvenido. Los problemas que necesitamos para abordar el parpadeo de la pantalla, debemos ver cómo disminuirlo y los autos enemigos aún pueden ocupar el mismo espacio.