//CATETOS AIRSOFT
//PROJETO 001 – BOMBA FAKE COM ARDUINO.

#include <Wire.h> 
#include <Keypad.h>
#include <LiquidCrystal_I2C.h>
//#include <LiquidCrystal.h>

//ARDUINO AIRSOFT TIME BOMB.

//Display
LiquidCrystal_I2C lcd(0x27,16,2);

//LiquidCrystal lcd(7, 6, 5, 4, 3, 2);


//Teclado
const byte ROWS = 4; //quatro linhas
const byte COLS = 4; //quatro colunas

char keys[ROWS][COLS] = {
  {'1','2','3','a'}
  ,
  {'4','5','6','b'}
  ,
  {'7','8','9','c'}
  ,
  {'*','0','#','d'}
};

byte rowPins[ROWS] = {
  5, 4, 3, 2}; //conecte as pinagens de linhas do teclado
byte colPins[COLS] = {
  A0, A1, A2, A3
}; //conecte as pinagens de colunas do teclado

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

char codeInput[8];
byte time[4];
boolean refresh=true;//1 atualizar uma vez
char password[8];
int key=-1;
char lastKey;
char var;
boolean passwordEnable=false;

//Botões do LCD
char BT_RIGHT = '4';
char BT_UP = 'a';
char BT_DOWN = 'b';
char BT_LEFT = '6';
char BT_SEL = '*';   // Botão Ok   
char BT_CANCEL = '#';
char BT_DEFUSER = 'd';   // não implementado

//botões
const int BT_RED = 6;
const int BT_GREEN = 7;

//leds
const int REDLED = 11;
const int GREENLED = 10;
//const int BLUELED = 12;

//Pinagem de Relé
boolean relayEnable = false;
const int RELAYPIN = 9;

// É MUITO IMPORTANTE QUE VOCÊ TESTE ESTE TEMPO. POR PADRÃO ESTÁ EM 1 SEG. ISSO NÃO É MUITO. ENTÃO TESTE!
const int RELAY_TIME = 5000;

//DECLARAÇÕES DE TEMPOS
int GAMEHOURS = 0;
int GAMEMINUTES = 45;
int BOMBMINUTES = 4;
int ACTIVATESECONDS = 5;

boolean endGame = false;
boolean sdStatus = false; // Habilita jogo - pesquisar e destruir
boolean saStatus = false; // Habilita jogo - Sabotagem
boolean doStatus = false; // Habilita jogo - Demolição
boolean start = true;
boolean defusing;
boolean fusing;
boolean cancelando;

//TONS DE SONS
boolean soundEnable = true;
int tonepin = 8; // Pino 8 para a saída de som
int alarmTone1 = 700;
int alarmTone2 = 2600;
int activeTone = 1330;  
int errorTone = 100;

unsigned long iTime;
unsigned long timeCalcVar;
unsigned long redTime;
unsigned long greenTime;
unsigned long iZoneTime;//Tempo inicial para TimeZone
byte team=0; // 0 = neutro, 1 = time verde, 2 = time vermelho

void setup(){
  lcd.init(); // INICIA A COMUNICAÇÃO COM O DISPLAY
  lcd.backlight(); // LIGA A ILUMINAÇÃO DO DISPLAY
  lcd.clear(); // LIMPA O DISPLAY
  lcd.begin(16, 2);
  Serial.begin(9600);
  
  lcd.setCursor(0,0);
  tone(tonepin,2400,30);
  lcd.print("ANDERSON PONTES");// Você pode adicionar o nome do seu time
  lcd.setCursor(0, 1);
  lcd.print("ARTEFATOS FAKES");
  delay(5000);
 
 // lcd.setCursor(0,1);
 // lcd.print("ARTEFATO FAKE 01");// Você pode adicionar o nome do seu time
  keypad.setHoldTime(50);
  keypad.setDebounceTime(50);
  keypad.addEventListener(keypadEvent);

  //PinModes
  pinMode(GREENLED, OUTPUT);     
  pinMode(REDLED, OUTPUT); 
  pinMode(RELAYPIN, OUTPUT);  
  pinMode(BT_RED, INPUT_PULLUP);
  pinMode(BT_GREEN, INPUT_PULLUP);

  // CONFIGURAÇÃO DA BARRA DE PROGRESSO
  byte bar1[8] = {
    B10000,
    B10000,
    B10000,
    B10000,
    B10000,
    B10000,
    B10000,
    B10000,
  };
  byte bar2[8] = {
    B11000,
    B11000,
    B11000,
    B11000,
    B11000,
    B11000,
    B11000,
    B11000,
  };
  byte bar3[8] = {
    B11100,
    B11100,
    B11100,
    B11100,
    B11100,
    B11100,
    B11100,
    B11100,
  };
  byte bar4[8] = {
    B11110,
    B11110,
    B11110,
    B11110,
    B11110,
    B11110,
    B11110,
    B11110,
  };
  byte bar5[8] = {
    B11111,
    B11111,
    B11111,
    B11111,
    B11111,
    B11111,
    B11111,
    B11111,
  };
  byte up[8] = {
    B00000,
    B00100,
    B01110,
    B11111,
    B11111,
    B00000,
    B00000,
  };

  byte down[8] = {
    B00000,
    B00000,
    B11111,
    B11111,
    B01110,
    B00100,
    B00000,
  };
  lcd.createChar(0,bar1);
  lcd.createChar(1,bar2);
  lcd.createChar(2,bar3);
  lcd.createChar(3,bar4);
  lcd.createChar(4,bar5);
  lcd.createChar(5,up);
  lcd.createChar(6,down);
}

void loop(){
  digitalWrite(RELAYPIN, LOW);
  digitalWrite(BT_RED, LOW);
  digitalWrite(BT_GREEN, LOW);
  menuPrincipal();
}
void keypadEvent(KeypadEvent key){
  switch (keypad.getState()){
    case RELEASED:
      switch (key){
         case 'd': fusing = false;
         break;
         case '#': defusing = false;
         break;
         case '0': cancelando = false;
         break;
      }
    break;
    case HOLD:
      switch (key){
        case 'd': fusing = true;
        break;
        case '#': defusing = true;
        break;
            case '0': cancelando = true;
        break;
      }
    break;
  }
}
//################## CONSTANTES ###############################

  const char* menu1[]={"LOCALIZAR/DESTR","SABOTAGEM","DOMINACAO", "CONFIGURAR"      };
  const char* menu2[]={"CONFIG JOGO","CONFIG SOM", "TESTE RELE", "AUTO TESTE"      };   
  const char* GAME_TIME="TEMPO DE JOGO:";
  const char* BOMB_TIME="TEMPO BOMBA:";
  const char* ZERO_MINUTES="00 minutos";
  const char* ARM_TIME="TEMPO P/ ARMAR:";
  const char* ZERO_SECS="00 segundos";
  const char* ENABLE_SOUND="ATIVAR SOM?";
  const char* YES_OR_NOT="A : SIM B : NAO";
  const char* ENABLE_RELAYPIN="ATIVAR SIRENE?";
  const char* ENABLE_CODE="BOMBA COM SENHA?";
  const char* GAME_TIME_TOP="TEMPO DE JOGO";
  const char* ARMING_BOMB = "ARMANDO BOMBA";
  const char* ENTER_CODE = "DIGITE A SENHA";
  const char* CODE_ERROR = "SENHA ERRADA";
  const char* BOMB_ARMED = "BOMBA ARMADA";
  const char* DETONATION_IN = "DETONACAO EM  ";
  const char* DISARMING = "DESARMANDO BOMBA" ;
  const char* DISARM = "DESARMANDO";
  const char* GAME_OVER = "  FIM DE JOGO!  ";
  const char* DEFENDERS_WIN = "DEFESA VENCE";
  const char* SABOTAGE_FAIL= "SABOTAGEM FALHOU";

  //################## DOMINAÇÃO ###############################
