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

//CONFIGURAÇÃO DO DISPLAY
LiquidCrystal_I2C lcd(0x27, 16, 2);
// LiquidCrystal_I2C lcd(0x3F, 16, 2);

//CONFIGURAÇÃO DO TECLADO 4X4
byte rowPins[4] = {11, 10, 9, 8};
//byte rowPins[4] = {8, 9, 10, 11};
byte colPins[4] = {7, 6, 5, 4};
//byte colPins[4] = {7, 6, 5, 4};
char keys[4][4] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, 4, 4);

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

//CONFIGURAÇÃO PARA DISPLAY COM BOTÕES
char BT_RIGHT = '4';
char BT_UP = 'A';
char BT_DOWN = 'B';
char BT_LEFT = '6';
char BT_SEL = 'D';
char BT_CANCEL = 'C';
char BT_DEFUSER = 'x';

//PINAGEM DOS LEDS
const int GREENLED = 3;
const int REDLED = 2;
const int YELLOWLED = 12;
const int BLUELED = 13;

//CONFIGURAÇÕES DO RELÉ
boolean relayEnable = false;
const int RELAYPIN = A2;
const int RELAY_TIME = 10000;

//TEMPO INICIAL
int GAMEHOURS = 0;
int GAMEMINUTES = 45;
int BOMBMINUTES = 4;
int ACTIVATESECONDS = 5;

boolean endGame = false;

boolean sdStatus = false;
boolean saStatus = false;
boolean doStatus = false;
boolean start = true;
boolean defusing;
boolean cancel;

//CONFIGURAÇÃO PARA OS SONS
boolean soundEnable = true;
int tonepin = A3;
int alarmTone1 = 700;
int alarmTone2 = 2600;
int activeTone = 1330;
int errorTone = 100;

unsigned long iTime;
unsigned long timeCalcVar;
unsigned long team2;
unsigned long team1;
unsigned long iZoneTime;
// 0 = NEUTRO, 1 = AMARELO, 2 = AZUL
byte team = 0;

//TODOS OS TEXTOS
char* menu1[] = {"DEMOLICAO", "SABOTAGEM", "DOMINACAO", "Configuration"};
char* menu2[] = {"Game Config", "Sound Config", "Relay Test", "Auto Test"};
char* GAME_TIME = " TEMPO DE JOGO: ";
char* BOMB_TIME = "TEMPO DE BOMBA:";
char* ZERO_MINUTES = "00 MINUTOS";
char* ARM_TIME = "TEMPO PARA ARMAR:";
char* ZERO_SECS = "00 SEGUNDOS";
char* ENABLE_SOUND = "ATIVAR SOM?";
char* YES_OR_NOT = "A : SIM  B : NAO";
char* ENABLE_RELAYPIN = "ATIVAR RELE?";
char* ENABLE_CODE = "ATIVAR SENHA?";
char* GAME_TIME_TOP = " TEMPO DE JOGO: ";
char* ARMING_BOMB = "ARMANDO BOMBA!";
char* ENTER_CODE = "SENHA:";
char* CODE_ERROR = "SENHA ERRADA";
char* NEW_CODE = "   NOVA SENHA   ";
char* REPEAT_CODE = " REPITA A SENHA ";
char* OK_CODE = "SENHAS  CONFEREM";
char* ERROR_CODE = "SENHAS  DIVERGEM";
char* BOMB_ARMED = "BOMBA ARMADA";
char* DETONATION_IN = "DETONACAO EM";
char* DISARMING = "DESARMANDO BOMBA" ;
char* DISARM = "DESARMANDO";
char* GAME_OVER = "  FIM DE JOGO!  ";
char* DEFENDERS_WIN = "DEFENDIDO!";
char* SABOTAGE_FAIL = "SABOTAGEM FALHOU!";
char* PLAY_AGAIN = "JOGAR NOVAMENTE?";
char* TIME_OVER = "  TEMPO ACABOU  ";
char* TERROR_WIN = "TERROR  VENCERAM";
char* PLAY = "PRONTO P/ INICIO";
char* PRESS_KEY = "APERTE UMA TECLA";
char* INIT = "COMECANDO O JOGO";
char* IN = "EM ";
char* BOMB_DESARM = "BOMBA  DESARMADA";
char* CT_WIN = "  CTs VENCERAM  ";
char* NEUTRAL_ZONE = "  ZONA  NEUTRA  ";
char* TEAM1_ZONE = "   ZONA  AZUL   ";
char* TEAM2_ZONE = "  ZONA AMARELA  ";
char* NEUTRALIZING = "NEUTRALIZANDO...";
char* CAPTURE_ZONE = "CAPTURANDO  ZONA";
char* TEAM1_WIN = "  AZUL  VENCEU  ";
char* TEAM2_WIN = " AMARELO VENCEU ";
char* TIED = "     EMPATE     ";
char* TEAM1_TIME = "TEMPO AZUL: ";
char* TEAM2_TIME = "TEMPO AMARELO: ";

