Jogo Reckless Racer Arduino OLED, AdafruitGFX e Bitmaps Básico: 6 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Neste tutorial, veremos como usar bitmaps usando a biblioteca Adafruit_GFX.c como uma espécie de sprites em um jogo. O jogo mais simples em que poderíamos pensar é um jogo de carro de mudança de pista de rolagem lateral, no final nosso testador beta e programador assistente decidiu "Reckless Racer" como um nome, já que é muito imprudente dirigir na direção errada na rodovia !!.

O design do nosso circuito está nas fotos incluídas acima e é detalhado em nosso último projeto / tutorial aqui Snake Instructables que descreve como o circuito funciona.

vamos exigir

Adafruit_GFX

Paint.net

Arduino IDE windowslinux

e dê uma olhada no tutorial do Snake para o resto do equipamento.

Suprimentos

Jogo da cobra

Etapa 1: Instalando o Paint.net

Estamos usando o paint.net, pois o software é gratuito, então você pode fazer o download do Paint. Net aqui.

Para instalar o paint.net clique duas vezes no programa baixado e responda positivamente em seguida, sim, ok, eu concordo e as fotos acima irão te dar um caminho.

Etapa 2: Desenhar uma tela inicial simples

Quando você estiver em paint.net, crie uma nova imagem clicando em Arquivo e depois em novo, defina o tamanho da imagem para 1260x620 (veja a primeira foto) clique em ok quando você tiver uma nova página, desenhe uma tela inicial usando apenas 2 cores preto e branco usando o lápis ferramenta (pic2), quando você tiver desenhado (ou colado) sua imagem de tela inicial, clique na imagem e redimensione (imagem4), no pop-up mude o tamanho de 1260x620 para 126x62 (2 pixels menor que a tela) (foto 5) Clique em OK.

em seguida, clique no menu Arquivo e salve como (foto 6).

quando a janela pop-up aparecer no menu suspenso de tipo de arquivo, selecione BMP (bitmap). (pic7), digite um nome de arquivo e clique em salvar, quando a janela pop-up aparecer defina o pontilhamento como 0 e como 8 bits, clique em ok (foto 8)

Etapa 3: convertendo BMP para arquivo de bitmap C

Agora precisamos converter nossa imagem para um formato que o arduino possa entender, existem muitas ferramentas disponíveis para fazer isso, mas meu "vá para" a ferramenta de conversão de bitmap do site da marlin webs…

marlinfw.org/tools/u8glib/converter.html

Então, começamos esta seção usando o link acima para abrir o site que é mostrado na foto 1

clique em escolher arquivo e selecione o bitmap que você criou anteriormente (foto 2)

O conversor de bitmap marlin converterá automaticamente sua imagem em código c, clique duas vezes com o botão esquerdo no código que deve destacar o código, clique com o botão direito e clique em copiar (foto 3)

próximo Nós criamos o botão direito e criamos um novo documento de texto (pic4)

clique duas vezes no novo documento, quando aberto clique com o botão direito e cole o código (pic5)

em seguida, temos que adicionar a linha perto do topo do código #include isso nos permite salvar os dados de bitmap na memória flash do arduino, então renomeamos #define largura, altura e nome para algo mais fácil de usar estes são destacados na foto 6, nós os renomeamos a partir dos caracteres gerados aleatoriamente, nós os renomeamos para o exemplo sublinhado abaixo

#define LOGOWIDTH

#define LOGOHEIGHT

const unsigned char LOGOPIC PROGMEM

em seguida, clique em arquivo e salve como, salve o arquivo como logo.c feche o bloco de notas, clique com o botão direito em logo.c e clique em copiar.

Etapa 4: Exibindo um LOGO usando DrawBitmap

Agora carregamos o IDE do arduino e criamos um novo esboço e salvamos com o nome logoexample.ino, em seguida, como um cheat no arduino, clique no menu de arquivo e salve como, volte para a pasta do projeto, clique com o botão direito e cole no arquivo.c (pic2) e clique em cancelar, isso evita que você tenha que navegar até a pasta para colar o arquivo.

digite o seguinte código no IDE do arduino ou baixe no ino.