void domination(){

  //CONFIGURAÇÃO DO TEMPO INICIAL 
  int minutos = GAMEMINUTES-1;
  boolean showGameTime=true;
  unsigned long a;
  unsigned long iTime=millis(); //  Tempo inicial em milisegundos 
  unsigned long aTime;
 
  team=0;
  iZoneTime=0;
  aTime=0;
  redTime=0;
  greenTime=0;

  int largoTono = 50;
  // 0 = neutro, 1 = time verde, 2 = time vermelho
  a=millis();
  
//CÓDIGO PARA INICIO DO JOGO
  while(1)  // Este é um código importante.
  {
    if(endGame){
      gameOver();
    }
    
    keypad.getKey();
    aTime=millis()- iTime;
   
    //Código para led piscando
    timeCalcVar=(millis()- iTime)%1000;
    if(timeCalcVar >= 0 && timeCalcVar <= 40)
    {
      if(team==1)digitalWrite(GREENLED, HIGH);  
      if(team==2)digitalWrite(REDLED, HIGH);  
    }
    if(timeCalcVar >= 50 && timeCalcVar <= 100)
    {    
      if(team==1)digitalWrite(GREENLED, LOW);  
      if(team==2)digitalWrite(REDLED, LOW);
    }
    
   // Som!!! Semelhante a destruição 
    if(timeCalcVar >= 0 && timeCalcVar <= 40 && soundEnable)tone(tonepin,activeTone,largoTono);

    if(timeCalcVar >= 245 && timeCalcVar <= 255 && minutos-aTime/60000<2 && soundEnable)tone(tonepin,activeTone,largoTono);
    if(timeCalcVar >= 495 && timeCalcVar <= 510 && minutos-aTime/60000<4 && soundEnable)tone(tonepin,activeTone,largoTono);
    if(timeCalcVar >= 745 && timeCalcVar <= 760 && minutos-aTime/60000<2 && soundEnable)tone(tonepin,activeTone,largoTono);
    //Ajuda a contar 3 secs
    if(a+2000<millis()){
      a=millis();   
      showGameTime=!showGameTime;
      cls();
    }
    //OS PRÓXIMOS MÉTODOS MOSTRAM "TEMPO DE JOGO" E "TEMPO DE ZONA CONTROLADA" MOSTRA A CADA 2 SEG CADA


    if(showGameTime){ //O SEGUNDO É /2
      lcd.setCursor(1,0);
      lcd.print("TEMPO DE JOGO");
      lcd.setCursor(3,1);
      printTime(minutos, aTime);
    }
    else if (!showGameTime){

      lcd.setCursor(1,0);
      if(team == 0)lcd.print(" ZONA NEUTRA");
      if(team == 1)lcd.print("  ZONA VERDE");
      if(team == 2)lcd.print("ZONA VERMELHA");

      if(team>0){
        lcd.setCursor(3,1);
        printTimeDom(millis()-iZoneTime,true);
      }
    }

    //###################### VERIFICAÇÕES ##################

    //Verifica se o Jogo Terminou
    if(minutos-aTime/60000==0 && 59-((aTime/1000)%60)==0)
    {
      gameOver();
    }

    //Verifica se esta em Neutro
    while((defusing || fusing || (digitalRead(BT_GREEN) == HIGH) || (digitalRead(BT_RED) == HIGH) ) && team > 0)
    {
      cls();
      if(team>0)lcd.print("NEUTRALIZANDO...");
      lcd.setCursor(0,1);
      unsigned int percent=0;
      unsigned long xTime=millis(); //Inicia o tempo de desativação
      while(fusing || defusing || (digitalRead(BT_GREEN) == HIGH) || (digitalRead(BT_RED) == HIGH))
     
      {
        
        //Verifica se o tempo de jogo acaba durante a desativação
        aTime= millis()- iTime;
        if((minutos-aTime/60000==0 && 59-((aTime/1000)%60)==0) || minutos-aTime/60000>4000000000){ 
          endGame = true;
        }
        
        keypad.getKey();
        timeCalcVar = (millis()- xTime)%1000;

        if( timeCalcVar >= 0 && timeCalcVar <= 20)
        {
          if(soundEnable)tone(tonepin,alarmTone1,200);
        }
        if(timeCalcVar >= 480 && timeCalcVar <= 500)
        {
          if(soundEnable)
          tone(tonepin,alarmTone2,200);
      
          digitalWrite(REDLED, LOW);
        }

        unsigned long seconds= millis() - xTime;
        percent = (seconds)/(ACTIVATESECONDS*10);
        drawBar(percent);

        if(percent >= 100)

        
        {
     tone(tonepin,alarmTone2,200);
     delay(1000);
  

          if(team==1){ 
            greenTime+=millis()-iZoneTime;
            iZoneTime=0; 

          }
          if(team==2){ 
            redTime+=millis()-iZoneTime;
            iZoneTime=0; 
          }
          team=0;
          break;
        }
      }
      
      cls();
    }

    //Zona Capturada por Time Vermelho

    while((fusing  || (digitalRead(BT_RED) == HIGH)) && team == 0 )
    {
      cls();
      if(team==0)lcd.print("CAPTURANDO ZONA");
      lcd.setCursor(0,1);
      unsigned int percent=0;
      unsigned long xTime=millis(); //Inicia o tempo de desativação
      while(fusing || (digitalRead(BT_RED) == HIGH))
      {
        keypad.getKey();
      
        //Verifica se o tempo de jogo acaba durante a desativação
        aTime= millis()- iTime;
        if((minutos-aTime/60000==0 && 59-((aTime/1000)%60)==0) || minutos-aTime/60000>4000000000){ 
          endGame = true;
        }
        timeCalcVar = (millis()- xTime)%1000;

        if( timeCalcVar >= 0 && timeCalcVar <= 20)
        {
          digitalWrite(REDLED, HIGH);  
          if(soundEnable)tone(tonepin,alarmTone1,200);
        }
        if(timeCalcVar >= 480 && timeCalcVar <= 500)
        {
          if(soundEnable)tone(tonepin,alarmTone2,200);
          digitalWrite(REDLED, LOW);
        }

        unsigned long seconds= millis() - xTime;
        percent = (seconds)/(ACTIVATESECONDS*10);
        drawBar(percent);

        if(percent >= 100)
        {
               tone(tonepin,alarmTone2,200);
     delay(200);
         tone(tonepin,alarmTone2,200);
     delay(200);
      tone(tonepin,alarmTone2,200);
          digitalWrite(GREENLED, LOW);
          team=2;
          iZoneTime=millis();
          delay(1000);
          
  digitalWrite(RELAYPIN, LOW);   
  delay(1000); 
  digitalWrite(RELAYPIN, HIGH);
          break;
        }
      }
        
      cls();
      digitalWrite(REDLED, LOW);
    }

    //Zona Capturada por Time Verde
    while((defusing || (digitalRead(BT_GREEN) == HIGH)) && team == 0 )
    {
      cls();
      if(team==0)lcd.print(" CAPTURANDO ZONA");
      lcd.setCursor(0,1);
      unsigned int percent=0;
      unsigned long xTime=millis(); //Inicia o tempo de desativação
      while(defusing || (digitalRead(BT_GREEN) == HIGH))
      {
        keypad.getKey();

        //Verifica se o tempo de jogo acaba durante a desativação
        aTime= millis()- iTime;
        if((minutos-aTime/60000==0 && 59-((aTime/1000)%60)==0) || minutos-aTime/60000>4000000000){ 
          endGame = true;
        }
        timeCalcVar = (millis()- xTime)%1000;

        if( timeCalcVar >= 0 && timeCalcVar <= 20)
        {
          digitalWrite(GREENLED, HIGH);  
          if(soundEnable)tone(tonepin,alarmTone1,200);
        }
        if(timeCalcVar >= 480 && timeCalcVar <= 500)
        {
          if(soundEnable)tone(tonepin,alarmTone2,200);
          digitalWrite(GREENLED, LOW);
        }

        unsigned long seconds= millis() - xTime;
        percent = (seconds)/(ACTIVATESECONDS*10);
        drawBar(percent);

        if(percent >= 100)
        {
           tone(tonepin,alarmTone2,200);
     delay(200);
         tone(tonepin,alarmTone2,200);
     delay(200);
      tone(tonepin,alarmTone2,200);
          digitalWrite(GREENLED, LOW);
          team=1;
          iZoneTime=millis();
          delay(1000);
           digitalWrite(RELAYPIN, LOW);   
  delay(1000); 
  digitalWrite(RELAYPIN, HIGH);
          break;
        }
      }
      cls();
      digitalWrite(GREENLED, LOW);  
    }
  }
}