void setup() {
  Serial.begin(115200);
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("  ITA  AIRSOFT  ");// you can add your team name or someting cool
  lcd.setCursor(0, 1);
  lcd.print("  SORRISO - MT  ");// you can add your team name or someting cool
  delay(2000);
  tone(tonepin, 2400, 30);
  keypad.setHoldTime(50);
  keypad.setDebounceTime(50);
  keypad.addEventListener(keypadEvent);

  //MODO DOS PINOS
  pinMode(GREENLED, OUTPUT);
  pinMode(REDLED, OUTPUT);
  pinMode(YELLOWLED, OUTPUT);
  pinMode(BLUELED, OUTPUT);
  pinMode(RELAYPIN, OUTPUT);
  digitalWrite(RELAYPIN, LOW);

  //TESTE LEDS
  digitalWrite(GREENLED, HIGH);
  digitalWrite(REDLED, HIGH);
  digitalWrite(BLUELED, HIGH);
  digitalWrite(YELLOWLED, HIGH);
  delay(500);
  digitalWrite(GREENLED, LOW);
  digitalWrite(REDLED, LOW);
  digitalWrite(BLUELED, LOW);
  digitalWrite(YELLOWLED, LOW);
  delay(500);

  // 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() {
  menuPrincipal();
}

void keypadEvent(KeypadEvent key) {
  switch (keypad.getState()) {
    case RELEASED:
      switch (key) {
        case 'D': defusing = false;
          break;
        case 'C': cancel = false;
          break;
      }
      break;
    case HOLD:
      switch (key) {
        case 'D': defusing = true;
          break;
        case 'C': cancel = true;
          break;
      }
      break;
  }
}

//##################MENUS###############################
void menuPrincipal() {  //MAIN MENU
  digitalWrite(GREENLED, LOW);
  digitalWrite(REDLED, LOW);
  digitalWrite(YELLOWLED, LOW);
  digitalWrite(BLUELED, LOW);
  saStatus = false;
  sdStatus = false;
  doStatus = false;
  //DESENHA O MENU
  cls();
  int i = 0;
  // MENU
  //imprime o menu1 na posição 0
  lcd.print(menu1[i]);
  //seta a posição na coluna 15 da linha 1
  lcd.setCursor(15, 1);
  //verifica se precisa por a seta pra cima, baixo ou as duas
  checkArrows(i, 2);
  while (1) {
    //aguarda digitar algo
    var = keypad.waitForKey();
    //se digitar o botão pra cima, ou seja a tecla A
    if (var == BT_UP && i > 0) {
      //vai fazer um som
      tone(tonepin, 2400, 30);
      //remover 1 da variável i
      i--;
      //limpa o display
      cls();
      //imprime o menu referente ao valor de i
      lcd.print(menu1[i]);
      //faz novamente a checkagem das setas
      checkArrows(i, 2);
      //delay de 50 milissegundos
      delay(50);
    }
    //o mesmo é feito para o botão B pressionado
    if (var == BT_DOWN && i < 2) {
      tone(tonepin, 2400, 30);
      i++;
      cls();
      lcd.print(menu1[i]);
      checkArrows(i, 2);
      delay(50);
    }
    //caso aperte o botão de selecionar, ou seja, D
    if (var == BT_SEL) {
      //toca um som
      tone(tonepin, 2400, 30);
      //limpa a tela
      cls();
      //verifica qual opção foi escolhida atraves do valor de i
      switch (i) {
        //se for 0
        case 0:
          //altera o sdStatus para true
          sdStatus = true;
          //chama as funções
          configQuickGame();
          startGameCount();
          search();
          break;
        case 1:
          saStatus = true;
          configQuickGame();
          startGameCount();
          sabotage();
          break;
        case 2:
          doStatus = true;
          configQuickGame();
          startGameCount();
          domination();
          break;
          // case 3:
          //   config();
          //   break;
      }
    }
  }
}
//FUNÇÃO CONFIGURAR (NÃO USADA)
// void config() {
//   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();
//           break;
//         case 1:
//           //soundConfigMenu();
//           break;
//         case 2:
//           cls();
//           lcd.print("RELE ON!");
//           digitalWrite(RELAYPIN, HIGH);
//           delay(4000);
//           cls();
//           lcd.print("RELE OFF!");
//           digitalWrite(RELAYPIN, LOW);
//           delay(2000);
//           config();
//           break;
//       }
//     }
//   }
// }

