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

static const uint8_t PIN_MP3_TX = 3; // D7
static const uint8_t PIN_MP3_RX = 2; // D6
SoftwareSerial softwareSerial(PIN_MP3_RX, PIN_MP3_TX);

DFRobotDFPlayerMini player;


// Aqui vc deve usar o I2C Scanner para descobrir
// a porta correta e mudar o 0x27 por ela, no
// meu arduino era 0x38, link do i2c Scanner
// https://playground.arduino.cc/Main/I2cScanner/
LiquidCrystal_I2C lcd(0x27, 16, 2);

// STRINGS DO LCD
const int PASSWORD_SIZE = 6;
char * menu1[] = {
  "Arme/Desarme",
  "Sabotagem",
  "Dominacao",
  "Configuracao"
};

char * menu2[] = {
  "Teste Rele",
  "Teste Player"
};

char * WELCOME_TITLE = "GSA - BOMBA v1.0";
char * WELCOME_MESSAGE = "Inicializando...";
char * GAME_TIME = "Tempo de Jogo:";
char * BOMB_TIME = "Tempo Explosao:";
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 Codigo?";
char * GAME_TIME_TOP = "Tempo de Jogo";
char * ARMING_BOMB = "ARMANDO...";
char * DISARMING_BOMB = "DESARMANDO...";
char * ENTER_CODE = "Insira o Codigo";
char * CODE_ERROR = "Codigo Errado!";
char * BOMB_ARMED = "BOMBA ARMADA";
char * DETONATION_IN = "EXPLOSAO EM";
char * GAME_OVER = " GAME OVER! ";
char * DEFENDERS_WIN = "DEFENSORES GANHARAM ";
char * SABOTAGE_FAIL = "SABOTAGEM FALHOU!";
char * PLAY_AGAIN = "Jogar Novamente?";
char * TIME_OVER = "Tempo Acabou!";
char * GREEN_TEAM_WINS = "Time Verde Venceu";
char * RED_TEAM_WINS = "Time Vermelho Venceu";
char * GREEN_TIME = "Tempo Verde:";
char * RED_TIME = "Tempo Vermelho:";
char * READY_TO_START = "PRONTO?";
char * NEUTRAL_ZONE = "Zona Neutra";
char * GREEN_ZONE = "Zona Verde";
char * RED_ZONE = "Zona Vermelha";
char * DISARMED = "BOMBA DESARMADA";
char * NEUTRALIZING = "NEUTRALIZANDO...";
char * CAPTURING_ZONE = "CAPTURANDO...";
char * RELAY_ON = "Rele Ativo";
char * RELAY_OFF = "Rele Desligado";
char * READY_TO_BEGIN = "Pronto?";
char * PUSH_ANY_BUTTON = "Pressione D";
char * STARTING_GAME = "Iniciando Jogo";
char * IN = " em ";
char * ENTER_PASSWORD = "Insira o Codigo";
char * ENTER_PASSWORD_AGAIN = "Confirmar Codigo";
char * PASSWORD_SET = "Codigo OK";
char * PASSWORD_DONT_MATCH = "Codigo Diferente";
char * SECONDS = " segundos";
char * CODE = "Codigo: ";
char * CT_WIN = "CT GANHOU";
char * TR_WIN = "TR GANHOU";
char * BOMB_DISARMED = "DESARMADA";

int BOMB_PLANTED_SOUND = 1;
int BOMB_DEFUSED_SOUND = 2;

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

byte rowPins[ROWS] = {
  12,
  13,
  A5,
  A4
}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {
  A3,
  A2,
  A1,
  A0
}; //connect to the column pinouts of the keypad

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

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

//Buttons for lcd shield
char BT_RIGHT = '4';
char BT_UP = 'a';
char BT_DOWN = 'b';
char BT_LEFT = '6';
char BT_SEL = 'd'; // Ok key
char BT_CANCEL = 'c';
char BT_DEFUSER = 'x'; // not implemented

//leds

const int REDLED = 11;
const int GREENLED = 10;
//const int BLUELED = 12;
//RELAYPIN
boolean relayEnable = false;
const int RELAYPIN = 9;
//IS VERY IMPORTANT THAT YOU TEST THIS TIME. BY DEFAULT IS IN 1 SEC. THAT IS NOT TOO MUCH. SO TEST IT!
const int RELAY_TIME = 5000;

//TIME INTS
int GAMEHOURS = 0;
int GAMEMINUTES = 45;
int BOMBMINUTES = 4;
int ACTIVATESECONDS = 5;