void gameOver(){

  
  if(team==1)greenTime+=millis()-iZoneTime;
  if(team==2)redTime+=millis()-iZoneTime;
  
  cls();    
  lcd.print("FIM DO JOGO ");
  digitalWrite(GREENLED, LOW);
  digitalWrite(REDLED, LOW);

   digitalWrite(RELAYPIN, LOW);   
  delay(5000); 
  digitalWrite(RELAYPIN, HIGH);
  while(!defusing  || (digitalRead(BT_GREEN) == LOW)){
    keypad.getKey();
    if(defusing || (digitalRead(BT_GREEN) == HIGH)){
      keypad.getKey();
      break;
    }
    lcd.clear();
    lcd.setCursor(0,0);
    lcd.print("FIM DO JOGO ");
    lcd.setCursor(0,1);

  
    //Verifica Qual Time Venceu
    if(greenTime>redTime){
      //Vitória do time verde
      lcd.print("VITORIA VERDE");
      digitalWrite(GREENLED, HIGH);
    }
    else{
      //Vitória do time vermelho 
      lcd.print("VITORIA VERMELHO");
      digitalWrite(REDLED, HIGH);
    }
    delay(3000);
    keypad.getKey();
    if(defusing || (digitalRead(BT_GREEN) == HIGH)){
      keypad.getKey();
      break;
    }
    cls();
    lcd.print("TEMPO VERMELHO:"); //Tempo de posse do time vermelho
    lcd.setCursor(5,1);
    printTimeDom(redTime,false);
    delay(3000);
    keypad.getKey();
    if(defusing || (digitalRead(BT_GREEN) == HIGH)){
      
      break;
    }
    cls();
    lcd.print("TEMPO VERDE:"); //Tempo de posse do time verde
    lcd.setCursor(5,1);
    printTimeDom(greenTime,false);
    delay(3000);
    keypad.getKey();
    if(defusing || (digitalRead(BT_GREEN) == HIGH)){
      keypad.getKey();
      break;
    }
  }
  cls();
  delay(100);
  lcd.print("Jogar novamente?");
  lcd.setCursor(0,1);
  lcd.print("A : SIM B : NAO");
  while(1)
  {
    var = keypad.waitForKey();
    if(var == 'a' ){
      tone(tonepin,2400,30);
      cls();
      domination();
      break;
    }  
    if(var == 'b' ){
      tone(tonepin,2400,30);
      menuPrincipal();
      break;
    }  
  } 
}
//################## FIM DE JOGO ###############################
void explodeSplash(){
  digitalWrite(REDLED, LOW);  
  digitalWrite(GREENLED, LOW); 
  cls();
  delay(100);
  endGame = false;
  lcd.setCursor(1,0);
  lcd.print("TERRORISTAS WIN");
  lcd.setCursor(4,1);
  lcd.print("GAME OVER");
  for(int i = 200; i>0; i--)// this is the ultra hi definition explosion sound xD
  {
    tone(tonepin,i);
    delay(20);
  }
  noTone(tonepin);
  if(relayEnable){
    activateRelay(); 
  }
  delay(5000);
  cls();

  //end code
  lcd.print("Jogar novamente?");
  lcd.setCursor(0,1);
  lcd.print("A : SIM B : NAO");
  while(1)
  {
    var = keypad.waitForKey();
    if(var == 'a' ){
      tone(tonepin,2400,30);
      //We have two options, search & destroy and sabotaje play again options so!
      if(sdStatus){
        startGameCount();
        search();
      }
      if(saStatus){
        saStatus=true;
        startGameCount();
        start=true; //to set iTime to actual millis() :D
        sabotage();
      }
    }  
    if(var == 'b' ){
      tone(tonepin,2400,30);
      menuPrincipal();

      break;
    }  
  } 
}
void failSplash(){
  digitalWrite(REDLED, LOW);  
  digitalWrite(GREENLED, LOW); 
  cls();
  delay(100);
  endGame = false;
  lcd.setCursor(1,0);
  lcd.print("FIM DO TEMPO");
  lcd.setCursor(4,1);
  lcd.print("GAME OVER");
  for(int i = 200; i>0; i--)// this is the ultra hi definition explosion sound xD
  {
    tone(tonepin,i);
    delay(20);
  }
  noTone(tonepin);
  if(relayEnable){
    activateRelay2(); 
  }
  delay(5000);
  cls();

  //end code
  lcd.print("Jogar Novamente?");
  lcd.setCursor(0,1);
  lcd.print("A : SIM B : NAO");
  while(1)
  {
    var = keypad.waitForKey();
    if(var == 'a' ){
      tone(tonepin,2400,30);
      //We have two options, search & destroy and sabotaje play again options so!
      if(sdStatus){
        startGameCount();
        search();
      }
      if(saStatus){
        saStatus=true;
        startGameCount();
        start=true; //to set iTime to actual millis() :D
        sabotage();
      }
    }  
    if(var == 'b' ){
      tone(tonepin,2400,30);
      menuPrincipal();

      break;
    }  
  } 
}
void disarmedSplash(){
  endGame = false;
  digitalWrite(REDLED, LOW); 
  digitalWrite(GREENLED, LOW);
  if(sdStatus || saStatus){
    lcd.clear();
    lcd.setCursor(1,0);
    lcd.print("BOMBA DESARMADA");
    lcd.setCursor(5,1);
    lcd.print("CT WIN");
    digitalWrite(GREENLED, HIGH);  
   
   

  digitalWrite(RELAYPIN, LOW);   
  delay(1000); 
  digitalWrite(RELAYPIN, HIGH);
 delay(500); 
  digitalWrite(RELAYPIN, LOW);   
  delay(1000); 
  digitalWrite(RELAYPIN, HIGH);

   digitalWrite(GREENLED, LOW); 
  }
  //end code
  lcd.clear();
  lcd.print("Jogar Novamente?");
  lcd.setCursor(0,1);
  lcd.print("A : SIM B : NAO");
  digitalWrite(REDLED, LOW);  
  digitalWrite(GREENLED, LOW); 
  while(1)
  {
    var = keypad.waitForKey();
    if(var == 'a' ){
      tone(tonepin,2400,30);
      //We have two options, search & destroy and sabotaje play again options so!
      if(sdStatus){
        startGameCount();
        search();
      }
      if(saStatus){
        saStatus=true;
        startGameCount();
        start=true; //to set iTime to actual millis() :D
        sabotage();
      }
    }  
    if(var == 'b' ){
      tone(tonepin,2400,30);
      menuPrincipal();
      break;
    }  
  } 
}
//void getConfig(){
//
////Check first time 
//
//if (EEPROM.read(0)!= 1){
////write default config values
//
//
//
//}
//  
////RELAY_TIME = EEPROM.read(1) * 1000 ;
//
//  
//}
//################## MENUS ###############################