void configQuickGame() {
  cls();
  //GAME TIME
  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;
          lcd.print(varu);
          tone(tonepin, 2400, 30);
          break;
        }
      }
    }
    lcd.noCursor();
    lcd.noBlink();
    lcd.setCursor(13, 1);
    lcd.print("OK?");
    //zona donde pasamos los items a
    //redibujar
    while (1) {
      var = keypad.waitForKey();
      if (var == 'D') {
        tone(tonepin, 2400, 30);
        GAMEMINUTES = ((time[0] * 600) + (time[1] * 60) + (time[2] * 10) + (time[3]));
        break;
      }
      if (var == 'C') {
        tone(tonepin, 2400, 30);
        goto menu1;
      }
    }
    tone(tonepin, 2400, 30);
    cls();
  }
  //BOMB TIME
  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?");
    //zona donde pasamos los items a
    //redibujar
    while (1) {
      var = keypad.waitForKey();
      if (var == 'D') {
        tone(tonepin, 2400, 30);
        BOMBMINUTES = ((time[0] * 10) + (time[1]));
        break;
      }
      if (var == 'C') {
        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?");
    while (1) {
      var = keypad.waitForKey();
      if (var == 'D') {
        tone(tonepin, 2400, 30);
        ACTIVATESECONDS = ((time[0] * 10) + (time[1]));
        break;
      }
      if (var == 'C') {
        tone(tonepin, 2400, 30);
        goto menu3;
      }
    }
    tone(tonepin, 2400, 30);
    cls();
  }
  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 RELE QUANDO ACABAR O JOGO
  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;
      }
    }
  }

  //SE QUER SENHA OU NÃO
  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);
  }
}

//ESTA FUNÇÃO COMPARA SE AS SENHAS CONFEREM
boolean comparePassword() {
  for (int i = 0; i < 8; i++) {
    if (codeInput[i] != password[i])return false;
  }
  return true;
}

//FUNÇÃO PARA SOLICITAR SENHA E CONFERÊNCIA E DEPOIS VERIFICAR SE SÃO IGUAIS
void setNewPass() {
  while (1) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(NEW_CODE);
    setPass();
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(REPEAT_CODE);
    setCode();
    if (comparePassword()) {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(OK_CODE);
      delay(2000);
      break;
    }
    else {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(ERROR_CODE);
      if (soundEnable)tone(tonepin, errorTone, 200);
      delay(2000);
    }
  }
}

//NOVA SENHA
void setPass() {
  for (int i = 0; i < 8; 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.setCursor(i, 1);
          lcd.print(var);
        }
        tone(tonepin, 2400, 30);
        break;
      }
    }
  }
}

//SENHA DE CONFERÊNCIA
void setCode() {
  for (int i = 0; i < 8; 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.setCursor(i, 1);
          lcd.print(var);
        }
        tone(tonepin, 2400, 30);
        break;
      }
    }
  }
}

