#include <Wire.h> 
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);		

//boto~es
const int Botao1 = 2;
const int Botao2 = 4;
const int Botao3 = 7;

//buzzer
const int Buzzer = 8;

//leds
const int Led1 = 11;   // Ação (flash de pulo/tiro) — digitalWrite, não precisa de PWM
const int Led2 = 10;   // Posição (ar - Dino)
const int Led3 = 9;    // Recarga (cooldown de pulo/tiro) — [FIX] movido do pino 11 pro 9: pino 11 usa o mesmo timer do tone(), o que travava o analogWrite

unsigned long led1DesligaEm = 0;
bool led1Ligado = false;

const int LED_BRILHO = 100;   // [LED] brilho reduzido (0-255) p/ Led2/Led3 -> corrente segura c/ resistor de 100 ohms

                    			// GERAL_________________________
//variavéis
unsigned long tempoAnterior = 0;
bool UltBotao1 = HIGH;
bool UltBotao2 = HIGH;
bool gameOver = false;
int tempoSpawn = 2;

bool pedidoPulo = false;   // [FIX] flag que captura o clique do pulo instantaneamente

struct Sprite {
  int pos;
  int ultPos;
  byte linha;
  int ultLinha;
  
  byte sprite1;
  byte sprite2;
  
  byte largura;
  
  bool ativo;
  byte tipo;
  
  bool redesenhar;
  bool visivel;
  bool quebravel;
};

//functions
void atualizarSprite(Sprite &spr){

  // APAGA o sprite anterior se:
  // - ele se moveu
  // - mudou de linha
  // - ficou inativo
  // - ficou invisível
  if(spr.ultPos >= -1 &&
     (spr.pos != spr.ultPos ||
      spr.linha != spr.ultLinha ||
      !spr.ativo ||
      !spr.visivel)){

    for(int i = 0; i < spr.largura; i++){

      int coluna = spr.ultPos + i;

      if(coluna >= 0 && coluna <= 15){
        lcd.setCursor(coluna, spr.ultLinha);
        lcd.print(" ");
      }
    }
  }

  // SÓ DESENHA se estiver ativo E visível
  if(spr.ativo && spr.visivel){

    if(spr.pos >= 0 && spr.pos <= 15){
      lcd.setCursor(spr.pos, spr.linha);
      lcd.write(byte(spr.sprite1));
    }

    if(spr.largura == 2 &&
       spr.pos + 1 >= 0 &&
       spr.pos + 1 <= 15){

      lcd.setCursor(spr.pos + 1, spr.linha);
      lcd.write(byte(spr.sprite2));
    }
  }

  spr.ultPos = spr.pos;
  spr.ultLinha = spr.linha;
}


// [LED] flash rápido e não-bloqueante do Led1 (ação)
void piscarLed1(int duracaoMs){
  digitalWrite(Led1, HIGH);
  led1DesligaEm = millis() + duracaoMs;
  led1Ligado = true;
}

// [LED] chamada todo loop() para desligar o Led1 sozinho após a duração
void atualizarLed1(){
  if(led1Ligado && millis() >= led1DesligaEm){
    digitalWrite(Led1, LOW);
    led1Ligado = false;
  }
}

// [LED] apaga os 3 (usado ao voltar pro menu e ao terminar qualquer jogo)
void ledsDesligarTudo(){
  digitalWrite(Led1, LOW);
  analogWrite(Led2, 0);
  analogWrite(Led3, 0);
  led1Ligado = false;
}


void somGameover(){ 
  tone(Buzzer, 523, 120);  // C5
  delay(130);
  tone(Buzzer, 494, 120);  // B4
  delay(130);
  tone(Buzzer, 440, 120);  // A4
  delay(130);
  tone(Buzzer, 392, 120);  // G4
  delay(130);
  tone(Buzzer, 349, 300);  // F4 (nota final mais longa)
  delay(320);
  noTone(Buzzer);
}


					  	//MENU_________________________________________________
//variaveis
int Tela = 0;
int TelaAnterior = -1;

int scoreDino = 0;
int HIDino = 0;
int scoreBShot = 0;
int HIBShot = 0;

int JogoSelecionado = 1;
int UltJogoSelecionado = -1;