void menuPrincipal(){   //MENU PRINCIPAL
  lcd.clear();
  lcd.setCursor(4, 0);
    lcd.print("CATETOS");
  lcd.setCursor(2, 1);
    lcd.print("AIRSOFT TEAM");
    delay(5000);
  
 lcd.clear();
  
  lcd.setCursor(0, 0);
    lcd.print("ARTEFATO FAKE 01");
  
  lcd.setCursor(0, 1);
    lcd.print("MULTGAME - V1.0");


     delay (5000);

     
     lcd.clear();
     
  digitalWrite(GREENLED, LOW); 
  digitalWrite(REDLED, LOW); 

  //Se iniciarmos um novo jogo a partir de outro, é preciso reiniciar as variáveis adequadamente
  saStatus=false;
  sdStatus=false;
  doStatus=false;

  //Display
  cls();//Limpa o LCD e seta o cursor para 0,0
  int i=0;

 //AQUI VC PODE ADICIONAR MAIS ITENS AO MENU PRINCIPAL
  lcd.print(menu1[i]);
  lcd.setCursor(15,1);
  checkArrows(i,2);
  while(1){

    var = keypad.waitForKey();
    if(var == BT_UP && i>0){
      tone(tonepin,2400,30);
      i--;
      cls();
      lcd.print(menu1[i]);
      checkArrows(i,2);
      delay(50);
    }
    if(var == BT_DOWN && i<2){
      tone(tonepin,2400,30);
      i++;
      cls(); 
      lcd.print(menu1[i]);    
      checkArrows(i,2);
      delay(50);
    }

    if(var == BT_SEL){
      tone(tonepin,2400,30);
      cls();
      switch (i){

      case 0:
        sdStatus=true;
        configQuickGame();
        startGameCount();
        search();
        break;
      case 1: 
        saStatus=true;
        configQuickGame();
        startGameCount();
        sabotage();
        break;
      case 2:
        doStatus=true;
        configQuickGame();
        startGameCount();
        domination();
        break;
      case 3:
        config();
        break;

      }
    }
  }
}

void config(){
  //MENU LCD
  lcd.clear();
  lcd.setCursor(0, 0);
  int i=0;
  
  delay(500);
  lcd.print(menu2[i]);
  checkArrows(i,3);

  while(1){
    var=keypad.waitForKey();
    if(var == BT_UP && i>0){
      tone(tonepin,2400,30);
      i--;
      lcd.clear();  
      lcd.print(menu2[i]);
      checkArrows(i,3);
      delay(50);

    }
    if(var == BT_DOWN && i<3){
      tone(tonepin,2400,30);
      i++;
      lcd.clear();  
      lcd.print(menu2[i]);
      checkArrows(i,3);
      delay(50);
    }
    if(var == BT_CANCEL){
      tone(tonepin,2400,30);
      menuPrincipal();
    }
    if(var == BT_SEL){
      tone(tonepin,2400,30);
      lcd.clear();
      switch (i){

      case 0:
        //gameConfigMenu(); //MENU CONFIGURAÇÃO DO JOGO
        break;

      case 1:
        //soundConfigMenu(); //MENU CONFIGURAÇÃO DO SOM
        break;

      case 2:
        cls();
        lcd.print("RELE ATIVO!");
        digitalWrite(RELAYPIN, HIGH);   //Liga o  LED (HIGH é o nível de tensão)
        delay(4000);   // Aguarde por 4 sec
        cls();
        lcd.print("RELE DESATIVADO");
        digitalWrite(RELAYPIN, LOW);
        delay(2000);
        config();
        break;        

      }
    }
  }
}