//SENHA PARA ATIVAR OU DESATIVAR
void setCodeTime() {
  timeCalcVar = millis();
  for (int i = 0; i < 8; i++) {
    while (1) {
      if (ACTIVATESECONDS * 1000 + timeCalcVar - millis() <= 100) {
        codeInput[i] = 'x';
        break;
      }
      lcd.setCursor(11, 0);
      printTimeDom(ACTIVATESECONDS * 1000 + timeCalcVar - millis(), false);
      var = getNumber();
      if (var != 'x') {
        codeInput[i] = var;
        if (i != 0) {
          lcd.setCursor(i - 1, 1);
          lcd.print("*");
          lcd.print(var);
        }
        else {
          lcd.setCursor(i, 1);
          lcd.print(var);
        }
        tone(tonepin, 2400, 30);
        break;
      }
    }
  }
}

//AGUARDA SER DIGITADO ALGUM NUMERO PARA AS SENHAS, CASO DIGITAR LETRAS OU CARACTERES, ENVIA UM 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';
  }
}

//PARA ACEITAR APENAS NUMEROS PARA CONFIGURAÇÕES
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;
  }
}

//DESENHA A BARRA DE CARREGAMENTO
void drawBar(byte porcent) {
  //TODO: Optimize this code
  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;
  }
}

//PARA LIMPAR O DISPLAY
void cls() {
  lcd.clear();
  lcd.setCursor(0, 0);
}

//PARA IMPRIMIR O TEMPO COM HORAS
void printTime(unsigned long minutos, unsigned long aTiempo) {
  timeCalcVar = minutos - aTiempo / 60000;
  //HORAS
  if (timeCalcVar / 60 == 0 && refresh) {
    lcd.clear();
    refresh = false;
    lcd.setCursor(3, 1);
  }
  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(":");
  }
  //MINUTOS
  if (timeCalcVar % 60 < 10) {
    lcd.print("0");
    lcd.print(timeCalcVar % 60);
  }
  else {
    lcd.print(timeCalcVar % 60);
  }
  lcd.print(":");
  //SEGUNDOS
  timeCalcVar = aTiempo / 1000;
  if (59 - (timeCalcVar % 60) < 10) {
    lcd.print("0");
    lcd.print(59 - (timeCalcVar % 60));
  }
  else {
    lcd.print(59 - (timeCalcVar % 60));
  }
  lcd.print(":");
  //PARA CORRIGIR BUG
  lcd.print(999 - (millis() % 1000));
}

//PARA IMPRIMIR TEMPO SEM HORAS
void printTimeDom(unsigned long aTiempo, boolean showMillis) {
  //MINUTOS
  if ((aTiempo / 60000) < 10) {
    lcd.print("0");
    lcd.print(aTiempo / 60000);
  }
  else {
    lcd.print(aTiempo / 60000);
  }
  lcd.print(":");
  //SEGUNDOS
  if (((aTiempo / 1000) % 60) < 10) {
    lcd.print("0");
    lcd.print((aTiempo / 1000) % 60);
  }
  else {
    lcd.print((aTiempo / 1000) % 60);
  }
  if (showMillis) {
    lcd.print(":");
    //PARA CORRIGIR BUG
    lcd.print(999 - millis() % 1000);
  }
}

//PARA INICIAR A CONTAGEM DE TEMPO
void startGameCount() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(PLAY);
  lcd.setCursor(0, 1);
  lcd.print(PRESS_KEY);
  //AGUARDANDO APERTAR UM BOTÃO PARA INICIAR
  keypad.waitForKey();
  cls();
  lcd.setCursor(0, 0);
  lcd.print(INIT);
  //CONTAGEM PARA INICIAR
  for (int i = 5; i > 0 ; i--) {
    lcd.setCursor(5, 1);
    tone(tonepin, 2000, 100);
    lcd.print(IN);
    lcd.print(i);
    delay(1000);
  }
  cls();
}

//CHECAGEM DE SETAS
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);
  }
}

//RELE ATIVADO
void activateRelay() {
  digitalWrite(RELAYPIN, HIGH);
  delay(RELAY_TIME);
  digitalWrite(RELAYPIN, LOW);
}

//EXPLOSAO
void explodeSplash() {
  digitalWrite(REDLED, LOW);
  digitalWrite(GREENLED, LOW);
  cls();
  delay(100);
  endGame = false;
  lcd.setCursor(0, 0);
  lcd.print(TERROR_WIN);
  lcd.setCursor(0, 1);
  lcd.print(GAME_OVER);
  for (int i = 200; i > 0; i--) {
    tone(tonepin, i);
    delay(20);
  }
  noTone(tonepin);
  if (relayEnable) {
    activateRelay();
  }
  delay(300000);
  cls();
  //APÓS 5 MINUTOS MOSTRA SE QUER JOGAR NOVAMENTE
  playAgain();
}