//functions
void desenharMenu(){
      lcd.setCursor(0,1);
      lcd.print("                ");
      lcd.setCursor(0,1);      
  
      switch(JogoSelecionado){
        case 1:					//Chrome DIno selecionado
        lcd.print("ChromeDino");
        lcd.setCursor(12, 1);
        lcd.print(HIDino);
        break;     
      
        case 2:					//jogo 2 selceionado
        lcd.print("BShot");
        lcd.setCursor(12, 1);
        lcd.print(HIBShot);
        break;     
      
        case 3:					//jogo 3 selecionado
        lcd.print("jogo 3");
        break;
        
        case 4:					//jogo 4 selecionado
        lcd.print("jogo 4");
        break;
        
        case 5:					//jogo 5 selecionado
        lcd.print("jogo 5");
        break;
      }
}


void checarBotaoMenu(){
  if(digitalRead(Botao3)==LOW){
    Tela = 0;
    while (digitalRead(Botao3) == LOW) {      // espera o botão ser solto
    }
    delay(20); 
  }
}
  

					//DINO CHrome __________________________________________
//variaveis
byte dino1[8] = {
  B00000, B00000, B00000, B10001, B11111, B11111, B00111, B00010
};
byte dino2[8] = {
  B11110, B11011, B11111, B11100, B11110, B11010, B11000, B10000
};
byte cactus[8] = {
  B00100, B00101, B01101, B01100, B00100, B00100, B00100, B00100
};
byte passaro1[8] = {
  B00000, B00110, B01110, B11111, B00011, B00000, B00000, B00000
};
byte passaro2[8] = {
  B10000, B11000, B11100, B11111, B11110, B11100, B00000, B00000
};

Sprite obstaculos[4];
Sprite dino;

int tempoPulo = 0;
int recargaPulo = 0;
int veloDino = 200;


//functions
void iniciarDino(){
  tempoPulo = 0;
  recargaPulo = 0;
  tempoSpawn = 2;
  scoreDino = 0;
  veloDino = 200;
  gameOver = false;
  pedidoPulo = false;

  dino.pos = 2;
  dino.ultPos = -1;
  dino.linha = 1;
  dino.ultLinha = -1;
  dino.sprite1 = 2;
  dino.sprite2 = 3;
  dino.largura = 2;
  dino.ativo = true;
  dino.visivel = true;

  lcd.createChar(1, cactus);
  lcd.createChar(2, dino1);
  lcd.createChar(3, dino2);
  lcd.createChar(4, passaro1);
  lcd.createChar(5, passaro2);
  lcd.clear();
  for(int i=0;i<4;i++){
  obstaculos[i].ativo=false;
  }

  atualizarSprite(dino);

  ledsDesligarTudo();   // [LED] começa o jogo com os leds apagados
}


void atualizarColisaoDino(Sprite &spr){
  for(int i = 0; i < 4; i++){
      if(obstaculos[i].ativo){		
        if((spr.pos == dino.pos ||
          spr.pos == dino.pos + 1 ||
          (spr.pos + spr.largura - 1) == dino.pos ||
          (spr.pos + spr.largura - 1) == dino.pos + 1)
          && spr.linha == dino.linha){    

            gameOver = true;   
          }
      }
  }
}


void atualizarPulo(){
  // [FIX] usa a flag pedidoPulo (capturada fora do gate) em vez de ler o botão aqui
  if (pedidoPulo && dino.linha == 1 && recargaPulo == 0) {
    dino.linha = 0;
    atualizarSprite(dino);
    tempoPulo = 6;   // fica X ciclos no ar
    tone(Buzzer, 880, 60);
    piscarLed1(60);                  // [LED] flash de ação no pulo
    analogWrite(Led2, LED_BRILHO);   // [LED] indica que está no ar
  }
  pedidoPulo = false;   // consome o pedido, evitado ficar "pulando sozinho"

  // cooldown  
  if (tempoPulo > 0) {
    tempoPulo--;
    if (tempoPulo == 0) {
        dino.linha = 1;
        atualizarSprite(dino);
        analogWrite(Led2, 0);            // [LED] voltou pro chão
        recargaPulo = 1;     //dino NAO pode pular por X ciclos
        analogWrite(Led3, LED_BRILHO);   // [LED] entrou em recarga
    }
  }
  if (recargaPulo > 0) {
  recargaPulo--;
    if(recargaPulo == 0){
      analogWrite(Led3, 0);   // [LED] recarga concluída
    }
  }
}
      