void configQuickGame(){

  cls();
  //TEMPO DE JOGO
  if(sdStatus || doStatus || saStatus){
    menu1:
    cls();
    lcd.print(GAME_TIME);
    delay(100);
    lcd.setCursor(0,1);
    lcd.print("00:00 hh:mm");
    lcd.cursor();
    lcd.blink();
    lcd.setCursor(0,1);
    byte var2=0;
    for(int i=0;i<4;i++){ 
      while(1){
        if(i==2 && var2==0){
          lcd.print(":");
          var2=1;
        }

        byte varu= getRealNumber();
        if(varu !=11){

          time[i] =  varu;
          Serial.print(varu);


          lcd.print(varu);
          tone(tonepin,2400,30);

          break;
        }
      }  
    }
    lcd.noCursor();
    lcd.noBlink();
    lcd.setCursor(13,1);
    lcd.print("ok?");
    //Área onde passamos os itens para redesenhar
    while(1){
      var = keypad.waitForKey();
      if(var == '*') // Aceitar
      {
        tone(tonepin,2400,30);
        GAMEMINUTES= ((time[0]*600)+(time[1]*60)+(time[2]*10)+(time[3]));
        break;
      }    
  if(var == '#') // Botão cancelar ou voltar :')
      {
        tone(tonepin,2400,30);
        goto menu1;
      }           
    }
    tone(tonepin,2400,30);
    cls();
  }
  //Tempo da Bomba
  if(sdStatus || saStatus){
 
    menu2:
    cls();
    lcd.print(BOMB_TIME);
    delay(100);
    lcd.setCursor(0,1);
    lcd.print(ZERO_MINUTES);
    lcd.cursor();
    lcd.blink();
    lcd.setCursor(0,1);
    for(int i=0;i<2;i++){ 
      while(1){
        byte varu= getRealNumber();
        if(varu !=11){
          time[i] =  varu;
          lcd.print(varu);
          tone(tonepin,2400,30);
          break;
        }
      }  
    }
    lcd.noCursor();
    lcd.noBlink();   
    lcd.setCursor(13,1);
    lcd.print("ok?");
    //Área onde passamos os itens para redesenhar
    while(1){
      var = keypad.waitForKey();
      if(var == '*') //Aceitar
      {
        tone(tonepin,2400,30);
        BOMBMINUTES= ((time[0]*10)+(time[1]));
        break;
      }    
  if(var == '#') // Botão cancelar ou voltar:')
      {
        tone(tonepin,2400,30);
        goto menu2;
      }           
    }
    tone(tonepin,2400,30);
    cls();
  }
  cls();
  //ARMING TIME
  if(sdStatus || doStatus || saStatus){
        
    menu3:
    cls();
    lcd.print(ARM_TIME);
    delay(100);
    lcd.setCursor(0,1);
    lcd.print(ZERO_SECS);
    lcd.cursor();
    lcd.blink();
    lcd.setCursor(0,1);
    for(int i=0;i<2;i++){ 
      while(1){
        byte varu= getRealNumber();
        if(varu !=11){
          time[i] =  varu;
          lcd.print(varu);
          tone(tonepin,2400,30);
          break;
        }
      }  
    }
    lcd.noCursor();
    lcd.noBlink(); 
    lcd.setCursor(13,1);
    lcd.print("ok?");  
    
    //Área onde passamos os itens para redesenhar
    while(1){
      var = keypad.waitForKey();
      if(var == '*') // Aceitar
      {
        tone(tonepin,2400,30);
        ACTIVATESECONDS= ((time[0]*10)+(time[1]));
        break;
      }    
  if(var == '#') //Botão cancelar ou voltar :')
      {
        tone(tonepin,2400,30);
        goto menu3;
      }           
    }
    tone(tonepin,2400,30);
    cls();
  }
  //som??
  if(sdStatus || saStatus || doStatus){
    cls();
    lcd.print(ENABLE_SOUND);
    lcd.setCursor(0,1);
    lcd.print(YES_OR_NOT);

    while(1)
    {
      var = keypad.waitForKey();
      if(var == 'a' ){
        soundEnable=true;
        tone(tonepin,2400,30);
        break;
      }  

      if(var == 'b' ){
        soundEnable=false;
        tone(tonepin,2400,30);
        break;
      }  
    }
  } 
  //ATIVAR RELÉ QUANDO O JOGO “TERRORISTA” TERMINAR??? Boom!

  if(sdStatus || saStatus){
    cls();
    lcd.print(ENABLE_RELAYPIN);
    lcd.setCursor(0,1);
    lcd.print(YES_OR_NOT);
    while(1)
    {
      var = keypad.waitForKey();
      if(var == 'a' ){
        relayEnable=true;
        tone(tonepin,2400,30);
        break;
      }  
      if(var == 'b' ){
        relayEnable=false;
        tone(tonepin,2400,30);
        break;
      }  
    } 
  }
  //Vc quer um jogo com habilitação e desabilitação por senha?
  if(sdStatus || saStatus){
    cls();
    lcd.print(ENABLE_CODE);
    lcd.setCursor(0,1);
    lcd.print(YES_OR_NOT);

    while(1)
    {
      var = keypad.waitForKey();
      if(var == 'a' ){
        tone(tonepin,2400,30);
        setNewPass();
        passwordEnable = true;
        break;
      }  
      if(var == 'b' ){
        tone(tonepin,2400,30);
        passwordEnable = false;
        break;
      }  
    } 
    tone(tonepin,2400,30);
  }  

  //Continue o jogo :D
}
//################## BUSCA E DESTRUIÇÃO ###############################

void search() {
  refresh = true;
  cls();
  digitalWrite(REDLED, LOW);
  digitalWrite(GREENLED, LOW);
  //CONFIGURAÇÃO DO TEMPO INICIAL
  int minutos = GAMEMINUTES - 1;
  unsigned long iTime = millis(); //Tempo inicial em  millisec
  unsigned long aTime;
  //var='o';

  //Iniciando Código do Jogo
  while (1) { // Isto é muito importante.

    //Se vc falhar, desarma.
    if (endGame) {
      failSplash();
    }

    //Codigo para led piscando
    timeCalcVar = (millis() - iTime) % 1000;
    if (timeCalcVar >= 0 && timeCalcVar <= 50)digitalWrite(GREENLED, HIGH);
    if (timeCalcVar >= 90 && timeCalcVar <= 130)digitalWrite(GREENLED, LOW);

    lcd.setCursor(1, 0);
    lcd.print(GAME_TIME_TOP);
    aTime = millis() - iTime;
    lcd.setCursor(3, 1);

    //APRESENTA O TEMPO NO LCD

    printTime(minutos, aTime);

    //########################### VERIFICAÇÕES ##################

    //Verifica se o jogo terminou
    if (minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0)failSplash();
    //Serial.println(keypad.getKey());

    //USADO EM JOGOS COM SENHA
    if ('d' == keypad.getKey() && passwordEnable) {
      lcd.clear();
      tone(tonepin,2400,30);
      lcd.setCursor(2, 0);
      lcd.print(ARMING_BOMB);
      delay(1000);//a little delay to think in the password
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(ENTER_CODE);

      setCodeTime();

      if (comparePassword()) destroy();
      lcd.clear();
      lcd.setCursor(2, 0);
      lcd.print(CODE_ERROR);
      if (soundEnable)tone(tonepin, errorTone, 200);
      delay(500);
      cls();
    }
    //Verifica se esta ativando
    while (fusing && !passwordEnable)
    {
      digitalWrite(GREENLED, LOW);
      lcd.clear();
      lcd.setCursor(2, 0);
      lcd.print(ARMING_BOMB);
      lcd.setCursor(0, 1);
      unsigned int percent = 0;
      unsigned long xTime = millis(); //Inicia o tempo de desarme
      while (fusing)
      {
        keypad.getKey();
                percent = (millis() - xTime) / (ACTIVATESECONDS * 10);
                
        drawBar(percent);
        //Verifica se o tempo terminou durante desativação
        aTime = millis() - iTime;
        Serial.println(millis()-xTime);
        if ((minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) || minutos - aTime / 60000 > 4000000000) {
          endGame = true;
        }
        timeCalcVar = (millis() - xTime) % 1000;

        if ( timeCalcVar >= 0 && timeCalcVar <= 40)
        {
          digitalWrite(REDLED, HIGH);
          if (soundEnable)tone(tonepin, alarmTone1, 200);
        }
        if (timeCalcVar >= 480 && timeCalcVar <= 520)
        {
          if (soundEnable)tone(tonepin, alarmTone2, 200);
          digitalWrite(REDLED, LOW);
        }



        if (percent >= 100)
        {
          digitalWrite(GREENLED, LOW);
          destroy();// jump to the next gamemode
        }
      }
      cls();
      digitalWrite(REDLED, LOW);

    }
  }
}