//TEMPO ACABOU
void failSplash() {
  digitalWrite(REDLED, LOW);
  digitalWrite(GREENLED, LOW);
  cls();
  delay(100);
  endGame = false;
  lcd.setCursor(0, 0);
  lcd.print(TIME_OVER);
  lcd.setCursor(0, 1);
  lcd.print(GAME_OVER);
  for (int i = 200; i > 0; i--) {
    tone(tonepin, i);
    delay(20);
  }
  noTone(tonepin);
  if (relayEnable) {
    activateRelay();
  }
  delay(300000);
  cls();
  //APÓS 5 MINUTOS MOSTRA SE QUER JOGAR NOVAMENTE
  playAgain();
}

void disarmedSplash() {
  endGame = false;
  digitalWrite(REDLED, LOW);
  digitalWrite(GREENLED, LOW);
  if (sdStatus || saStatus) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(BOMB_DESARM);
    lcd.setCursor(0, 1);
    lcd.print(CT_WIN);
    digitalWrite(GREENLED, HIGH);
    delay(300000);
    digitalWrite(GREENLED, LOW);
  }
  cls();
  //APÓS 5 MINUTOS MOSTRA SE QUER JOGAR NOVAMENTE
  playAgain();
}

//PARA MOSTRAR SE QUER JOGAR NOVAMENTE
void playAgain() {
  lcd.print(PLAY_AGAIN);
  lcd.setCursor(0, 1);
  lcd.print(YES_OR_NOT);
  while (1) {
    var = keypad.waitForKey();
    if (var == 'A' ) {
      tone(tonepin, 2400, 30);
      if (sdStatus) {
        startGameCount();
        search();
      }
      if (saStatus) {
        saStatus = true;
        startGameCount();
        start = true;
        sabotage();
      }
    }
    if (var == 'B' ) {
      tone(tonepin, 2400, 30);
      menuPrincipal();
      break;
    }
  }
}

void search() {
  refresh = true;
  cls();
  digitalWrite(REDLED, LOW);
  digitalWrite(GREENLED, LOW);
  //SETUP INITIAL TIME
  int minutos = GAMEMINUTES - 1;
  unsigned long iTime = millis();
  unsigned long aTime;
  while (1) {
    if (endGame) {
      failSplash();
    }
    timeCalcVar = (millis() - iTime) % 1000;
    if (timeCalcVar >= 0 && timeCalcVar <= 50)digitalWrite(GREENLED, HIGH);
    if (timeCalcVar >= 90 && timeCalcVar <= 130)digitalWrite(GREENLED, LOW);
    lcd.setCursor(0, 0);
    lcd.print(GAME_TIME_TOP);
    aTime = millis() - iTime;
    lcd.setCursor(3, 1);
    printTime(minutos, aTime);

    //###########################CHECAGENS##################

    //CHECA SE O TEMPO ACABOU
    if ((minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) || minutos - aTime / 60000 > 1000)failSplash();
    //PARA DIGITAR A SENHA
    if ('D' == keypad.getKey() && passwordEnable) {
      lcd.clear();
      lcd.setCursor(1, 0);
      lcd.print(ARMING_BOMB);
      delay(1000);
      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();
    }
    while (defusing && !passwordEnable) {
      digitalWrite(GREENLED, LOW);
      lcd.clear();
      lcd.setCursor(1, 0);
      lcd.print(ARMING_BOMB);
      lcd.setCursor(0, 1);
      unsigned int percent = 0;
      unsigned long xTime = millis();
      while (defusing) {
        keypad.getKey();
        percent = (millis() - xTime) / (ACTIVATESECONDS * 10);
        drawBar(percent);
        aTime = millis() - iTime;
        if ((minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) || minutos - aTime / 60000 > 1000) {
          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();
        }
      }
      cls();
      digitalWrite(REDLED, LOW);
    }
  }
}