(recomendamos digitar em vez de copiar e colar ou usar os arquivos abaixo, é a melhor maneira de aprender)

#include / * isso irá variar dependendo de onde você armazena

o ino geralmente está na pasta C: / Usuários / ~ nome de usuário / Documentos / Arduino / projeto ~ nome

e é assim que nos ligamos ao nosso bitmap * /

#incluir

#incluir

uint8_t bmpX, bmpY = 0; / * reserva de memória para inteiros de 2 X 8 bits, só precisamos de ints de 8 bits

como o valor nunca é superior a 128 (pixels), podemos economizar espaço usando ints de 8 bits (que tem um valor máximo de 255) * /

void setup ()

{atraso (100); // dê ao display etc. tempo para ligar display.begin (SSD1306_SWITCHCAPVCC, 0x3C); // isso é para inicializar o display display.clearDisplay (); // começa com uma tela em branco}

/ * observe que você não precisa digitar esses comentários são para referência …………..

o comando no qual vamos nos concentrar é display.drawBitmap, é isso que desenha nossa tela inicial. (bmpX, é o valor do eixo X na tela onde o ponto de âncora X do bitmap estará e bmpX e bmpY são os valores nos quais estamos interessados para criar movimento (bmpY, é o valor do eixo Y na tela onde a âncora Y ponto do bitmap será que obteremos os nomes de referência conforme os definimos em logo.c (LOGOPIC, é o nome do bitmap no arquivo #included logo.c (LOGOWIDTH, é quantos pixels transversais (X) para desenhar o bitmap do ponto âncora (LOGOHEIGHT, é quantos pixels abaixo (Y) para desenhar o bitmap do ponto âncora os pixels X e Y transversais podem ser inseridos manualmente, mas é apenas mais fácil usar os predefinidos do que lembrar todos eles (1, o último valor é a cor, pois a tela é mono 0 preto 1 branco. ok, comece a digitar a partir da próxima linha: ¬D lol * / void loop () {display.clearDisplay (); // em branco a tela // bitmap desenhado do superior esquerdo, x, y, nome do bitmap, largura X, altura Y, exibição de cores.drawBitmap (bmpX, bmpY, LOGOPIC, LOGOWIDTH, LOGOHEIGHT, 1); display.display (); // na verdade, isso atrai o buffer para a exibição sempre}

carregue o código do seu arduino e confirme que está funcionando (pic3).

Etapa 5: mover um bitmap Sprite

usando as instruções anteriores, use paint.net e faça um novo arquivo com 30x15 pixels (foto 1) e desenhe um carro rústico, nosso jovem designer começa com o pára-brisa primeiro (fotos 2 e 3).

novamente salve-o como um arquivo bmp do Windows (como na etapa 2), converta para um bitmap C (etapa 3) e coloque o arquivo car.c (ou o que você decidir) na mesma pasta de um arduino ino recém-criado (esboço) Arquivo.

(p.s. lembre-se de adicionar a linha #include em car.c isso costumava nos surpreender com frequência)

Primeiro vincule seu equivalente a car.c

#incluir

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

Exibição Adafruit_SSD1306 (128, 64); // define a resolução da tela

/ * bmpX / bmpY precisamos que sejam variáveis, pois mudamos esses valores e redesenhamos

a tela é como criamos o efeito de animação de movimento. hitSide e hitTop é como mantemos o sprite na tela * / uint8_t bmpX, bmpY = 0; // reservar memória para 2 8 bits (0-255) não precisamos de mais 128 será o maior número usado bool hitSide = 0; bool hitTop = 0;

void setup ()

{atraso (100); // dê ao display etc. tempo para ligar display.begin (SSD1306_SWITCHCAPVCC, 0x3C); // isso é para inicializar o display display.clearDisplay (); // começa com uma tela em branco

}

void loop ()

{display.clearDisplay (); // esvaziar a tela // bitmap desenhado do canto superior esquerdo, x, y, nome do bitmap, largura X, altura Y, exibição de cores.drawBitmap (bmpX, bmpY, CARSPRITE, CARWIDTH, CARHEIGHT, 1); // display.display (); // isso realmente atrai o buffer para a exibição sempre / * é assim que rastreamos a borda da tela e decidimos se adicionar um pixel mova de cima para baixo) ou remover um pixel (mover de baixo para cima) * / switch (hitSide) // isso escolhe a direção do carro com base no boole {case 0: bmpX ++; pausa;

caso 1:

bmpX--; pausa; } // essas 2 instruções if define o bool como verdadeiro ou falso if (bmpX == 0) {hitSide = 0; } if (bmpX == 96) // a largura da tela menos o carro {hitSide = 1; } // mesmo que acima para o eixo Y if (bmpY == 0) {hitTop = 0; } if (bmpY == 49) // altura da tela menos a altura do carro {hitTop = 1; } switch (hitTop) {case 0: bmpY ++; pausa; caso 1: bmpY--; pausa; }

}

você pode ver o programa funcionando no vídeo em anexo

Etapa 6: Fazendo o jogo de direção

Primeiro, começamos desenhando alguns carros ou obstáculos diferentes, como nos estágios anteriores do tutorial, tornando-os 30x15 pixels. Em seguida, os convertemos em bitmaps c e os vinculamos ao código.

#include // esses caminhos terão que mudar de acordo

// onde você armazena os arquivos // edit: acabei de descobrir que se você substituir // por "" você não precisa do caminho completo // com suas próprias bibliotecas #include

#incluir

#include #include

#incluir

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

Exibição Adafruit_SSD1306 (128, 64); // define os parâmetros de exibição

definir as variáveis e valores fixos

// define os pinos de entrada esses são os pinos no arduino, eles nunca mudam, então # define # define INTPIN 3 // apenas os pinos 2 e 3 podem ser pinos de interrupção em UNO #define UPPIN 4 // esses são pinos conectados ao switch relevante #define DWNPIN 5 # define LFTPIN 6 # define RHTPIN 7 # define SND 9 // define direções

#define DIRUP 1 // esses valores é o que a "cobra" olha para decidir-

#define DIRDOWN 2 // a direção em que a cobra vai viajar #define DIRLEFT 3 #define DIRRIGHT 4

uint8_t dirPressed = 0; // valor para registrar a direção para mover em qual pino foi alto

// loja de booleanos cujo pino foi alto

bool BUTUP = 0; bool BUTDWN = 0; bool BUTLFT = 0; bool BUTRHT = 0; // vars para a posição do carro uint8_t carPosX = 1; uint8_t carPosY = {0, 16, 32, 48}; // precisa de valor cahnging o array

uint8_t lanePosArr = {0, 16, 32, 48}; // array para armazenar onde cada pista está

uint8_t carPosYCnt = 0; uint8_t carYTmp = 0; // variáveis para as linhas na estrada uint8_t roadLineX1 = 51; // eles são predefinidos no início, então as linhas aparecem sem costura uint8_t roadLineX2 = 102; uint8_t roadLineX3 = 153; uint8_t roadLineX4 = 254; uint8_t roadLineX5 = 200;

// é quantos pixels a área de jogo se move de cada vez

uint8_t drawSpeed = 4;

// vars para o inimigo0

uint8_t inimigo0PosX = 255; uint8_t inimigo0PosY = 0; uint8_t inimigo1PosX = 255; uint8_t inimigo1PosY = 0; uint8_t inimigo2PosX = 255; uint8_t inimigo2PosY = 0;

// variável para aleatório atribuir um número de pista aos obstáculos

uint8_t laneGen = 0;

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

// contador de pontuação

pontuação longa = 0; // esta é a pontuação: / lol long compare = 0; // isso armazena a pontuação no último nível para comparar de volta com long highScore = 25; uint8_t metreCnt = 0;

é aqui que começamos as funções

// este é o conjunto de comandos se a interrupção for ativada void interruptressed () {delay (150); updateDirection (); } // atualize qual valor está na direção var verificando os bools DIR // -------------------------- ATUALIZAR DIREÇÃO (jogador) - ------------------------- void updateDirection () {//Serial.println("updateDirection Called "); BUTUP = digitalRead (UPPIN); BUTDWN = digitalRead (DWNPIN); BUTLFT = digitalRead (LFTPIN); BUTRHT = leitura digital (RHTPIN); if (BUTUP == true) {dirPressed = DIRUP; } if (BUTDWN == true) {dirPressed = DIRDOWN; } if (BUTLFT == true) {dirPressed = DIRLEFT; } if (BUTRHT == true) {dirPressed = DIRRIGHT; }

}

// ------------------------------- MOVE CAR --------------- -------------------------

// isso irá atualizar a tela que move o sprite do carro

void moveCar ()

{switch (dirPressed) {case DIRUP: carPosYCnt--; carPosY [carPosYCnt]; tom (SND, 100, 100); if (carPosYCnt == 255) {carPosYCnt = 0; } carYTmp = carPosY [carPosYCnt]; dirPressed = 0; // Serial.println ("carPosY up"); // Serial.println (carPosYCnt); pausa; case DIRDOWN: carPosYCnt ++; tom (SND, 100, 100); if (carPosYCnt == 4) {carPosYCnt = 3; } // Serial.println ("carPosY"); // Serial.println (carPosYCnt); carYTmp = carPosY [carPosYCnt]; dirPressed = 0; pausa; // carro comentado, capaz de se mover para a esquerda e para a direita, a detecção de colisão ainda não é tão boa / * case DIRLEFT: carPosX--; if (carPosX == 0) {carPosX = 1; } // Serial.println ("carPosX"); // Serial.println (carPosX); dirPressed = 0; pausa; * / case DIRRIGHT: // apenas por diversão, se você pressionar direito o jogo fará um som de ruído (SND, 100, 50); // carPosX ++; // if (carPosX == 128) // {// carPosX = 127; //} // Serial.println ("carPosX"); // Serial.println (carPosX); // dirPressed = 0; pausa; } updateDisplay (); }

// -------------------------- RANDOM POS X ------------------- -----------

uint8_t randomPosX () // essas 2 rotinas apenas geram posições aleatórias para os obstáculos

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

// --------------------------- RANDOM POS Y ------------------ ------------------

uint8_t randomPosY ()

{uint8_t laneVal = 0; pistaVal = aleatório (0, 4); // adiciona uma pista extra para aleatoriedade, ou seja, nenhum objeto na tela enquanto estiver nessa pista //Serial.println("RandomY "); //Serial.println(lanePosArr[laneVal]); return (lanePosArr [laneVal]); }// ------------------------------- DEFINIR VELOCIDADE DO JOGO -------------- -------------- void setGameSpeed () // isso impede que o nível passe de 20, tornando o jogo impossível de jogar {if (drawSpeed <21) {drawSpeed = drawSpeed + 2; }}// ------------------------------------ DETECTAR CRASH ---------- ----------------------- void detectCrash () {

if (inimigo0PosX = 0 && inimigo0PosY == carYTmp)

{// Serial.println ("Game Over CRAASSSSHHHHHHHEEEEDDD no Traffic 0"); fim de jogo(); } if (inimigo1PosX = 0 && inimigo1PosY == carYTmp) {//Serial.println("Jogo sobre CRAASSSSHHHHHHHEEEEDDD no tráfego 1 "); fim de jogo(); } if (inimigo2PosX = 0 && inimigo2PosY == carYTmp) {//Serial.println("Jogo sobre CRAASSSSHHHHHHHEEEEDDD no tráfego 2 "); fim de jogo(); }}

essas são as rotinas que desenham a tela.

// ------------------------------- DRAW ROAD --------------- --------------------- void drawRoad () // X, Y, comprimento, largura {display.fillRect (roadLineX1, 15, 30, 4, WHITE); display.fillRect (roadLineX1, 30, 30, 4, WHITE); display.fillRect (roadLineX1, 45, 30, 4, WHITE); display.fillRect (roadLineX2, 15, 30, 4, WHITE); display.fillRect (roadLineX2, 30, 30, 4, WHITE); display.fillRect (roadLineX2, 45, 30, 4, WHITE); display.fillRect (roadLineX3, 15, 30, 4, WHITE); display.fillRect (roadLineX3, 30, 30, 4, WHITE); display.fillRect (roadLineX3, 45, 30, 4, WHITE); display.fillRect (roadLineX4, 15, 30, 4, WHITE); display.fillRect (roadLineX4, 30, 30, 4, WHITE); display.fillRect (roadLineX4, 45, 30, 4, WHITE); display.fillRect (roadLineX5, 15, 30, 4, WHITE); display.fillRect (roadLineX5, 30, 30, 4, WHITE); display.fillRect (roadLineX5, 45, 30, 4, WHITE);

roadLineX1 = roadLineX1-drawSpeed;

roadLineX2 = roadLineX2-drawSpeed; roadLineX3 = roadLineX3-drawSpeed; roadLineX4 = roadLineX4-drawSpeed; roadLineX5 = roadLineX5-drawSpeed; display.display (); } // ----------------------------------------- DESENHE inimigos ---- --------------------------------------- void enemysDraw () {// X, Y, nome do bmp, largura, altura, exibição de cores.drawBitmap (inimigo0PosX, inimigo0PosY, ENEMY0, ENEMY0_WIDTH, ENEMY0_HEIGHT, 1); inimigo0PosX = inimigo0PosX-drawSpeed; display.drawBitmap (inimigo1PosX, inimigo1PosY, ENEMY1, ENEMY1_WIDTH, ENEMY1_HEIGHT, 1); inimigo1PosX = inimigo1PosX-drawSpeed; display.drawBitmap (inimigo2PosX, inimigo2PosY, ENEMY2, ENEMY2_WIDTH, ENEMY2_HEIGHT, 1); inimigo2PosX = inimigo2PosX-drawSpeed; display.display (); if (inimigo0PosX> 231 && inimigo0PosX231 && inimigo1PosX <255) {inimigo1PosX = randomPosX (); inimigo1PosY = randomPosY (); checkDuplicate (); }

if (inimigo2PosX> 231 && inimigo2PosX <255) {inimigo2PosX = randomPosX (); inimigo2PosY = randomPosY (); }} // ------------------------------------ ATUALIZAR EXIBIÇÃO -------- ---------------------------------------- void updateDisplay () {display.clearDisplay (); display.drawBitmap (carPosX, carPosY [carPosYCnt], CARSPRITE, 30, 15, 1); display.fillRect (100, 0, 28, 10, PRETO); display.setCursor (100, 0); display.setTextColor (BRANCO, PRETO); display.println (pontuação); display.display ();

}

// ------------------------- esperar pelo loop de pressionamentos ------------------- ------

// este é o código da tela inicial void waitForPress () {splashScreen (); bool esperando = 0; // o loop termina quando isso for verdadeiro display.clearDisplay (); enquanto (esperando == 0) {

display.fillRect (19, 20, 90, 32, PRETO); // fundo em branco para o texto

display.setTextColor (WHITE); display.setCursor (23, 24); display.setTextSize (0); display.println ("Reckless"); display.setCursor (36, 34); display.println ("Racer"); display.drawBitmap (74, 24, CARSPRITE, CARWIDTH, CARHEIGHT, 1); // x y w h r col display.drawRoundRect (21, 21, 86, 23, 4, WHITE); // border Snake display.drawRect (19, 20, 90, 33, WHITE); // caixa de borda - 3 display.setCursor (25, 43); display.setTextSize (0); // fonte de volta ao normal display.println ("pressione qualquer tecla"); display.fillRect (0, 0, 127, 8, PRETO); display.setCursor (10, 0); display.print ("Pontuação alta:"); // exibe a pontuação mais alta display.print (highScore); display.display (); esperando = digitalRead (INTPIN); // verifique se a tecla pressionada em espera mudará para 1 terminando enquanto dirPressed = 0; // reset pressionado o botão para nenhuma direção}} // -------------------------------------- ----- ATUALIZAR JOGO ----------------------------------------- void updateGame () {moverCarro (); drawRoad (); enemysDraw (); // inimigo1Draw (); // inimigo2Draw (); metreCnt ++; detectCrash (); if (metreCnt == 5) // adiciona um ponto a cada 10 ciclos para aumentar a pontuação {metreCnt = 0; pontuação ++; } if (score == compare + 5) // acelera o jogo a cada 5 pontos até um máximo de 20 velocidades {compare = score; setGameSpeed (); } noTone (SND); updateDisplay ();

}

// ------------------------------ FIM DE JOGO---------------- ------------------------------

// esta rotina desenha as linhas ao redor do carro do herói morto e exibe o jogo na tela

void gameOver ()

{tom (SND, 200, 200); // reproduz som uint8_t linePosX, linePosY, pixwidth, pixheight = 0; // define vars para desenhar caixas ao redor do carro linePosX = carPosY; linePosY = carYTmp; pixwidth = 30; pixheight = 15; display.drawRect (linePosX, linePosY, pixwidth, pixheight, WHITE); display.display (); for (int i = 0; i <= 26; i ++) // circunda o carro em retângulos simulando explosão {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 (); tom (SND, i * 20, 50); atraso (10); } display.setTextSize (2); display.setTextColor (BRANCO, PRETO); display.setCursor (10, 23); tom (SND, 50, 500); display.print ("GAME"); display.display (); atraso (500); tom (SND, 40, 500); display.print ("OVER"); display.setTextSize (0); display.display (); atraso (3000); reiniciar o jogo(); waitForPress (); }

// ----------------------------------------- REINICIAR O JOGO ----- -------------------------------------------------- -----

void restartGame () // copia a pontuação alta e redefine todas as estatísticas e gera posições aleatórias

{if (score> = highScore) // verifique se a pontuação é maior do que a pontuação alta {highScore = score; // único if statment para atualizar a pontuação mais alta}

pontuação = 0;

drawSpeed = 4; metreCnt = 0; carPosYCnt = 0; inimigo0PosX = randomPosX (); inimigo0PosY = randomPosY (); inimigo1PosX = randomPosX (); inimigo1PosY = randomPosY (); inimigo2PosX = randomPosX (); inimigo2PosY = randomPosY (); noTone (SND);

checkDuplicate ();

}

// ------------------------------------------------ - VERIFICAR DUPLICADO ----------------------------------------------- ------ void checkDuplicate () // estes verificam se os obstáculos ocupam o mesmo espaço de jogo {// Serial.println ("duplicado verificado"); if (inimiga2PosX> 230 && inimiga2PosX <255) {enquanto (inimiga2PosY == inimiga1PosY || inimiga2PosY == inimiga0PosY) {inimiga2PosY = randomPosY (); }}

if (inimigo0PosX> 230 && inimigo0PosX230 && inimigo2PosXenemy1PosX && inimigo2PosX230 && inimigo0PosXenemy1PosX && inimigo0PosX

//------------------------------------------- TELA DE ABERTURA --- --------------------------------

void splashScreen ()

{display.clearDisplay (); display.drawBitmap (0, 0, CRASH, CRASHWIDTH, CRASHHEIGHT, 1); display.display (); atraso (2000); } // ----------------------------------------------- CONFIGURAR ------------------------------------------------- ----------- configuração vazia () {atraso (100); // deixe as coisas começarem // Serial.begin (9600); // descomente este e todo o Serial. comandos para display.begin de diagnóstico de falhas (SSD1306_SWITCHCAPVCC, 0x3C); display.clearDisplay (); display.setTextColor (BRANCO, PRETO); display.setTextWrap (false); display.dim (0); pinMode (INTPIN, INPUT); pinMode (UPPIN, INPUT); pinMode (DWNPIN, INPUT); pinMode (LFTPIN, INPUT); pinMode (RHTPIN, INPUT);

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

// coloca obstruções aleatoriamente inimigo0PosX = randomPosX (); inimigo0PosY = randomPosY (); inimigo1PosX = randomPosX (); inimigo1PosY = randomPosY (); inimigo2PosX = randomPosX (); inimigo2PosY = randomPosY (); checkDuplicate (); // verifique se há localizações duplicadas // Serial.println ("setup Complete"); tela de abertura(); waitForPress (); } // ----------------------------------------------- ----- CICLO -------------------------------------------- ----------

void loop ()

{updateGame (); }

e é basicamente isso, quaisquer modificações e comentários serão bem-vindos. Questões que precisamos resolver a cintilação da tela, precisamos descobrir como diminuí-la e os carros inimigos ainda são capazes de ocupar o mesmo espaço.