void atualizarSpawn(){ 
  if(tempoSpawn > 0){
    tempoSpawn--;
  }else{
    for(int i = 0; i < 4; i++){
      if(!obstaculos[i].ativo){			//coiseia uma vez em todos os obstaculos quais ativo = false devido
       obstaculos[i].ativo = true;		// mudar a var ativo para = true
       obstaculos[i].pos = 16;
       obstaculos[i].ultPos = -1;
       obstaculos[i].ultLinha = -1;
       obstaculos[i].visivel = true;
       obstaculos[i].tipo = random(0,2);

        if(obstaculos[i].tipo == 0){      //cacuto
         obstaculos[i].linha = 1;
         obstaculos[i].largura = 1;
         obstaculos[i].sprite1 = 1;
        }else{
         obstaculos[i].linha = random(0,2); //passaro
         obstaculos[i].largura = 2;
         obstaculos[i].sprite1 = 4;
         obstaculos[i].sprite2 = 5;
        }
      tempoSpawn = random(6,10);  //tempo de spawn dentro de X a X ciclos
      break; //-> faz o código sair do for
      }
    }
  }  
}


void moverObstaculos(){ 
  for(int i = 0; i < 4; i++){         //coiseia sempre q obstaculo = ativo
    if(!obstaculos[i].ativo){
      continue;
    }             
    obstaculos[i].pos--;

    if(obstaculos[i].pos < -1){
        obstaculos[i].ativo = false;       
    }
    atualizarSprite(obstaculos[i]);
  }
}

              //[[BIG SHOT]]________________________________________________
//variaveis
byte caixa1[8] = {
  B11111, B10001, B10001, B10001, B10001, B10001, B10001, B11111
};
byte caixa2[8] = {
  B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111
};
byte bomba[8] = {
  B00000, B00011, B00100, B01110, B11111, B11111, B11111, B01110
};
byte bombaAnim[8] = {
  B00000, B00011, B00100, B01110, B11011, B10001, B11011, B01110
};
byte amonguinho[8] = {   //SUSSSSSS
  B00000, B00000, B01110, B11100, B11110, B11110, B01110, B01010
};
byte raio1[8] = {
   B00000,
  B00000,
  B11111,
  B11111,
  B11111,
  B11111,
  B00000,
  B00000
};
byte raio2[8] = {
  B00000,
  B00000,
  B00000,
  B11111,
  B11111,
  B00000,
  B00000,
  B00000
};
byte tiro[8] = {
  B00000, B00000, B00000, B01110, B00000, B00000, B00000, B00000
};

Sprite amonguinhos;
Sprite tiros[6];
Sprite objetos[10];

int indiceSpawn = 0;
bool padrao = false;
int veloBShot = 200;
int recargaTiro = 0;
bool explosaoAtiva = false;
byte explosaoLinha = 0;
byte explosaoFase = 0;
byte explosaoCiclos = 0;
unsigned long meioTempoTiro = 0;
unsigned long tempoTiroInteiro= 0;

//functions
void iniciarBShot(){
  tempoSpawn = 2;
  padrao = false;
  veloBShot = 200;
  recargaTiro = 0;
  explosaoAtiva = false;
  explosaoLinha = 0;
  explosaoFase = 0;
  explosaoCiclos = 0;
  scoreBShot = 0;
  gameOver = false;

  amonguinhos.pos = 2;
  amonguinhos.ultPos = -1;
  amonguinhos.linha = 0;
  amonguinhos.ultLinha = -1;
  amonguinhos.sprite1 = 1;
  amonguinhos.largura = 1;
  amonguinhos.ativo = true;
  amonguinhos.visivel = true;

  lcd.createChar(1, amonguinho);
  lcd.createChar(2, caixa1);
  lcd.createChar(3, caixa2);
  lcd.createChar(4, bomba);
  lcd.createChar(5, raio1);
  lcd.createChar(6, raio2);
  lcd.createChar(7, tiro);
  lcd.clear();

  atualizarSprite(amonguinhos);

  for(int i=0;i<6;i++){
  tiros[i].ativo=false;
  }
  for(int i=0;i<10;i++){
  objetos[i].ativo=false;
  }

  ledsDesligarTudo();                    // [LED] reset visual
}