//MODO DE JOGO: DESTRUIÇÃO
void destroy() {
  lcd.clear();
  lcd.setCursor(2, 0);
  lcd.print(BOMB_ARMED);
  delay(1000);
  int minutos = BOMBMINUTES - 1;
  unsigned long iTime = millis();
  unsigned long aTime;
  int largoTono = 50;
  while (1) {
    //SE O DESARME FALHAR
    if (endGame) {
      explodeSplash();
    }
    //PISCAR DO LED
    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
    aTime = millis() - iTime;
    timeCalcVar = (millis() - iTime) % 1000;
    if ( minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) < 10)largoTono = 300;
    lcd.setCursor(2, 0);
    lcd.print(DETONATION_IN);
    //TEMPO PASSADO
    lcd.setCursor(3, 1);

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

    //PRIMEIRA OPÇÃO: FIM DO TEMPO
    if ((minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) || minutos - aTime / 60000 > 1000) {
      explodeSplash();
    }
    printTime(minutos, aTime);

    //SEGUNDA OPÇÃO: DISARMANDO
    if ('D' == keypad.getKey() && passwordEnable) {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(DISARMING);
      delay(1000);
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(ENTER_CODE);
      setCodeTime();
      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) {
      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();
        //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 > 1000) {
          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
        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);
  int minutos = GAMEMINUTES - 1;
  if (start) {
    iTime = millis();
    start = false;
  }
  unsigned long aTime;
  while (1) {
    //ACABOU O TEMPO
    if (endGame) {
      failSplash();
    }
    //PISCAR LED
    timeCalcVar = (millis() - iTime) % 1000;
    if (timeCalcVar >= 0 && timeCalcVar <= 50)digitalWrite(GREENLED, HIGH);
    if (timeCalcVar >= 90 && timeCalcVar <= 130)digitalWrite(GREENLED, LOW);
    lcd.setCursor(0, 0);
    lcd.print(GAME_TIME);
    aTime = millis() - iTime;
    lcd.setCursor(3, 1);
    //IMPRIMIR TEMPO NO LCD
    printTime(minutos, aTime);

    //###########################CHECAGENS##################

    //CHECA SE ACABOU O JOGO
    if ((minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) || minutos - aTime / 60000 > 1000) {
      failSplash();
    }
    //PARA INSERIR A SENHA
    if ('D' == keypad.getKey() && passwordEnable) {
      lcd.clear();
      lcd.setCursor(1, 0);
      lcd.print(ARMING_BOMB);
      delay(1000);
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(ENTER_CODE);
      setCodeTime();
      if (comparePassword()) {
        destroySabotage();
      }
      lcd.clear();
      lcd.setCursor(2, 0);
      lcd.print(CODE_ERROR);
      if (soundEnable)tone(tonepin, errorTone, 200);
      delay(500);
      cls();
    }

    //CHECA SE ESTA ATIVADA
    while (defusing && !passwordEnable) {
      keypad.getKey();
      cls();
      digitalWrite(GREENLED, LOW);
      lcd.clear();
      lcd.setCursor(1, 0);
      lcd.print(ARMING_BOMB);
      lcd.setCursor(0, 1);
      unsigned int percent = 0;
      unsigned long xTime = millis();
      while (defusing)
      {
        keypad.getKey();
        aTime = millis() - iTime;
        if ((minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) || minutos - aTime / 60000 > 1000)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();
        }
      }
      cls();
      digitalWrite(REDLED, LOW);
    }
  }
}