void destroy() {
  lcd.clear();
  lcd.setCursor(2, 0);
  lcd.print(BOMB_ARMED);
  digitalWrite(RELAYPIN, LOW);   
  delay(1000); 
  digitalWrite(RELAYPIN, HIGH);
    int minutos = BOMBMINUTES - 1;
  unsigned long iTime = millis();
  unsigned long aTime;
  int largoTono = 50;

  //MAIN LOOP
  while (1) {

    //If you fail disarm.
    if (endGame) {
      explodeSplash();
    }

    //Led Blink

    timeCalcVar = (millis() - iTime) % 1000;
    if (timeCalcVar >= 0 && timeCalcVar <= 40)
    {
      digitalWrite(REDLED, HIGH);
      if (soundEnable)tone(tonepin, activeTone, largoTono);
    }
    if (timeCalcVar >= 180 && timeCalcVar <= 220) {
      digitalWrite(REDLED, LOW);
    }
    //Sound
    aTime = millis() - iTime;
    timeCalcVar = (millis() - iTime) % 1000;
    if (timeCalcVar >= 245 && timeCalcVar <= 255 && minutos - aTime / 60000 < 2 && soundEnable)tone(tonepin, activeTone, largoTono);
    if (timeCalcVar >= 495 && timeCalcVar <= 510 && minutos - aTime / 60000 < 4 && soundEnable)tone(tonepin, activeTone, largoTono);
    if (timeCalcVar >= 745 && timeCalcVar <= 760 && minutos - aTime / 60000 < 2 && soundEnable)tone(tonepin, activeTone, largoTono);
    if ( minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) < 10)largoTono = 300;

    lcd.setCursor(1, 0);
    lcd.print(DETONATION_IN);
    //Passed Time

    lcd.setCursor(3, 1);

    //////// HERE ARE THE TWO OPTIONS THAT ENDS THE GAME ///////////

    ////TIME PASED AWAY AND THE BOMB EXPLODES
    if (minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) // Check if game ends
    {
      explodeSplash();
    }
    //print time

    printTime(minutos, aTime);

    //// SECOND OPTION: YOU PRESS DISARMING BUTTON

    //IF IS A PASSWORD GAME

    if ('#' == keypad.getKey() && passwordEnable) {

      lcd.clear();
       tone(tonepin,2400,30);
      lcd.setCursor(0, 0);
      lcd.print(DISARMING);
      delay(1000);//a little delay to think in the password

      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(ENTER_CODE);

      setCodeTime();// we need to set the compare variable first

      //then compare :D

      if (comparePassword()) {
        disarmedSplash();
      }
      lcd.clear();
      lcd.setCursor(2, 0);
      lcd.print(CODE_ERROR);
      if (soundEnable)tone(tonepin, errorTone, 200);
      delay(500);
      cls();
    }

    if (defusing && !passwordEnable) // disarming bomb
    {
      lcd.clear();
      digitalWrite(REDLED, LOW);
      lcd.setCursor(1, 0);
      lcd.print(DISARM);
      lcd.setCursor(0, 1);
      unsigned int percent = 0;
      unsigned long xTime = millis();
      while (defusing)
      {
        keypad.getKey();
        //check if game time runs out during the disabling
        aTime = millis() - iTime;
        if ((minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) || minutos - aTime / 60000 > 4000000000) {
          endGame = true;
        }
        timeCalcVar = (millis() - xTime) % 1000;
        if (timeCalcVar >= 0 && timeCalcVar <= 20)
        {
          digitalWrite(GREENLED, HIGH);
          if (soundEnable)tone(tonepin, alarmTone1, 200);
        }
        if (timeCalcVar  >= 480 && timeCalcVar <= 500)
        {
          if (soundEnable)tone(tonepin, alarmTone2, 200);
          digitalWrite(GREENLED, LOW);
        }
        unsigned long seconds = (millis() - xTime);
        percent = seconds / (ACTIVATESECONDS * 10);
        drawBar(percent);

        //BOMB DISARMED GAME OVER
        if (percent >= 100)disarmedSplash();
      }
      digitalWrite(REDLED, LOW);
      digitalWrite(GREENLED, LOW);
      cls();
    }
  }
}
//################## SABOTAGEM ###############################
void sabotage() {
  endGame = false;
  refresh = true;
  cls();
  digitalWrite(REDLED, LOW);
  digitalWrite(GREENLED, LOW);
  //SETUP INITIAL TIME
  int minutos = GAMEMINUTES - 1;


  if (start) {
    iTime = millis(); //  initialTime of the game, use this because sabotage mode goes can return to sabotage()
    start = false;
  }

  unsigned long aTime;

  //Iniciando o código de Jogo
  while (1) { // Este é um código importante.

    if (endGame) {
      failSplash();
    }
    //Código para piscar led
    timeCalcVar = (millis() - iTime) % 1000;
    if (timeCalcVar >= 0 && timeCalcVar <= 50)digitalWrite(GREENLED, HIGH);
    if (timeCalcVar >= 90 && timeCalcVar <= 130)digitalWrite(GREENLED, LOW);

    lcd.setCursor(1, 0);
    lcd.print(GAME_TIME);
    aTime = millis() - iTime;
    lcd.setCursor(3, 1);

    //PRINT TIME ON LCD
    printTime(minutos, aTime);
    //########################### VERIFICAÇÕES ##################

    //Verificando se o Jogo Terminou
    if (minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) {
      failSplash();
    }

    //Usando a senha de jogo
    if ('d' == keypad.getKey() && passwordEnable) {
      lcd.clear();
       tone(tonepin,2400,30);
      lcd.setCursor(2, 0);
      lcd.print(ARMING_BOMB);
      
      delay(1000);//Um pequeno tempo para pensar na senha
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(ENTER_CODE);

      setCodeTime();// Precisamos definir a senha de comparação

      //Então compara-la :D

      if (comparePassword()) {
        destroySabotage();
      }
      lcd.clear();
      lcd.setCursor(2, 0);
      lcd.print(CODE_ERROR);
      if (soundEnable)tone(tonepin, errorTone, 200);
      delay(500);
      cls();
    }
    
    //Verificação se esta ativando
    while (fusing && !passwordEnable)
    {
      keypad.getKey();
      cls();
      digitalWrite(GREENLED, LOW);
      lcd.clear();
      lcd.setCursor(2, 0);
      lcd.print(ARMING_BOMB);
      lcd.setCursor(0, 1);
      unsigned int percent = 0;
      unsigned long xTime = millis(); //Início do tempo de desativação
      while (fusing)
      {
        keypad.getKey();
        //verifique se o tempo de jogo acaba durante a desativação
        aTime = millis() - iTime;
        if ((minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) || minutos - aTime / 60000 > 4000000000)endGame = true;

        timeCalcVar = (millis() - xTime) % 1000;

        if ( timeCalcVar >= 0 && timeCalcVar <= 40)
        {
          digitalWrite(REDLED, HIGH);
          if (soundEnable)tone(tonepin, alarmTone1, 200);
        }
        if (timeCalcVar >= 480 && timeCalcVar <= 520)
        {
          if (soundEnable)tone(tonepin, alarmTone2, 200);
          digitalWrite(REDLED, LOW);
        }
        unsigned long seconds = millis() - xTime;
        percent = (seconds) / (ACTIVATESECONDS * 10);
        drawBar(percent);

        if (percent >= 100)
        {
          digitalWrite(GREENLED, LOW);
          destroySabotage();// jump to the next gamemode
        }
      }
      cls();
      digitalWrite(REDLED, LOW);
    }
  }
}