void trocarLinha(){
  // [FIX] leitura instantânea do botão, chamada fora do gate de tempo
  bool leitura = digitalRead(Botao1);
  if(leitura == LOW && UltBotao1 == HIGH){
    amonguinhos.linha = (amonguinhos.linha == 1) ? 0 : 1;
    atualizarSprite(amonguinhos);
  }
  UltBotao1 = leitura;
}



void criarTiro(){
  if(recargaTiro == 0){
    for(int i = 0; i < 6; i++){               //segmento responsável por criar o tiro
      if(!tiros[i].ativo){
        tiros[i].ativo = true;
        tiros[i].pos = amonguinhos.pos + 1;
        tiros[i].linha = amonguinhos.linha;
        tiros[i].ultPos = -1;
        tiros[i].ultLinha = -1;
        tiros[i].sprite1 = 7;
        tiros[i].largura = 1;
        tiros[i].visivel = true;
        atualizarSprite(tiros[i]); 
        tone(Buzzer, 1500, 40);     // beep de "laser" ao atirar
        atualizarTiro();            // caso tiro spawne no objeto quebra igual
        piscarLed1(40);             // [LED] flash de ação no disparo
        break;                              //---
      }
    }
  recargaTiro = 3;                 //cooldown XX do tiro
  analogWrite(Led3, LED_BRILHO);   // [LED] entrou em recarga
  }
}



void moverTiro(){
  for(int j = 0; j < 6; j++){
        if(!tiros[j].ativo)
            continue;
        tiros[j].pos++;
        atualizarSprite(tiros[j]);
  }
}


void atualizarTiro(){

    for(int j = 0; j < 6; j++){

        if(!tiros[j].ativo)
            continue;

        for(int i = 0; i < 10; i++){

            if(!objetos[i].ativo)
                continue;

            if(objetos[i].pos == tiros[j].pos &&
               objetos[i].linha == tiros[j].linha){

                // O tiro sempre desaparece
                tiros[j].ativo = false;

                //// guarda informações antes de destruir
                byte tipoObjeto = objetos[i].tipo;
                byte linhaObjeto = objetos[i].linha;

                // Só quebra se for quebrável
                if(objetos[i].quebravel){
                  objetos[i].ativo = false;
                  atualizarSprite(objetos[i]);

                    if(tipoObjeto == 3){
                       objetos[i].ativo = false;
                       atualizarSprite(objetos[i]);
                       iniciarExplosao(linhaObjeto);
                    }
                }
                break; // Agora sim, sai do for dos objetos
            }
        }

        if(tiros[j].ativo && tiros[j].pos > 15){
            tiros[j].ativo = false;
            atualizarSprite(tiros[j]);
        }
    }
}

  

void criarObjeto(byte linha, byte tipo){
    for(int i = 0; i < 10; i++){
        if(!objetos[i].ativo){
            objetos[i].ativo = true;
            objetos[i].pos = 16;
            objetos[i].ultPos = -1;
            objetos[i].linha = linha;
            objetos[i].ultLinha = -1;            
            objetos[i].largura = 1;
            objetos[i].visivel = true;
            if(tipo == 1){
              objetos[i].sprite1 = 2; //caixa quebrável
              objetos[i].tipo = 1;
              objetos[i].quebravel = true;
            }else if(tipo == 2){
              objetos[i].sprite1 = 3; //caixa indestrutível
              objetos[i].tipo = 2;
              objetos[i].quebravel = false;
            }else if(tipo == 3){
              objetos[i].sprite1 = 4;   //bomba
              objetos[i].tipo = 3;
              objetos[i].quebravel = true;
            }
            break;
        }
    }
}