void destroySabotage() {
  endGame = false;
  lcd.clear();
  lcd.setCursor(2, 0);
  lcd.print(BOMB_ARMED);
  delay(1000);
  int minutos = BOMBMINUTES - 1;
  unsigned long iTime = millis();
  unsigned long aTime;
  int largoTono = 50;
  while (1) {
    if (endGame) {
      explodeSplash();
    }
    //PISCAR LED
    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 ( minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) < 10)largoTono = 300;
    lcd.setCursor(1, 0);
    lcd.print(DETONATION_IN);
    lcd.setCursor(3, 1);

    ////////AQUI AS DUAS OPÇÕES DE FIM DE JOGO///////////

    //PRIMEIRA OPÇÃO: ACABOU O TEMPO
    if ((minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) || minutos - aTime / 60000 > 1000) {
      failSplash();
    }
    //IMPRIMIR O TEMPO
    printTime(minutos, aTime);
    //SEGUNDA OPÇÃO: APERTAR O BOTÃO DE DESARMAR
    if ('D' == keypad.getKey() && passwordEnable) {
      cls();
      digitalWrite(REDLED, LOW);
      digitalWrite(GREENLED, HIGH);
      lcd.print(DISARMING);
      delay(1000);
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(ENTER_CODE);
      setCodeTime();
      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) {
      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();
        aTime = millis() - iTime;
        if ((minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) || minutos - aTime / 60000 > 1000) {
          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
        if (percent >= 100) {
          cls();
          lcd.print(BOMB_DESARM);
          delay(1000);
          sabotage();
        }
      }
      digitalWrite(REDLED, LOW);
      digitalWrite(GREENLED, LOW);
      cls();
    }
  }
}

//MODO DE JOGO: DOMINAÇÃO
void domination() {
  int minutos = GAMEMINUTES - 1;
  boolean showGameTime = true;
  unsigned long a;
  unsigned long iTime = millis();
  unsigned long aTime;
  team = 0;
  iZoneTime = 0;
  aTime = 0;
  team2 = 0;
  team1 = 0;
  int largoTono = 50;
  // 0 = NEUTRO, 1 = AZUL, 2 = AMARELO
  a = millis();
  while (1) {
    if (endGame) {
      gameOver();
    }
    keypad.getKey();
    aTime = millis() - iTime;
    //PISCAR LED
    timeCalcVar = (millis() - iTime) % 1000;
    if (timeCalcVar >= 0 && timeCalcVar <= 40) {
      if (team == 0)digitalWrite(GREENLED, HIGH);
      if (team == 1)digitalWrite(BLUELED, HIGH);
      if (team == 2)digitalWrite(YELLOWLED, HIGH);
    }
    if (timeCalcVar >= 50 && timeCalcVar <= 100) {
      if (team == 0)digitalWrite(GREENLED, LOW);
      if (team == 1)digitalWrite(BLUELED, LOW);
      if (team == 2)digitalWrite(YELLOWLED, LOW);
    }
    //SOM
    if (timeCalcVar >= 0 && timeCalcVar <= 40 && soundEnable)tone(tonepin, activeTone, largoTono);
    if (a + 2000 < millis()) {
      a = millis();
      showGameTime = !showGameTime;
      cls();
    }
    //MOSTRAR TEMPO
    if (showGameTime) {
      lcd.setCursor(0, 0);
      lcd.print(GAME_TIME);
      lcd.setCursor(3, 1);
      printTime(minutos, aTime);
    }
    else if (!showGameTime) {
      lcd.setCursor(0, 0);
      if (team == 0)lcd.print(NEUTRAL_ZONE);
      if (team == 1)lcd.print(TEAM1_ZONE);
      if (team == 2)lcd.print(TEAM2_ZONE);
      if (team > 0) {
        lcd.setCursor(3, 1);
        printTimeDom(millis() - iZoneTime, true);
      }
    }

    //###########################CHECAGENS##################

    //CHECA O FIM DO JOGO
    if (minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) {
      gameOver();
    }

    //CHECA SE É NEUTRO
    while ((defusing || cancel) && team > 0) {
      cls();
      if (team > 0)lcd.print(NEUTRALIZING);
      lcd.setCursor(0, 1);
      unsigned int percent = 0;
      unsigned long xTime = millis();
      while (defusing || cancel) {
        //CHECA SE TEM TEMPO DURANTE O DESARME
        aTime = millis() - iTime;
        if ((minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) || minutos - aTime / 60000 > 1000) {
          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) {
          delay(1000);
          if (team == 1) {
            team1 += millis() - iZoneTime;
            iZoneTime = 0;
          }
          if (team == 2) {
            team2 += millis() - iZoneTime;
            iZoneTime = 0;
          }
          team = 0;
          break;
        }
      }
      cls();
    }

    //CAPTURANDO ZONA AMARELA
    while (defusing && team == 0 ) {
      digitalWrite(GREENLED, LOW);
      cls();
      if (team == 0)lcd.print(CAPTURE_ZONE);
      lcd.setCursor(0, 1);
      unsigned int percent = 0;
      unsigned long xTime = millis();
      while (defusing) {
        keypad.getKey();
        aTime = millis() - iTime;
        if ((minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) || minutos - aTime / 60000 > 1000) {
          endGame = true;
        }
        timeCalcVar = (millis() - xTime) % 1000;
        if ( timeCalcVar >= 0 && timeCalcVar <= 20) {
          digitalWrite(YELLOWLED, HIGH);
          if (soundEnable)tone(tonepin, alarmTone1, 200);
        }
        if (timeCalcVar >= 480 && timeCalcVar <= 500) {
          if (soundEnable)tone(tonepin, alarmTone2, 200);
          digitalWrite(YELLOWLED, LOW);
        }
        unsigned long seconds = millis() - xTime;
        percent = (seconds) / (ACTIVATESECONDS * 10);
        drawBar(percent);
        if (percent >= 100) {
          digitalWrite(YELLOWLED, LOW);
          team = 2;
          iZoneTime = millis();
          delay(1000);
          break;
        }
      }
      cls();
      digitalWrite(YELLOWLED, LOW);
    }

    //CAPTURANDO ZONA AZUL
    while (cancel && team == 0 ) {
      digitalWrite(GREENLED, LOW);
      cls();
      if (team == 0)lcd.print(CAPTURE_ZONE);
      lcd.setCursor(0, 1);
      unsigned int percent = 0;
      unsigned long xTime = millis();
      while (cancel) {
        keypad.getKey();
        aTime = millis() - iTime;
        if ((minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) || minutos - aTime / 60000 > 1000) {
          endGame = true;
        }
        timeCalcVar = (millis() - xTime) % 1000;
        if ( timeCalcVar >= 0 && timeCalcVar <= 20) {
          digitalWrite(BLUELED, HIGH);
          if (soundEnable)tone(tonepin, alarmTone1, 200);
        }
        if (timeCalcVar >= 480 && timeCalcVar <= 500) {
          if (soundEnable)tone(tonepin, alarmTone2, 200);
          digitalWrite(BLUELED, LOW);
        }
        unsigned long seconds = millis() - xTime;
        percent = (seconds) / (ACTIVATESECONDS * 10);
        drawBar(percent);

        if (percent >= 100) {
          digitalWrite(BLUELED, LOW);
          team = 1;
          iZoneTime = millis();
          delay(1000);
          break;
        }
      }
      cls();
      digitalWrite(BLUELED, LOW);
    }
  }
}