boolean endGame = false;

boolean sdStatus = false; //search and destroy game enable used in config
boolean saStatus = false; //same but SAbotaghe
boolean doStatus = false; //for DEmolition
boolean start = true;
boolean defusing;
boolean arming;
boolean cancelando;
// SOUND TONES
boolean soundEnable = true;
int tonepin = 8; // Pin 13 for the sound
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; //initial time for zone


const unsigned long lcdOffDelay = 3000; // 3 segundos
unsigned long keyReleasedTime = 0;
unsigned long keyPressedTime = 0;

byte team = 0; // 0 = neutral, 1 = green team, 2 = red team

void setup() {
  lcd.init();
  lcd.backlight();

  Serial.begin(9600);
  softwareSerial.begin(9600);

  if (player.begin(softwareSerial)) {
   Serial.println("MP3 ok");
    // Set volume to maximum (0 to 30).
    player.volume(30); //30 is very loud
  } else {
    Serial.println("Connecting to DFPlayer Mini failed!");
  }

  lcd.home();
  tone(tonepin, 2400, 30);
  lcd.print(WELCOME_TITLE);
  lcd.setCursor(0, 1);
  lcd.print(WELCOME_MESSAGE);

  keypad.setHoldTime(50);
  keypad.setDebounceTime(50);
  keypad.addEventListener(keypadEvent);

  //PinModes
  pinMode(GREENLED, OUTPUT);
  pinMode(REDLED, OUTPUT);
  pinMode(RELAYPIN, OUTPUT);

  digitalWrite(RELAYPIN, HIGH);

  // CONFIGURE THE BARS OF PROGRESS BAR
  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() { 
  // delay before show menu to allow init message
  delay(2000);
  menuPrincipal();
}

void keypadEvent(KeypadEvent key) {
  switch (keypad.getState()) {
    case RELEASED:
      switch (key) {
        case 'd':
          arming = false;
          break;
        case 'c':
          arming = false;
          defusing = false;
          cancelando = false;
          break;
      }
      keyReleasedTime = millis();
      break;
    case HOLD:
      switch (key) {
        case 'd':
          arming = true;
          break;
        case 'c':
          arming = false;
          defusing = true;
          cancelando = true;
          break;
        case '*':
          menuPrincipal();
          break;
      }
      keyPressedTime = millis();
      lcd.backlight();
      break;
  }
}

//##################MENUS###############################

void menuPrincipal() { //MAIN MENU
  digitalWrite(GREENLED, LOW);
  digitalWrite(REDLED, LOW);

  //   if whe start a new game from another we need to restart propertly this variables
  saStatus = false;
  sdStatus = false;
  doStatus = false;
  //Draw menu
  cls(); //clear lcd and set cursor to 0,0
  int i = 0;
  // HERE YOU CAN ADD MORE ITEMS ON THE MAIN MENU
  lcd.print(menu1[i]);
  lcd.setCursor(15, 1);
  checkArrows(i, 3);
 
  while (1) {
    var = keypad.waitForKey();
    if (var == BT_UP && i > 0) {
      tone(tonepin, 2400, 30);
      i--;
      cls();
      lcd.print(menu1[i]);
      checkArrows(i, 3);
      delay(50);
    }

    if (var == BT_DOWN && i < 3) {
      tone(tonepin, 2400, 30);
      i++;
      cls();
      lcd.print(menu1[i]);
      checkArrows(i, 3);
      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() {
  //Draw menu
  lcd.clear();
  lcd.home();
  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,1);
      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();
          cls();
          lcd.print(RELAY_ON);
          digitalWrite(RELAYPIN, LOW); // turn the LED on (HIGH is the voltage level)
          delay(4000); // wait for 4 second
          cls();
          lcd.print(RELAY_OFF);
          digitalWrite(RELAYPIN, HIGH);
          delay(2000);
          lcd.print("TOCANDO");
          cls();
          playSound(3);
          delay(4000);
          player.stop();
          delay(3000);
          config();
          break;
          break;

        case 1:
          //soundConfigMenu();
          cls();
          lcd.print("TOCANDO");
          cls();
          playSound(3);
          delay(4000);
          player.stop();
          cls();
          lcd.print("PAROU");
          cls();
          config();
          break;

        case 2:
          cls();
          lcd.print(RELAY_ON);
          digitalWrite(RELAYPIN, LOW); // turn the LED on (HIGH is the voltage level)
          delay(4000); // wait for 4 second
          cls();
          lcd.print(RELAY_OFF);
          digitalWrite(RELAYPIN, HIGH);
          delay(2000);
          lcd.print("TOCANDO");
          delay(3000);
          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;
          Serial.print(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') // Accept
      {
        tone(tonepin, 2400, 30);
        GAMEMINUTES = ((time[0] * 600) + (time[1] * 60) + (time[2] * 10) + (time[3]));
        break;
      }
      if (var == 'c') // Cancel or Back Button :')
      {
        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') // Cancel or Back Button :')
      {
        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?");

    //zona donde pasamos los items a
    //redibujar
    while (1) {
      var = keypad.waitForKey();
      if (var == 'd') // Accept
      {
        tone(tonepin, 2400, 30);
        ACTIVATESECONDS = ((time[0] * 10) + (time[1]));
        break;
      }
      if (var == 'c') // Cancel or Back Button :')
      {
        tone(tonepin, 2400, 30);
        goto menu3;
      }
    }
    tone(tonepin, 2400, 30);
    cls();
  }
  //sound??
  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;
      }
    }
  }
  //Activate RELAY at Terrorist game ends??? 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;
      }
    }
  }
  //You Want a password enable-disable game?
  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 the game :D
}