void moverObjeto(){
  for(int i = 0; i < 10; i++){
    if(!objetos[i].ativo){
        continue;
    }    
    objetos[i].pos--;
    atualizarSprite(objetos[i]);    

    if(objetos[i].pos < -1){
        objetos[i].ativo = false;
        atualizarSprite(objetos[i]);
    }
  }
}



void atualizarColisaoAmong(Sprite &spr){
  if(spr.pos == amonguinhos.pos && spr.linha == amonguinhos.linha){     
    gameOver = true;         
  }
}



void desenharExplosao() {

  for(int coluna = 0; coluna < 16; coluna++){

    lcd.setCursor(coluna, explosaoLinha);

    if(explosaoFase == 0){
      lcd.write(byte(5));   // raio1
    }else{
      lcd.write(byte(6));   // raio2
    }
  }

}



  void iniciarExplosao(byte linha){

  explosaoAtiva = true;
  explosaoLinha = linha;

  // começa no sprite 1
  explosaoCiclos = 0;
  explosaoFase = 0;
  
  // SOM
  tone(Buzzer, 180, 100);
  delay(110);

  tone(Buzzer, 100, 120);
  delay(130);

  tone(Buzzer, 60, 180);

  // ------------------------------------
  // PROCESSA TODOS OS OBJETOS DA LINHA
  // ------------------------------------

  for(int i = 0; i < 10; i++){

    if(!objetos[i].ativo)
      continue;

    if(objetos[i].linha != explosaoLinha)
      continue;

    // Se for quebrável, destrói
    if(objetos[i].quebravel){

      objetos[i].ativo = false;

    }else{

      // Se não for quebrável,
      // continua existindo, mas fica invisível
      objetos[i].visivel = false;
    }

    atualizarSprite(objetos[i]);
  }

  // ------------------------------------
  // DESENHA O PRIMEIRO FRAME DO RAIO
  // ------------------------------------

  desenharExplosao();
  }




  void atualizarExplosao(){

  if(!explosaoAtiva)
    return;

  // ============================================
  // A EXPLOSÃO É PERIGOSA ENQUANTO ESTIVER ATIVA
  // ============================================

  if(amonguinhos.linha == explosaoLinha){
    gameOver = true;
  }


  // ============================================
  // CICLO 1
  // ============================================

  if(explosaoCiclos == 0){

    explosaoCiclos = 1;

    // troca UMA VEZ:
    // raio1 -> raio2
    explosaoFase = 1;

    desenharExplosao();

    return;
  }


  // ============================================
  // CICLO 2 TERMINOU
  // ============================================

  if(explosaoCiclos == 1){

    explosaoCiclos = 2;

    // limpa o raio
    lcd.setCursor(0, explosaoLinha);
    lcd.print("                ");

    explosaoAtiva = false;

    // ========================================
    // objetos indestrutíveis voltam
    // ========================================

    for(int i = 0; i < 10; i++){

      if(!objetos[i].ativo)
        continue;

      if(objetos[i].linha == explosaoLinha){

        objetos[i].visivel = true;
        atualizarSprite(objetos[i]);
      }
    }

    return;
  }
}



  
void setup(){				//setup--não é gamer ________________________________
  lcd.init();
  lcd.backlight();
  pinMode(Botao1, INPUT_PULLUP);
  pinMode(Botao2, INPUT_PULLUP);
  pinMode(Botao3, INPUT_PULLUP);
  pinMode(Led1, OUTPUT);   // [LED]
  pinMode(Led2, OUTPUT);   // [LED]
  pinMode(Led3, OUTPUT);   // [LED]
  ledsDesligarTudo();      // [LED]
  Tela = 0;
  randomSeed(analogRead(A0));
  Serial.begin(9600);
}