//FIM DE JOGO
void gameOver() {
  if (team == 1)team1 += millis() - iZoneTime;
  if (team == 2)team2 += millis() - iZoneTime;
  digitalWrite(GREENLED, LOW);
  digitalWrite(REDLED, LOW);
  while (!defusing) {
    keypad.getKey();
    if (defusing) {
      keypad.getKey();
      break;
    }
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print(TIME_OVER);
    lcd.setCursor(0, 1);
    if (team1 == team2) {
      lcd.print(TIED);
      digitalWrite(GREENLED, HIGH);
    } else if (team1 > team2) {
      lcd.print(TEAM1_WIN);
      digitalWrite(REDLED, LOW);
      digitalWrite(GREENLED, LOW);
      digitalWrite(YELLOWLED, LOW);
      digitalWrite(BLUELED, HIGH);
    }
    else if (team2 > team1) {
      lcd.print(TEAM2_WIN);
      digitalWrite(REDLED, LOW);
      digitalWrite(GREENLED, LOW);
      digitalWrite(YELLOWLED, HIGH);
      digitalWrite(BLUELED, LOW);
    }
    delay(3000);
    keypad.getKey();
    if (defusing) {
      keypad.getKey();
      break;
    }
    cls();
    lcd.print(TEAM2_TIME);
    lcd.setCursor(3, 1);
    printTimeDom(team2, true);
    delay(3000);
    keypad.getKey();
    if (defusing) {
      break;
    }
    cls();
    lcd.print(TEAM1_TIME);
    lcd.setCursor(3, 1);
    printTimeDom(team1, true);
    delay(3000);
    keypad.getKey();
    if (defusing) {
      keypad.getKey();
      break;
    }
  }
  cls();
  delay(3000000);
  playAgain();
}