//This fuction compare codeInput[8] and password[8] variables
boolean comparePassword() {

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

//Set the password variable
void setCode() {
  lcd.setCursor(0, 1);
  for (int i = 0; i < PASSWORD_SIZE; 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 < PASSWORD_SIZE; 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.home();
          lcd.setCursor(i - 1, 1);
          lcd.print("*");
          lcd.print(var);
        } else {
          lcd.setCursor(0, 1);
          lcd.print(var);
        }
        tone(tonepin, 2400, 30);
        break;
      }
    }
  }
}

void setPass() {
  lcd.setCursor(0, 1);

  for (int i = 0; i < PASSWORD_SIZE; 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.home();
    lcd.print(ENTER_PASSWORD);
    setPass();

    lcd.clear();
    lcd.home();
    lcd.print(ENTER_PASSWORD_AGAIN);

    setCode();

    if (comparePassword()) {
      lcd.clear();
      lcd.home();
      lcd.print(PASSWORD_SET);
      delay(2000);
      break;
    } else {
      lcd.clear();
      lcd.home();
      lcd.print(PASSWORD_DONT_MATCH);
      if (soundEnable) tone(tonepin, errorTone, 200);
      delay(2000);

    }
  }
}

//Whait until a button is pressed is is a number return the number 'char' if not return 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;
  }
}