void loop(){                    //void loop__________________________________não é gamer
  Serial.println(gameOver);

  atualizarLed1();   // [LED] desliga o flash do Led1 sozinho quando a duração passar

  switch(Tela){  
    
  case 0:				        		// MENU______________________________________________
  if(Tela != TelaAnterior) {	//essa estrutura é meio q um espaço				
	lcd.clear(); 				        //onde as coisas só vão acontecer 1x
    lcd.setCursor(0,0);		
    lcd.print("Selecione o jogo");
    desenharMenu();
    TelaAnterior = Tela;
	UltJogoSelecionado = JogoSelecionado;
    ledsDesligarTudo();   // [LED] volta pro menu com tudo apagado
  }
      
  if(digitalRead(Botao1)==LOW && JogoSelecionado>1){
    JogoSelecionado--;
    delay (200);   
  }
  if(digitalRead(Botao2)==LOW && JogoSelecionado<2){
    JogoSelecionado++;
    delay (200);
  }
    
  if(JogoSelecionado != UltJogoSelecionado){
  	desenharMenu();
  UltJogoSelecionado = JogoSelecionado;
  }  
              
  if(digitalRead(Botao3) == LOW) {       //escolhe o jogo selecionado
  Tela = JogoSelecionado;
  
  while (digitalRead(Botao3) == LOW) {      // espera o botão ser solto
  }
  delay(20);    
  }
    
  break;                      //FIM DO menue!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    
    
  case 1:				        							// Chrome Dino tela_____________________________
  if(Tela != TelaAnterior) {  
	  iniciarDino();    //prep
    TelaAnterior = Tela;
  }	        
  checarBotaoMenu();

  // [FIX] captura o clique do pulo AQUI, todo loop(), fora do gate de tempo
  {
    bool leituraBotao1 = digitalRead(Botao1);
    if(leituraBotao1 == LOW && UltBotao1 == HIGH){
      pedidoPulo = true;
    }
    UltBotao1 = leituraBotao1;
  }

  for(int i = 0; i < 4; i++){
    if(obstaculos[i].ativo)
        atualizarColisaoDino(obstaculos[i]);
  }
    
  //logica do jogo  
  if(millis() - tempoAnterior >= veloDino){		//XX velocidade do jogo
  atualizarPulo();
  atualizarSpawn();
  moverObstaculos();
     

    
    
  //velocidade do gueime
  veloDino = map(scoreDino, 0, 1000, 200, 70);
    if(veloDino < 70){           //X max velo
      veloDino = 70;
    }
    
    
  //atualização de variaveis
  scoreDino++;
    
  tempoAnterior = millis();
  }

  if(gameOver){
    if(scoreDino > HIDino){
      HIDino = scoreDino;
    }
    delay(70);
    atualizarSprite(dino);
    somGameover();
    ledsDesligarTudo();   // [LED] desliga todos os leds ao terminar o jogo
    delay(200);
    Tela = 99; 
  }
    
  break;													//fim do dino!!!!!!!!!!!!!!!!!!!!!!!!!!!
    
    
  case 2:				        		      // BShot______________________________________________
  if(Tela != TelaAnterior) {
    iniciarBShot();
    TelaAnterior = Tela;
  }
  checarBotaoMenu();

  // [FIX] leituras instantâneas de botão, fora do gate de tempo
  trocarLinha();

  {
    bool leituraBotao2 = digitalRead(Botao2);
    if(leituraBotao2 == LOW && UltBotao2 == HIGH){
      criarTiro();
    }
    UltBotao2 = leituraBotao2;
  }
  
  //atualiza a colisao do amonguinhos
  for(int i = 0; i < 10; i++){
    if(objetos[i].ativo)
        atualizarColisaoAmong(objetos[i]);
  }
  
  if(millis() - meioTempoTiro >= 110){  //velocidade do tiro
    moverTiro();
    atualizarTiro();
    meioTempoTiro = millis();
  }



  if(millis() - tempoAnterior >= veloBShot){   //abaixo desse if tudo está sujeito ao tempo de ciclo do jogo

  atualizarExplosao();

  //spawna os objetos
  if(tempoSpawn > 0){
    tempoSpawn--;
  } else {  
      if(!padrao){
        if(scoreBShot < 40){
          indiceSpawn = random(0, 3);
        }else if(scoreBShot < 60){
          indiceSpawn = random(2, 5);
        }else if(scoreBShot < 100){
          indiceSpawn = random(3, 7);
        }else if(scoreBShot < 170){
          indiceSpawn = random(3, 10);
        }else{
          indiceSpawn = random(7, 18);
        }
      }
      switch (indiceSpawn) {    //case dos padroes
        case 0:
         criarObjeto(0, 2);
         tempoSpawn = 7;
         break;  
         
        case 1:
         criarObjeto(1, 2);
         tempoSpawn = 7;
         break;  
                            //-
        case 2:
         criarObjeto(0, 1);
         criarObjeto(1, 1);
         tempoSpawn = 7;
         break;

        case 3:
         criarObjeto(0, 1);
         criarObjeto(1, 2);
         tempoSpawn = 7;
        break;      

        case 4:
         criarObjeto(0, 2);
         criarObjeto(1, 1);
         tempoSpawn = 7;
        break;
                            //-
        case 5:
         criarObjeto(0, 2);
         criarObjeto(1, 3);
         tempoSpawn = 7;
        break;

        case 6:
         criarObjeto(0, 3);
         criarObjeto(1, 2);
         tempoSpawn = 6;
        break;
                            //-
                            //padr1
        case 7:
         criarObjeto(0, 2);
         tempoSpawn = 3;
         padrao = true;
         indiceSpawn = 8;
        break;

        case 8:
         criarObjeto(1, 2);
         tempoSpawn = 3;
         indiceSpawn = 71;
        break;
         
        case 71:
         criarObjeto(0, 2);
         tempoSpawn = 3;
         indiceSpawn = 72;
        break;

        case 72:
         criarObjeto(1, 2);
         tempoSpawn = 3;
         indiceSpawn = 73;
        break;

        case 73:
         criarObjeto(0, 2);
         tempoSpawn = 3;
         indiceSpawn = 74;
        break;

        case 74:
         criarObjeto(1, 2);
         tempoSpawn = 7;
         padrao = false;
        break;
                                //padr2
case 9:
  criarObjeto(0, 2);
  tempoSpawn = 3;
  padrao = true;
  indiceSpawn = 91;
break;

case 91:
  criarObjeto(0, 2);
  tempoSpawn = 4;
  indiceSpawn = 92;
break;

case 92:
  criarObjeto(1, 2);
  tempoSpawn = 3;
  indiceSpawn = 93;
break;

case 93:
  criarObjeto(1, 2);
  tempoSpawn = 7;
  padrao = false;
break;

                                  //padr3
case 10:
  criarObjeto(0, 2);
  tempoSpawn = 3;
  padrao = true;
  indiceSpawn = 101;
break;

case 101:
  criarObjeto(1, 3);
  tempoSpawn = 3;
  indiceSpawn = 102;
break;

case 102:
  criarObjeto(0, 3);
  tempoSpawn = 3;
  indiceSpawn = 103;
break;

case 103:
  criarObjeto(1, 2);
  tempoSpawn = 7;
  padrao = false;
break;
                              //padr4
case 11:
  criarObjeto(0, 3);
  tempoSpawn = 4;
  padrao = true;
  indiceSpawn = 111;
break;

case 111:
  criarObjeto(1, 2);
  tempoSpawn = 4;
  indiceSpawn = 112;
break;

case 112:
  criarObjeto(0, 3);
  tempoSpawn = 7;
  padrao = false;
break;
                              //padr5
case 12:
  criarObjeto(0, 1);
  criarObjeto(1, 2);
  tempoSpawn = 3;
  padrao = true;
  indiceSpawn = 121;
break;
case 121:
  criarObjeto(0, 3);
  tempoSpawn = 7;
  padrao = false;
break;
                            //padr6
case 13:
  criarObjeto(0, 2);
  criarObjeto(1, 1);
  tempoSpawn = 3;
  padrao = true;
  indiceSpawn = 131;
break;

case 131:
  criarObjeto(1, 3);
  tempoSpawn = 7;
  padrao = false;
break;
                          //padr7
case 14:
  criarObjeto(0, 2);
  criarObjeto(1, 1);
  tempoSpawn = 1;
  padrao = true;
  indiceSpawn = 141;
break;

case 141:
  criarObjeto(0, 2);
  criarObjeto(1, 1);
  tempoSpawn = 1;
  padrao = true;
  indiceSpawn = 142;
break;

case 142:
  criarObjeto(0, 2);
  criarObjeto(1, 1);
  tempoSpawn = 7;
  padrao = false;
break;
                        //padr8
case 15:
  criarObjeto(0, 1);
  criarObjeto(1, 2);
  tempoSpawn = 1;
  padrao = true;
  indiceSpawn = 151;
break;

case 151:
  criarObjeto(0, 1);
  criarObjeto(1, 2);
  tempoSpawn = 1;
  padrao = true;
  indiceSpawn = 152;
break;

case 152:
  criarObjeto(0, 1);
  criarObjeto(1, 2);
  tempoSpawn = 7;
  padrao = false;
break;
                          //padr9
case 16:
  criarObjeto(0, 2);
  criarObjeto(1, 3);
  tempoSpawn = 1;
  padrao = true;
  indiceSpawn = 161;
break;

case 161:
  criarObjeto(0, 2);
  criarObjeto(1, 1);
  tempoSpawn = 1;
  padrao = true;
  indiceSpawn = 162;
break;

case 162:
  criarObjeto(0, 2);
  criarObjeto(1, 1);
  tempoSpawn = 7;
  padrao = false;
break;
                      //padr10
case 17:
  criarObjeto(0, 3);
  criarObjeto(1, 2);
  tempoSpawn = 1;
  padrao = true;
  indiceSpawn = 171;
break;

case 171:
  criarObjeto(0, 1);
  criarObjeto(1, 2);
  tempoSpawn = 1;
  padrao = true;
  indiceSpawn = 172;
break;

case 172:
  criarObjeto(0, 1);
  criarObjeto(1, 2);
  tempoSpawn = 7;
  padrao = false;
break;



    }
  }

  
  moverObjeto();
  atualizarTiro();
  //atualiza recarga
  if(recargaTiro > 0){
    recargaTiro--;
    if(recargaTiro == 0){
      analogWrite(Led3, 0);   // [LED] recarga do tiro concluída
    }
  }
  


    veloBShot = map(scoreBShot, 0, 1000, 200, 70);
    if(veloBShot < 70){           //X max velo
      veloBShot = 70;
    }

    scoreBShot++;               // [FIX] faltava ; e faltava esse incremento (vel/recorde nunca mudavam)
    tempoAnterior = millis();
  }


    if(gameOver){
    if(scoreBShot > HIBShot){
      HIBShot = scoreBShot;
    }
    delay(70);
    somGameover();
    ledsDesligarTudo();   // [LED] desliga todos os leds ao terminar o jogo
    delay(200);
    Tela = 99; 
  }


  
  break;                      //fim do BShot!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
    
    
  case 3:				        		// jogo 3 tela
  if(Tela != TelaAnterior) {
    lcd.clear();
    lcd.print("WIP 3");
    TelaAnterior = Tela;
  }
  checarBotaoMenu();
  break;
    
    
  case 4:				        		// jogo 4 tela
  if(Tela != TelaAnterior) {
    lcd.clear();
    lcd.print("WIP 4");
    TelaAnterior = Tela;
  }
  checarBotaoMenu();
  break;
    
    
  case 5:				        		// jogo 5 tela
  if(Tela != TelaAnterior) {
    iniciarDino();
    lcd.clear();
    lcd.createChar(4, passaro1);
    lcd.createChar(5, passaro2);
    lcd.setCursor(0,0);
    lcd.write(byte(4));
    lcd.setCursor(1,0);
    lcd.write(byte(5));
    lcd.setCursor(0,1);
    lcd.write(byte(1));
    lcd.setCursor(1,1);
    lcd.write(byte(2));
    TelaAnterior = Tela;
  }
  checarBotaoMenu();
  break;
    
  
  case 99:              //game over
  if(Tela != TelaAnterior) {                 // [FIX] chave fechando esse if estava faltando
    lcd.clear();
    lcd.print("  Voce perdeu!");
    lcd.setCursor(0,1);
    lcd.print(" Pontuacao: ");
    if(TelaAnterior == 1){
      lcd.print(scoreDino);
    }else if(TelaAnterior == 2){             // [FIX] agora mostra a pontuação do BShot tambem
      lcd.print(scoreBShot);
    }
    TelaAnterior = Tela;                     // [FIX] movido pra fora do if/else, senão só atualizava quando vindo do BShot
  }
  checarBotaoMenu();
  break;
    
    
  }//sw jogo
  
  
  
}