void destroySabotage() {
  endGame = false;
  lcd.clear();
  lcd.setCursor(2, 0);
  lcd.print(BOMB_ARMED);
   digitalWrite(RELAYPIN, LOW);   
  delay(1000); 
  digitalWrite(RELAYPIN, HIGH);

  int minutos = BOMBMINUTES - 1;
  unsigned long iTime = millis();
  unsigned long aTime;
  int largoTono = 50;

  //LOOP PRINCIPAL
  while (1) {

    //Se vc falhar, desarme.
    if (endGame) {
      explodeSplash();
    }

    //Led Pisca

    timeCalcVar = (millis() - iTime) % 1000;
    if (timeCalcVar >= 0 && timeCalcVar <= 40)
    {
      digitalWrite(REDLED, HIGH);
      if (soundEnable)tone(tonepin, activeTone, largoTono);
    }
    if (timeCalcVar >= 180 && timeCalcVar <= 220) {
      digitalWrite(REDLED, LOW);
    }
    //Som

    timeCalcVar = (millis() - iTime) % 1000;
    aTime = millis() - iTime;
    if (timeCalcVar >= 245 && timeCalcVar <= 255 && minutos - aTime / 60000 < 2 && soundEnable)tone(tonepin, activeTone, largoTono);
    if (timeCalcVar >= 495 && timeCalcVar <= 510 && minutos - aTime / 60000 < 4 && soundEnable)tone(tonepin, activeTone, largoTono);
    if (timeCalcVar >= 745 && timeCalcVar <= 760 && minutos - aTime / 60000 < 2 && soundEnable)tone(tonepin, activeTone, largoTono);
    if ( minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) < 10)largoTono = 300;

    lcd.setCursor(1, 0);
    lcd.print(DETONATION_IN);
    //Fim do Tempo

    lcd.setCursor(3, 1);

    //////// AQUI ESTÃO AS DUAS OPÇÕES PARA O FIM DO JOGO ///////////

    ////PRIMEIRA OPÇÃO: FIM DO TEMPO E BOMBA EXPLODE
    if (minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) // Verifique se o jogo terminou
    {
      explodeSplash();
    }
    //print time
    printTime(minutos, aTime);

    ////SEGUNDA OPÇÃO: BOTÃO DE DESARME É APERTADO OU ENTRA COM A SENHA


    if ('#' == keypad.getKey() && passwordEnable) {

      cls();
      digitalWrite(REDLED, LOW);
      digitalWrite(GREENLED, HIGH);
      tone(tonepin,2400,30);
      lcd.print(DISARMING);
      delay(1000);//Um pequeno tempo para pensar na senha

      lcd.clear();

      lcd.setCursor(0, 0);
      lcd.print(ENTER_CODE);

      setCodeTime();// Compara a senha


      if (comparePassword()) {
        sabotage();
      }
      lcd.clear();
      lcd.setCursor(2, 0);
      lcd.print(CODE_ERROR);
      if (soundEnable)tone(tonepin, errorTone, 200);
      delay(500);
      cls();
    }

    if (defusing && !passwordEnable) // desarmando a bomba
    {
      lcd.clear();
      digitalWrite(REDLED, LOW);
      lcd.setCursor(3, 0);
      lcd.print(DISARM);
      lcd.setCursor(0, 1);
      unsigned int percent = 0;
      unsigned long xTime = millis();
      while (defusing)
      {
        keypad.getKey();
        //Verifique se o tempo do jogo acaba durante a desativação
        aTime = millis() - iTime;
        if ((minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) || minutos - aTime / 60000 > 4000000000) {
          endGame = true;
        }

        timeCalcVar = (millis() - xTime) % 1000;
        if (timeCalcVar >= 0 && timeCalcVar <= 20)
        {
          digitalWrite(GREENLED, HIGH);
          if (soundEnable)tone(tonepin, alarmTone1, 200);
        }
        if (timeCalcVar >= 480 && timeCalcVar <= 500)
        {
          if (soundEnable)tone(tonepin, alarmTone2, 200);
          digitalWrite(GREENLED, LOW);
        }
        unsigned long seconds = (millis() - xTime);
        percent = seconds / (ACTIVATESECONDS * 10);
        drawBar(percent);

        //BOMBA DESARMADA – RETORNA PARA SABOTAGEM
        if (percent >= 100)
        {
          cls();
          lcd.print("Bomba Desarmada");
          delay(1000);
          sabotage();
        }
      }
      digitalWrite(REDLED, LOW);
      digitalWrite(GREENLED, LOW);
      cls();
    }
  }
}
//################## SAÍDAS ###############################
void drawBar(byte porcent){
  //TODO: Otimize Este Código 
  int box=(8*porcent)/10;
  lcd.setCursor(0,1);
  while(box>=5){
    if(box>=5)
    {
      lcd.write(4);
      box-=5;
    }
  }
    switch(box){
    case 0:
      break;
    case 1:
      lcd.write((uint8_t)0);
      break;
    case 2:
      lcd.write(1);
      break;
    case 3:
      lcd.write(2);
      break;
    case 4:
      lcd.write(3);
      break;
    }
  

}
void cls(){
  lcd.clear();
  lcd.setCursor(0,0);
}