//void getConfig(){
//
////Check first time
//
//if (EEPROM.read(0)!= 1){
////write default config values
//
//
//
//}
//
////RELAY_TIME = EEPROM.read(1) * 1000 ;
//
//
//}

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;
  }

}
void cls() {
  lcd.clear();
  lcd.home();
}

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.home();
  lcd.print(READY_TO_BEGIN);
  lcd.setCursor(0, 1);
  lcd.print(PUSH_ANY_BUTTON);
  keypad.waitForKey(); //if you press a button game start

  cls();
  lcd.setCursor(1, 0);
  lcd.print(STARTING_GAME);
  for (int i = 5; i > 0; i--) { // START COUNT GAME INIT
    lcd.setCursor(0, 1);
    tone(tonepin, 2000, 100);
    lcd.print(IN);
    lcd.print(i);
    lcd.print(SECONDS);
    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 explodeSplash() {
  digitalWrite(REDLED, LOW);
  digitalWrite(GREENLED, LOW);
  cls();
  delay(100);
  endGame = false;
  lcd.setCursor(1, 0);
  lcd.print(TR_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(PLAY_AGAIN);
  lcd.setCursor(0, 1);
  lcd.print(YES_OR_NOT);
  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("  TIME OUT");
  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(PLAY_AGAIN);
  lcd.setCursor(0, 1);
  lcd.print(YES_OR_NOT);
  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(DISARMED);
    lcd.setCursor(3, 1);
    lcd.print(CT_WIN);
    digitalWrite(GREENLED, HIGH);

    if (soundEnable) {
      playSound(BOMB_DEFUSED_SOUND);
    }

    delay(5000);
    digitalWrite(GREENLED, LOW);
  }
  //end code
  lcd.clear();
  lcd.print(PLAY_AGAIN);
  lcd.setCursor(0, 1);
  lcd.print(YES_OR_NOT);
  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 search() {
  refresh = true;
  cls();
  digitalWrite(REDLED, LOW);
  digitalWrite(GREENLED, LOW);
  //SETUP INITIAL TIME
  int minutos = GAMEMINUTES - 1;
  unsigned long iTime = millis(); //  initialTime in millisec
  unsigned long aTime;
  //var='o';

  //Starting Game Code
  while (1) { // this is the important code, is a little messy but works good.

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

    //Code for led blinking
    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);

    printTime(minutos, aTime);

    //###########################CHECKINGS##################

    //Check If Game End
    if (minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) failSplash();
    //Serial.println(keypad.getKey());
    //USED IN PASSWORD GAME
    if ('d' == keypad.getKey() && passwordEnable) {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(ARMING_BOMB);
      delay(1000); //a little delay to think in the password
      lcd.clear();
      lcd.home();
      lcd.print(CODE);

      setCodeTime(); // we need to set the comparation variable first it writes on codeInput[]

      //then compare :D

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

    //Check If Is Activating
    while (arming && !passwordEnable) {
      digitalWrite(GREENLED, LOW);
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(ARMING_BOMB);
      lcd.setCursor(0, 1);
      unsigned int percent = 0;
      unsigned long xTime = millis(); //start disabling time

      while (arming || defusing) {
        keypad.getKey();
        percent = (millis() - xTime) / (ACTIVATESECONDS * 10);

        drawBar(percent);
        //check if game time runs out during the disabling
        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);

  if (soundEnable) {
    playSound(BOMB_PLANTED_SOUND);
  }
  
  delay(3000);
  cls();
  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.clear();
    lcd.setCursor(2, 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 ('c' == keypad.getKey() && passwordEnable) {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(DISARMING_BOMB);
      delay(1000); //a little delay to think in the password

      lcd.clear();
      lcd.home();
      lcd.print(CODE);

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

      //then compare :D

      if (comparePassword()) {
        disarmedSplash();
      }

      lcd.clear();
      lcd.setCursor(1, 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(0, 0);
      lcd.print(DISARMING_BOMB);
      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();
    }
  }
}

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;

  //Starting Game Code
  while (1) { // this is the important code, is a little messy but works good.

    if (endGame) {
      failSplash();
    }
    //Code for led blinking
    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);
    //###########################CHECKINGS##################

    //Check If Game End
    if (minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) {
      failSplash();
    }

    //USED IN PASSWORD GAME
    if ('d' == keypad.getKey() && passwordEnable) {
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(ARMING_BOMB);
      delay(1000); //a little delay to think in the password
      lcd.clear();
      lcd.home();
      lcd.print(CODE);

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

      //then compare :D

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

    //Check If Is Activating
    while (arming && !passwordEnable) {
      keypad.getKey();
      cls();
      digitalWrite(GREENLED, LOW);
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print(ARMING_BOMB);
      lcd.setCursor(0, 1);
      unsigned int percent = 0;
      unsigned long xTime = millis(); //start disabling time
      while (arming) {
        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 <= 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(3, 0);
  lcd.print(BOMB_ARMED);
  cls();
  delay(1000);
  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

    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.clear();
    lcd.setCursor(2, 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
    {
      failSplash();
    }
    //print time
    printTime(minutos, aTime);

    //// SECOND OPTION: YOU PRESS DISARMING BUTTON

    //IF IS A PASSWORD GAME
    if ('c' == keypad.getKey() && passwordEnable) {

      cls();
      digitalWrite(REDLED, LOW);
      digitalWrite(GREENLED, HIGH);
      lcd.setCursor(0, 0);
      lcd.print(DISARMING_BOMB);
      delay(1000); //a little delay to think in the password

      lcd.clear();
      lcd.home();
      lcd.print(CODE);

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

      //then compare :D

      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) // disarming bomb
    {
      lcd.clear();
      digitalWrite(REDLED, LOW);
      lcd.setCursor(0, 0);
      lcd.print(DISARMING_BOMB);
      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 RETURN TO SABOTAGE
        if (percent >= 100) {
          cls();
          lcd.print(BOMB_DISARMED);
          delay(1000);
          sabotage();
        }
      }
      digitalWrite(REDLED, LOW);
      digitalWrite(GREENLED, LOW);
      cls();
    }
  }
}

void domination() {

  //SETUP INITIAL TIME
  int minutos = GAMEMINUTES - 1;
  boolean showGameTime = true;
  unsigned long a;
  unsigned long iTime = millis(); //  initialTime in millisec
  unsigned long aTime;

  team = 0;
  iZoneTime = 0;
  aTime = 0;
  redTime = 0;
  greenTime = 0;

  int largoTono = 50;
  // 0 = neutral, 1 = green team, 2 = red team
  a = millis();
  //Starting Game Code
  while (1) // this is the important code, is a little messy but works good.
  {
    if (endGame) {
      gameOver();
    }

    keypad.getKey();
    aTime = millis() - iTime;
    //Code for led blinking
    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);
    }
    // Sound!!! same as Destroy
    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);
    //Help to count 3 secs
    if (a + 2000 < millis()) {
      a = millis();
      showGameTime = !showGameTime;
      cls();
    }

    if (showGameTime) { //THE SECOND IS /2
      lcd.setCursor(1, 0);
      lcd.print(GAME_TIME);
      lcd.setCursor(3, 1);
      printTime(minutos, aTime);
    } else if (!showGameTime) {


      if (team == 0) {
        lcd.setCursor(2, 0);
        lcd.print(NEUTRAL_ZONE);
      }

      if (team == 1) {
        lcd.setCursor(3, 0);
        lcd.print(GREEN_ZONE);
      }

      if (team == 2) {
        lcd.setCursor(1, 0);
        lcd.print(RED_ZONE);
      }

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

    //###########################CHECKINGS##################

    //Check If Game End
    if (minutos - aTime / 60000 == 0 && 59 - ((aTime / 1000) % 60) == 0) {
      gameOver();
    }

    //Check If IS neutral
    while ((arming || defusing || cancelando) && team > 0) {
      cls();
      if (team > 0) lcd.print(NEUTRALIZING);
      lcd.setCursor(0, 1);
      unsigned int percent = 0;
      unsigned long xTime = millis(); //start disabling time
      while (arming || defusing || cancelando) {
        //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;
        }

        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) {
            greenTime += millis() - iZoneTime;
            iZoneTime = 0;

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

    //Capturing red
    while (arming && team == 0) {
      cls();
      if (team == 0) lcd.print(CAPTURING_ZONE);
      lcd.setCursor(0, 1);
      unsigned int percent = 0;
      unsigned long xTime = millis(); //start disabling time
      while (arming) {
        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(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) {
          digitalWrite(GREENLED, LOW);
          team = 2;
          iZoneTime = millis();
          delay(1000);
          break;
        }
      }
      cls();
      digitalWrite(REDLED, LOW);
    }

    //getting to green zone
    while (defusing || cancelando && team == 0) {
      cls();
      if (team == 0) lcd.print(CAPTURING_ZONE);
      lcd.setCursor(0, 1);
      unsigned int percent = 0;
      unsigned long xTime = millis(); //start disabling time
      while (defusing || cancelando) {
        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);

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

void gameOver() {

  if (team == 1) greenTime += millis() - iZoneTime;
  if (team == 2) redTime += millis() - iZoneTime;
  digitalWrite(GREENLED, LOW);
  digitalWrite(REDLED, LOW);
  while (!arming || !defusing) {
    keypad.getKey();
    if (arming || defusing) {
      keypad.getKey();
      break;
    }
    lcd.clear();
    lcd.setCursor(3, 0);
    lcd.print(TIME_OVER);
    lcd.setCursor(0, 1);

    //check who team win the base
    if (greenTime > redTime) {
      //greenteam wins
      lcd.print(GREEN_TEAM_WINS);
      digitalWrite(GREENLED, HIGH);
    } else {
      //redteam wins
      lcd.print(RED_TEAM_WINS);
      digitalWrite(REDLED, HIGH);
    }
    delay(3000);
    keypad.getKey();
    if (arming || defusing) {
      keypad.getKey();
      break;
    }
    cls();
    lcd.print(RED_TIME);
    lcd.setCursor(5, 1);
    printTimeDom(redTime, false);
    delay(3000);
    keypad.getKey();
    if (arming || defusing) {

      break;
    }
    cls();
    lcd.print(GREEN_TIME);
    lcd.setCursor(5, 1);
    printTimeDom(greenTime, false);
    delay(3000);
    keypad.getKey();
    if (arming || defusing) {
      keypad.getKey();
      break;
    }
  }
  cls();
  delay(100);
  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);
      cls();
      domination();
      break;
    }
    if (var == 'b') {
      tone(tonepin, 2400, 30);
      menuPrincipal();
      break;
    }
  }
}

void playSound(uint8_t sound) {
  player.playFolder(sound, 1);

}