void printTime(unsigned long minutos, unsigned long aTiempo){

  timeCalcVar=minutos-aTiempo/60000;
  //Hours
  
  if(timeCalcVar/60==0 && refresh){
      lcd.clear();
      refresh=false;
      //delay(100);
      lcd.setCursor(3,1);
      Serial.println("!!!!");
  }
   
  if(timeCalcVar/60>=1){
    
    if(timeCalcVar/60<10)
  {
    lcd.setCursor(2,1);
    lcd.print("0");
    lcd.print(timeCalcVar/60);
  }
  else
  {
    lcd.print(timeCalcVar/60);
  }
  
  lcd.print(":");
  
  }
  //minutes
  if(timeCalcVar%60<10)
  {
    lcd.print("0");
    lcd.print(timeCalcVar%60);
  }
  else
  {
    lcd.print(timeCalcVar%60);
  }
  lcd.print(":");
  //seconds
  timeCalcVar=aTiempo/1000;
  if(59-(timeCalcVar%60)<10)
  {
    lcd.print("0");
    lcd.print(59-(timeCalcVar%60));
  }
  else
  {
    lcd.print(59-(timeCalcVar%60));
  }
  lcd.print(":");
  //this not mach with real time, is just a effect, it says 999 because millis%1000 sometimes give 0 LOL
  lcd.print(999-(millis()%1000));
}

void printTimeDom(unsigned long aTiempo, boolean showMillis){
  //minutes
  if((aTiempo/60000)<10)
  {
    lcd.print("0");
    lcd.print(aTiempo/60000);
  }
  else
  {
    lcd.print(aTiempo/60000);
  }
  lcd.print(":");
  //seconds
  if(((aTiempo/1000)%60)<10)
  {
    lcd.print("0");
    lcd.print((aTiempo/1000)%60);
  }
  else
  {
    lcd.print((aTiempo/1000)%60);
  }
  if(showMillis){
    lcd.print(":");
    //this not mach with real time, is just a effect, it says 999 because millis%1000 sometimes give 0 LOL
      lcd.print(999-millis()%1000);

  }
}

void startGameCount(){
  lcd.clear();
  lcd.setCursor(1,0);
  lcd.print("Tudo Pronto!!");
  lcd.setCursor(0,1);
  lcd.print("Aperte um botao");
  keypad.waitForKey();//if you press a button game start

  cls();
  lcd.setCursor(1,0);
  lcd.print("Iniciando Jogo");
  for(int i = 5; i > 0 ; i--){ // START COUNT GAME INIT
    lcd.setCursor(5,1);
    tone(tonepin,2000,100);
    lcd.print("Em ");
    lcd.print(i);
    delay(1000);
  }
  cls();
}

void checkArrows(byte i,byte maxx ){

  if(i==0){
    lcd.setCursor(15,1);
    lcd.write(6); 
  }
  if(i==maxx){  
    lcd.setCursor(15,0);
    lcd.write(5);
  }
  if(i>0 && i<maxx){
    lcd.setCursor(15,1);
    lcd.write(6);
    lcd.setCursor(15,0);
    lcd.write(5);  
  }
}

void activateRelay(){

  digitalWrite(RELAYPIN, LOW);   // turn the LED on (HIGH is the voltage level)
  delay(RELAY_TIME); 
  digitalWrite(RELAYPIN, HIGH);

}

void activateRelay2(){

  digitalWrite(RELAYPIN, LOW);   // turn the LED on (HIGH is the voltage level)
  delay(1000); 
  digitalWrite(RELAYPIN, HIGH);
    delay(500); 
     digitalWrite(RELAYPIN, LOW);   // turn the LED on (HIGH is the voltage level)
  delay(1000); 
  digitalWrite(RELAYPIN, HIGH);
    delay(500); 
     digitalWrite(RELAYPIN, LOW);   // turn the LED on (HIGH is the voltage level)
  delay(1000); 
  digitalWrite(RELAYPIN, HIGH);
  

}
//################## SENHAS ###############################
//Esta função compara: codeInput[8] and password[8] 
boolean comparePassword(){

  for(int i=0;i<4;i++){
    if(codeInput[i]!=password[i])return false;
  }
  return true;
}

//Definindo a senha
void setCode(){

  lcd.setCursor(0, 1);
  for(int i=0;i<4;i++){
    while(1){
      var= getNumber();
      if(var !='x'){
        codeInput[i] = var;

        if (i != 0){
          lcd.setCursor(i-1,1);
          lcd.print("*");
          lcd.print(var);
        }
        else
        {
          lcd.print(var);
        }
        tone(tonepin,2400,30);
        break;
      }
    }
  }
}
void setCodeTime(){

  timeCalcVar=millis();

  for(int i=0;i<4;i++){
    while(1){
      if(ACTIVATESECONDS*1000+timeCalcVar-millis()<=100){
        codeInput[i]='x';
        break;
      }

      lcd.setCursor(11,2);
      printTimeDom(ACTIVATESECONDS*1000+timeCalcVar-millis(),false);

      var= getNumber();
      if(var !='x'){
        codeInput[i] = var;

        if (i != 0){
          lcd.setCursor(i-1,2);
          lcd.print("*");
          lcd.print(var);
        }
        else
        {
          lcd.print(var);
        }
        tone(tonepin,2400,30);
        break;
      }
    }
  }
}
void setPass(){
  lcd.setCursor(0, 1);

  for(int i=0;i<4;i++){ 
    while(1){
      var= getNumber();
      if(var !='x'){
        password[i] =  var;
        if (i != 0){
          lcd.setCursor(i-1,1);
          lcd.print("*");
          lcd.print(var);
        }
        else
        {
          lcd.print(var);
        }
        tone(tonepin,2400,30);
        break;
      }
    }  
  }
}

void setNewPass(){

  while(1){
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Nova senha:");
    setPass();

    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Redigite senha:");

    setCode();

    if(comparePassword()){

      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Senha OK!");
      delay(2000); 
      break; 
    }
    else {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Senha nao bate!");
      if(soundEnable)tone(tonepin,errorTone,200);
      delay(2000); 

    }
  }
}
//Caso seja digitado uma letra no lugar de um número, retornara “x”



char getNumber(){
  while(1){
    var = keypad.getKey();
    if (var){//
      switch (var) {
      case 'a': 
        return 'x';
        break;
      case 'b': 
        return 'x';
        break;

      case 'c': 
        return 'x';
        break;
      case 'd': 
        return 'x';
        break;
      case '*': 
        return 'x';
        break;
      case '#': 
        return 'x';
        break;
      default:
        return var;
        break;
      }
    }
    return 'x';
  }
}

byte getRealNumber(){

  while(1){
    var = keypad.waitForKey();

    if (var){//
      switch (var) {
      case '1': 
        return 1;
        break;
      case '2': 
        return 2;
        break;

      case '3': 
        return 3;
        break;
      case '4': 
        return 4;
        break;
      case '5': 
        return 5;
        break;
      case '6': 
        return 6;
      case '7': 
        return 7;
        break;
      case '8': 
        return 8;
        break;
      case '9': 
        return 9;
        break;
        case '0': 
        return 0;
        break;
        
      default:
        return 11;
        break;
      }

    }
    return 11;
  }
}