#include "const.h"
#include "struct.h"
#include "gamedirector.h"
#include <iostream>

const Uint8 *keystates;

//Calcula el cuadrado de la distancia entre dos puntos
double distanceSquared(int x1, int y1, int x2, int y2)
{
	int deltaX = x2 - x1;
	int deltaY = y2 - y1;
	return deltaX * deltaX + deltaY * deltaY;
}

//Detector de colisiones entre dos circulos
bool checkCollision(Circle &a, Circle &b)
{
	//Calcula el radio total al cuadrado
	int totalRadiusSquared = a.r + b.r;
	totalRadiusSquared = totalRadiusSquared * totalRadiusSquared;

	//Si la distancia entre el centro de los circulos es inferior a la suma de sus radios
	if (distanceSquared(a.x, a.y, b.x, b.y) < (totalRadiusSquared))
	{
		//Los circulos han colisionado
		return true;
	}

	//En caso contrario
	return false;
}

//Constructor
GameDirector::GameDirector()
{
	init(false);
}

//Iniciador
void GameDirector::init(bool reset)
{
	//Variables
	mOldTicks = 0;
	mMaxBalloons = 50;
	mMaxBullets = 50;
	mGameSpeed = 15;
	mMenaceLevel = 0;
	mMenaceLevelThreshold = 10;
	mScore = 0;
	mHiScoreAchieved = false;
	mScoreText = std::to_string(mScore);
	mHiScoreText = std::to_string(mHiScore);
	mPlayFieldDrawOnly = true;

	//Objeto jugador
	player.init(PLAY_AREA_CENTER_X - 12, PLAY_AREA_BOTTOM - 24, &gPlayerTexture, gRenderer);

	//Establece a cero todos los valores del vector de objetos globo
	resetBalloons();

	//Crea objetos globo y los centra en el area de juego
	balloon[0].init(0, BLOCK, BALLOON_4, BALLON_VELX_POSITIVE, 0, &gBalloonTexture, gRenderer);
	balloon[0].allignTo(PLAY_AREA_CENTER_X);

	//Con los globos creados, calcula el nivel de amenaza
	calculateMenaceLevel();

	//Establece a cero todos los valores del vector de objetos bala
	resetBullets();

	//Inicializa la notificación de GetReady!
	mGetReady.init(-113, PLAY_AREA_CENTER_Y - 10, 109, 20, 2, 0, true, 0, &gMiscTexture, gRenderer);

	if (reset == false)
	{
		//Variables
		mGameStatus = GAME_STATE_TITLE;

		//Carga la máxima puntuación a partir del fichero de datos
		if (gDataFile[0] == 0)
		{
			mHiScore = 10000;
		}
		//Comprueba el checksum para ver si se ha modificado el fichero
		else if (gDataFile[0] % 43 == gDataFile[1])
		{
			mHiScore = gDataFile[0];
		}
		else
		{
			mHiScore = 10000;
		}

		//Los fondos
		gameBackground.init(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT - (0 * BLOCK), &gGameBackgroundTexture, gRenderer);
		titleBackground.init(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, &gTitleBackgroundTexture, gRenderer);

		//Objetos texto, uno de cada color
		whiteText.init(&gWhiteFontTexture, gRenderer, TEXT_FIXED, 8);
		newText.init(&gNewFontTexture, gRenderer, TEXT_VARIABLE, 10);

		//Inicializa el objeto con el menu del titulo
		menuTitle.init(0, 16 * BLOCK, MENU_BACKGROUND_TRANSPARENT, &gMenuTexture, gRenderer, &whiteText);
		menuTitle.addItem("START");
		menuTitle.addItem("EXIT");
		menuTitle.setBackgroundColor(0, 0, 0, 255);
		menuTitle.centerMenuOnScreen();

		//Inicializa el objeto con el menu de pausa
		menuPause.init(0, 12 * BLOCK, MENU_BACKGROUND_SOLID, &gMenuTexture, gRenderer, &whiteText);
		menuPause.addItem("CONTINUE");
		menuPause.addItem("EXIT TO TITLE");
		menuPause.setBackgroundColor(0x73, 0x27, 0x5c, 255);
		menuPause.centerMenuOnScreen();
	}
}


//Arranca SDL y crea la ventana
bool GameDirector::initSDL()
{
	//Indicador de inicialización
	bool success = true;

	//Inicializa SDL
	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK | SDL_INIT_AUDIO) < 0)
	{
		printf("SDL could not initialize! SDL Error: %s\n", SDL_GetError());
		success = false;
	}
	else
	{
		//Establece el filtro de la textura a nearest
		if (!SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "0"))
		{
			printf("Warning: Nearest texture filtering not enabled!");
		}

		//Inicializa SDL_mixer
		if (Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 2048) < 0)
		{
			printf("SDL_mixer could not initialize! SDL_mixer Error: %s\n", Mix_GetError());
			success = false;
		}

		//Comprueba los mandos
		if (SDL_NumJoysticks() < 1)
		{
			printf("Warning: No joysticks connected!\n");
		}
		else
		{
			//Carga el mando
			gGameController = SDL_JoystickOpen(0);
			if (gGameController == NULL)
			{
				printf("Warning: Unable to open game controller! SDL Error: %s\n", SDL_GetError());
			}
			printf("%i joysticks were found.\n", SDL_NumJoysticks());
			std::cout << SDL_JoystickNumButtons(gGameController) << " buttons\n";
		}

		//Crea la ventana
		gWindow = SDL_CreateWindow("Super Popping (Like Loc) in Jailers World", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, VIEW_WIDTH, VIEW_HEIGHT, SDL_WINDOW_SHOWN);
		if (gWindow == NULL)
		{
			printf("Window could not be created! SDL Error: %s\n", SDL_GetError());
			success = false;
		}
		else
		{
			//Crea un renderizador para la ventana con vsync
			gRenderer = SDL_CreateRenderer(gWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
			if (gRenderer == NULL)
			{
				printf("Renderer could not be created! SDL Error: %s\n", SDL_GetError());
				success = false;
			}
			else
			{
				//Inicializa el color de renderizado
				SDL_SetRenderDrawColor(gRenderer, 0x00, 0x00, 0x00, 0xFF);

				//Establece el tamaño del buffer de renderizado
				SDL_RenderSetLogicalSize(gRenderer, SCREEN_WIDTH, SCREEN_HEIGHT);

				//Inicializa el cargador de PNG
				int imgFlags = IMG_INIT_PNG;
				if (!(IMG_Init(imgFlags) & imgFlags))
				{
					printf("SDL_image could not initialize! SDL_image Error: %s\n", IMG_GetError());
					success = false;
				}
			}
		}
	}

	return success;
}

//Carga todos los recursos
bool GameDirector::loadMedia()
{
	//Indicador de éxito en la carga
	bool success = true;

	//Abrimos el fichero para leer en binario
	SDL_RWops* file = SDL_RWFromFile("data.bin", "r+b");

	//El fichero no existe
	if (file == NULL)
	{
		printf("Warning: Unable to open data.bin file! SDL Error: %s\n", SDL_GetError());

		//Creamos el fichero para escritura
		file = SDL_RWFromFile("data.bin", "w+b");
		if (file != NULL)
		{
			printf("New file created!\n");

			//Inicializamos los datos
			for (int i = 0; i < TOTAL_DATA; ++i)
			{
				gDataFile[i] = 0;
				SDL_RWwrite(file, &gDataFile[i], sizeof(Uint32), 1);
			}

			//Cerramos el fichero
			SDL_RWclose(file);
		}
		else
		{
			printf("Error: Unable to create file! SDL Error: %s\n", SDL_GetError());
			success = false;
		}
	}
	//El fichero existe
	else
	{
		//Cargamos los datos
		printf("Reading file...!\n");
		for (int i = 0; i < TOTAL_DATA; ++i)
		{
			SDL_RWread(file, &gDataFile[i], sizeof(Uint32), 1);
		}

		//Cierra el fichero
		SDL_RWclose(file);
	}

	//Carga los gráficos del jugador
	if (!gPlayerTexture.loadFromFile("media/gfx/player.png", gRenderer))
	{
		printf("Failed to load player texture!\n");
		success = false;
	}

	//Carga los gráficos de los globos
	if (!gBalloonTexture.loadFromFile("media/gfx/balloon.png", gRenderer))
	{
		printf("Failed to load balloon texture!\n");
		success = false;
	}

	//Carga los gráficos de las balas
	if (!gBulletTexture.loadFromFile("media/gfx/bullet.png", gRenderer))
	{
		printf("Failed to load bullet texture!\n");
		success = false;
	}

	//Carga los gráficos del fondo del juego
	if (!gGameBackgroundTexture.loadFromFile("media/gfx/background.png", gRenderer))
	{
		printf("Failed to load game background texture!\n");
		success = false;
	}

	//Carga los gráficos del fondo de la pantalla de titulo
	if (!gTitleBackgroundTexture.loadFromFile("media/gfx/title.png", gRenderer))
	{
		printf("Failed to load title texture!\n");
		success = false;
	}

	//Carga varios gráficos para varios propósitos
	if (!gMiscTexture.loadFromFile("media/gfx/misc.png", gRenderer))
	{
		printf("Failed to load misc texture!\n");
		success = false;
	}

	//Carga los gráficos para el menu
	if (!gMenuTexture.loadFromFile("media/gfx/menu.png", gRenderer))
	{
		printf("Failed to load menu texture!\n");
		success = false;
	}

	//Carga los gráficos para el texto blanco
	if (!gWhiteFontTexture.loadFromFile("media/gfx/white_font.png", gRenderer))
	{
		printf("Failed to load white font texture!\n");
		success = false;
	}

	//Carga los gráficos para el texto negro
	if (!gNewFontTexture.loadFromFile("media/gfx/new_font.png", gRenderer))
	{
		printf("Failed to load black font texture!\n");
		success = false;
	}

	//Carga la música del titulo
	gTitleMusic = Mix_LoadMUS("media/music/title.ogg");
	if (gTitleMusic == NULL)
	{
		printf("Failed to load title music! SDL_mixer Error: %s\n", Mix_GetError());
		success = false;
	}

	//Carga la música del juego
	gPlayingMusic = Mix_LoadMUS("media/music/playing.ogg");
	if (gPlayingMusic == NULL)
	{
		printf("Failed to load playing music! SDL_mixer Error: %s\n", Mix_GetError());
		success = false;
	}

	//Carga los efectos de sonido para la explosión de los globos
	gPopBalloonFX = Mix_LoadWAV("media/sound/balloon.wav");
	if (gPopBalloonFX == NULL)
	{
		printf("Failed to load balloon sound effect! SDL_mixer Error: %s\n", Mix_GetError());
		success = false;
	}

	//Carga los efectos de sonido para los disparos del jugador
	gBulletFX = Mix_LoadWAV("media/sound/bullet.wav");
	if (gBulletFX == NULL)
	{
		printf("Failed to load bullet sound effect! SDL_mixer Error: %s\n", Mix_GetError());
		success = false;
	}

	//Carga los efectos de sonido para el menu
	gMenuSelectedFX = Mix_LoadWAV("media/sound/menu_selected.wav");
	if (gMenuSelectedFX == NULL)
	{
		printf("Failed to load menu selected sound effect! SDL_mixer Error: %s\n", Mix_GetError());
		success = false;
	}

	//Carga los efectos de sonido para los disparos del jugador
	gPlayerCollisionFX = Mix_LoadWAV("media/sound/player_collision.wav");
	if (gPlayerCollisionFX == NULL)
	{
		printf("Failed to load player collision sound effect! SDL_mixer Error: %s\n", Mix_GetError());
		success = false;
	}

	//Carga los efectos de sonido para la puntuación máxima
	gHiScoreFX = Mix_LoadWAV("media/sound/hiscore.wav");
	if (gHiScoreFX == NULL)
	{
		printf("Failed to load hiscore sound effect! SDL_mixer Error: %s\n", Mix_GetError());
		success = false;
	}

	return success;
}

//Libera todos los recursos y cierra SDL
void GameDirector::close()
{
	//Abre el fichero para escribir
	SDL_RWops* file = SDL_RWFromFile("data.bin", "w+b");
	if (file != NULL)
	{
		//Guardamos los datos
		for (int i = 0; i < TOTAL_DATA; ++i)
		{
			SDL_RWwrite(file, &gDataFile[i], sizeof(Uint32), 1);
		}

		//Cerramos el fichero
		SDL_RWclose(file);
	}
	else
	{
		printf("Error: Unable to save file! %s\n", SDL_GetError());
	}

	//Libera todas las imagenes
	gPlayerTexture.free();
	gGameBackgroundTexture.free();
	gTitleBackgroundTexture.free();
	gWhiteFontTexture.free();
	gNewFontTexture.free();
	gMenuTexture.free();
	gBalloonTexture.free();
	gMiscTexture.free();

	//Libera los efectos de sonido
	Mix_FreeChunk(gPopBalloonFX);
	gPopBalloonFX = NULL;
	Mix_FreeChunk(gBulletFX);
	gBulletFX = NULL;
	Mix_FreeChunk(gMenuSelectedFX);
	gMenuSelectedFX = NULL;
	Mix_FreeChunk(gPlayerCollisionFX);
	gPlayerCollisionFX = NULL;
	Mix_FreeChunk(gHiScoreFX);
	gHiScoreFX = NULL;

	//Libra la música
	Mix_FreeMusic(gTitleMusic);
	gTitleMusic = NULL;
	Mix_FreeMusic(gPlayingMusic);
	gPlayingMusic = NULL;

	//Libera el mando
	SDL_JoystickClose(gGameController);
	gGameController = NULL;

	//Destruye la ventana
	SDL_DestroyRenderer(gRenderer);
	SDL_DestroyWindow(gWindow);
	gWindow = NULL;
	gRenderer = NULL;

	//Sal del subsistema SDL
	Mix_Quit();
	IMG_Quit();
	SDL_Quit();
}


//Establece el valor de la variable
void GameDirector::setScore(Uint32 score)
{
	mScore = score;
}

//Establece el valor de la variable
void GameDirector::setHiScore(Uint32 score)
{
	mHiScore = score;
}

//Actualiza el valor de HiScore en caso necesario
void GameDirector::updateHiScore()
{
	//La puntuación es mayor que la máxima puntuación
	if (mScore > mHiScore)
	{
		//Actualiza la máxima puntuación
		mHiScore = mScore;

		//Almacena la máxima puntuación en el fichero junto con un checksum
		gDataFile[0] = mHiScore;
		gDataFile[1] = mHiScore % 43;

		//Si superamos la máxima puntuación
		if (mHiScoreAchieved == false)
		{
			mHiScoreAchieved = true;
			Mix_PlayChannel(-1, gHiScoreFX, 0);
		}
	}
}

//Transforma un valor numérico en una cadena de 6 cifras
std::string GameDirector::updateScoreText(Uint32 num)
{
		if ((num >= 0) && (num <= 9))
		{
			return ("00000" + std::to_string(num));
		}

		if ((num >= 10) && (num <= 99))
		{
			return ("0000" + std::to_string(num));
		}

		if ((num >= 100) && (num <= 999))
		{
			return ("000" + std::to_string(num));
		}

		if ((num >= 1000) && (num <= 9999))
		{
			return ("00" + std::to_string(num));
		}

		if ((num >= 010000) && (num <= 99999))
		{
			return ("0" + std::to_string(num));
		}

		if ((num >= 100000) && (num <= 999999))
		{
			return (std::to_string(num));
		}
	
		return (std::to_string(num));
	
}

//Pinta el marcador en pantalla usando un objeto texto
void GameDirector::renderScoreBoard(Text &text)
{
	mScoreText = updateScoreText(mScore);
	mHiScoreText = updateScoreText(mHiScore);
	whiteText.write(SCORE_WORD_X, SCORE_WORD_Y, "SCORE", 0);
	whiteText.write(SCORE_NUMBER_X, SCORE_NUMBER_Y, mScoreText, 0);
	whiteText.write(HISCORE_WORD_X, HISCORE_WORD_Y, "HI-SCORE", 0);
	whiteText.write(HISCORE_NUMBER_X, HISCORE_NUMBER_Y, mHiScoreText, 0);
}

//Mueve todos los globos activos
void GameDirector::moveBalloons()
{
	for (Uint8 i = 0; i < mMaxBalloons; i++)
	{
		if (balloon[i].isActive())
		{
			balloon[i].update();
		}
	}
}

//Pinta en pantalla todos los globos activos
void GameDirector::renderBalloons()
{
	for (Uint8 i = 0; i < mMaxBalloons; i++)
	{
		if (balloon[i].isActive())
		{
			balloon[i].render();
		}
	}
}

//Devuelve el primer indice no activo del vector de globos
Uint8 GameDirector::getBallonFreeIndex()
{
	int index = 0;

	for (Uint8 i = 0; i < mMaxBalloons; i++)
	{
		if (balloon[i].isActive() == false)
		{
			index = i;
			break;
		}
	}

	return index;
}

//Crea un globo nuevo en el vector de globos
Uint8 GameDirector::createNewBalloon(float x, int y, Uint8 kind, float velx, Uint16 creationtimer, LTexture *texture)
{
	Uint8 index = getBallonFreeIndex();
	balloon[index].init(x, y, kind, velx, creationtimer, texture, gRenderer);
	return index;
}

//Establece a cero todos los valores del vector de objetos globo
void GameDirector::resetBalloons()
{
	for (Uint8 i = 0; i < mMaxBalloons; i++)
	{
		balloon[i].erase();
	}
}

//Explosiona un globo. Lo destruye y crea otros dos si es el caso
void GameDirector::popBalloon(Uint8 index)
{
	if (balloon[index].isActive())
	{
		Uint8 kind = balloon[index].getKind();
		Uint8 freeIndex = 0;
		switch (kind)
		{
		//Si es del tipo más pequeño, simplemente elimina el globo
		case BALLOON_1:
			balloon[index].pop();
			break;

		//En cualquier otro caso, crea dos globos de un tipo inferior
		default:
			freeIndex = getBallonFreeIndex();
			balloon[freeIndex].init(0, balloon[index].getPosY(), balloon[index].getKind() - 1, BALLON_VELX_NEGATIVE, 0, &gBalloonTexture, gRenderer);
			balloon[freeIndex].allignTo(balloon[index].getPosX() + (balloon[index].getWidth() / 2));
			balloon[freeIndex].setVelY(-2.5);

			freeIndex = getBallonFreeIndex();
			balloon[freeIndex].init(0, balloon[index].getPosY(), balloon[index].getKind() - 1, BALLON_VELX_POSITIVE, 0, &gBalloonTexture, gRenderer);
			balloon[freeIndex].allignTo(balloon[index].getPosX() + (balloon[index].getWidth() / 2));
			balloon[freeIndex].setVelY(-2.5);

			//Elimina el globo
			balloon[index].pop();
			break;
		}
	}
}

//Detiene todos los globos
void GameDirector::stopAllBalloons(Uint16 time)
{
	for (Uint8 i = 0; i < mMaxBalloons; i++)
	{
		if (balloon[i].isActive())
		{
			balloon[i].setStop(true);
			balloon[i].setStoppedTimer(time);
		}
	}
}

//Pone en marcha todos los globos
void GameDirector::startAllBalloons()
{
	for (Uint8 i = 0; i < mMaxBalloons; i++)
	{
		if (balloon[i].isActive())
		{
			balloon[i].setStop(false);
			balloon[i].setStoppedTimer(0);
		}
	}
}

//Obtiene el numero de globos activos
Uint8 GameDirector::countBalloons()
{
	Uint8 num = 0;
	for (Uint8 i = 0; i < mMaxBalloons; i++)
	{
		if (balloon[i].isActive())
		{
			++num;
		}
	}
	return num;
}

//Comprueba la colisión entre el jugador y los globos activos
bool GameDirector::checkPlayerBallonCollision()
{
	bool result = false;
	for (Uint8 i = 0; i < mMaxBalloons; i++)
	{
		if ((balloon[i].isActive()) && (balloon[i].isStopped() == false))
		{
			if (checkCollision(player.getCollider(), balloon[i].getCollider()))
			{
				result = true;
				break;
			}
		}
	}
	return result;
}

//Comprueba y procesa la colisión entre las balas y los globos
void GameDirector::processBulletBallonCollision()
{
	for (Uint8 i = 0; i < mMaxBalloons; i++)
	{
		for (Uint8 j = 0; j < mMaxBullets; j++)
		{
			if (balloon[i].isActive() && !(balloon[i].isInvulnerable()) && bullet[j].isActive())
			{
				if (checkCollision(balloon[i].getCollider(), bullet[j].getCollider()))
				{
					player.addScore(balloon[i].getScore());
					setScore(player.getScore());
					updateHiScore();
					popBalloon(i);
					Mix_PlayChannel(-1, gPopBalloonFX, 0);
					bullet[j].erase();
					calculateMenaceLevel();
					break;
				}
			}
		}
	}
}

//Mueve las balas activas
void GameDirector::moveBullets()
{
	for (Uint8 i = 0; i < mMaxBullets; i++)
	{
		if (bullet[i].isActive())
		{
			bullet[i].move();
		}
	}
}

//Pinta las balas activas
void GameDirector::renderBullets()
{
	for (Uint8 i = 0; i < mMaxBullets; i++)
	{
		if (bullet[i].isActive())
		{
			bullet[i].render();
		}
	}
}

//Devuelve el primer indice no activo del vector de balas
Uint8 GameDirector::getBulletFreeIndex()
{
	Uint8 index = 0;

	for (int i = 0; i < mMaxBullets; i++)
	{
		if (bullet[i].isActive() == false)
		{
			index = i;
			break;
		}
	}

	return index;
}

//Establece a cero todos los valores del vector de objetos bala
void GameDirector::resetBullets()
{
	for (Uint8 i = 0; i < mMaxBullets; i++)
	{
		bullet[i].erase();
	}
}

//Crea un objeto bala
void GameDirector::createBullet(int x, int y, Uint8 kind)
{
	bullet[getBulletFreeIndex()].init(x, y, kind, &gBulletTexture, gRenderer);
}

//Acciones a realizar cuando el jugador muere
void GameDirector::killPlayer()
{
	stopAllBalloons(5000);
	Mix_HaltMusic();
	Mix_PlayChannel(-1, gPlayerCollisionFX, 0);
	shackeScreen();
	player.setAlive(false);
	SDL_Delay(1000);
	setGameStatus(GAME_STATE_GAME_OVER_SCREEN);
}

//Calcula y establece el valor de amenaza en funcion de los globos activos
void GameDirector::calculateMenaceLevel()
{
	mMenaceLevel = 0;
	for (Uint8 i = 0; i < mMaxBalloons; i++)
	{
		switch (balloon[i].getKind())
		{
		case BALLOON_1:
			mMenaceLevel += 1;
			break;

		case BALLOON_2:
			mMenaceLevel += 2;
			break;

		case BALLOON_3:
			mMenaceLevel += 4;
			break;

		case BALLOON_4:
			mMenaceLevel += 8;
			break;

		default:
			mMenaceLevel += 0;
			break;
		}
	}
}

//Obtiene el valor de la variable
Uint8 GameDirector::getMenaceLevel()
{
	return mMenaceLevel;
}

//Obtiene el valor de la variable
bool GameDirector::isPlayFieldDrawOnly()
{
	return mPlayFieldDrawOnly;
}

//Establece el valor de la variable
void GameDirector::setPlayFieldDrawOnly(bool state)
{
	mPlayFieldDrawOnly = state;
}

//Gestiona el nivel de amenaza
void GameDirector::checkMenaceLevel()
{
	//Aumenta el nivel de amenaza en función de la puntuación
	mMenaceLevelThreshold = 7 + (4 * (mScore / 10000));

	//Si el nivel de amenza es inferior al umbral
	if (mMenaceLevel < mMenaceLevelThreshold)
	{
		Uint8 index = 0;

		//Obtiene el centro del jugador en el eje X
		int x = player.getPosX() + (player.getWidth() / 2);

		//Crea un globo sobre el jugador en dirección hacia el centro
		if (x < (PLAY_AREA_WIDTH / 2))
		{
			index = createNewBalloon(0, PLAY_AREA_TOP + BLOCK - 37, BALLOON_4, BALLON_VELX_POSITIVE, 400, &gBalloonTexture);
		}
		else
		{
			index = createNewBalloon(0, PLAY_AREA_TOP + BLOCK - 37, BALLOON_4, BALLON_VELX_NEGATIVE, 400, &gBalloonTexture);
		}
		balloon[index].allignTo(x);

		//Recalcula el nivel de amenaza con el nuevo globo
		calculateMenaceLevel();
	}
}

//Gestiona la entrada de teclado y mando durante el juego
void GameDirector::checkGameInput()
{
	//Obtiene el estado de las teclas pulsadas del teclado
	keystates = SDL_GetKeyboardState(NULL);

	//Si está pulsada la tecla izquierda o el mando hacia la izquierda
	if ((keystates[SDL_SCANCODE_LEFT] != 0) || (SDL_JoystickGetAxis(gGameController, 0) < -JOYSTICK_DEAD_ZONE))
	{
		player.checkInput(INPUT_LEFT);
	}
	//Si está pulsada la tecla derecha o el mando hacia la derecha
	else if ((keystates[SDL_SCANCODE_RIGHT] != 0) || (SDL_JoystickGetAxis(gGameController, 0) > JOYSTICK_DEAD_ZONE))
	{
		player.checkInput(INPUT_RIGHT);
	}
	//Ninguna de las dos direcciones pulsadas
	else
	{
		player.checkInput(NO_INPUT);
	}

	//Comprobamos la tecla o el botón de disparo central
	if ((SDL_JoystickGetButton(gGameController, BUTTON_X)) || (keystates[SDL_SCANCODE_W] != 0))
	{
		if (player.canFire())
		{
			createBullet(player.getPosX() + (player.getWidth() / 2) - 4, player.getPosY(), BULLET_UP);
			player.setFireCooldown(10);

			//Reproduce el sonido de disparo
			Mix_PlayChannel(-1, gBulletFX, 0);
		}
	}

	//Comprobamos la tecla o el botón de disparo izquierdo
	if ((SDL_JoystickGetButton(gGameController, BUTTON_Y)) || (keystates[SDL_SCANCODE_Q] != 0))
	{
		if (player.canFire())
		{
			createBullet(player.getPosX() + (player.getWidth() / 2) - 4, player.getPosY(), BULLET_LEFT);
			player.setFireCooldown(10);

			//Reproduce el sonido de disparo
			Mix_PlayChannel(-1, gBulletFX, 0);
		}
	}

	//Comprobamos la tecla o el botón de disparo derecho
	if ((SDL_JoystickGetButton(gGameController, BUTTON_A)) || (keystates[SDL_SCANCODE_E] != 0))
	{
		if (player.canFire())
		{
			createBullet(player.getPosX() + (player.getWidth() / 2) - 4, player.getPosY(), BULLET_RIGHT);
			player.setFireCooldown(10);

			//Reproduce el sonido de disparo
			Mix_PlayChannel(-1, gBulletFX, 0);
		}
	}

	//Comprobamos la tecla o el botón de pausa/menu
	if ((SDL_JoystickGetButton(gGameController, BUTTON_START)) || (keystates[SDL_SCANCODE_ESCAPE] != 0))
	{
		setGameStatus(GAME_STATE_PAUSED);

		//Detiene la música
		Mix_HaltMusic();
	}
}

//Gestiona la entrada de teclado y mando durante el menu
void GameDirector::checkMenuInput(Menu *menu)
{
	//Obtiene el estado de las teclas pulsadas del teclado
	keystates = SDL_GetKeyboardState(NULL);

	//Si está pulsada la tecla izquierda o el mando hacia la izquierda
	if ((keystates[SDL_SCANCODE_UP] != 0) || (SDL_JoystickGetAxis(gGameController, 1) < -JOYSTICK_DEAD_ZONE))
	{
		menu->checkInput(INPUT_UP);
	}
	//Si está pulsada la tecla derecha o el mando hacia la derecha
	else if ((keystates[SDL_SCANCODE_DOWN] != 0) || (SDL_JoystickGetAxis(gGameController, 1) > JOYSTICK_DEAD_ZONE))
	{
		menu->checkInput(INPUT_DOWN);
	}
	//Comprobamos la tecla o el botón de menu/pausa
	else if (keystates[SDL_SCANCODE_RETURN] != 0 || (SDL_JoystickGetButton(gGameController, BUTTON_A)))
	{
		menu->checkInput(INPUT_FIRE);
	}
}

//Obtiene el valor de la variable
Uint8 GameDirector::getGameStatus()
{
	return mGameStatus;
}

//Establece el valor de la variable
void GameDirector::setGameStatus(Uint8 status)
{
	mGameStatus = status;
}

//Pinta una transición en pantalla
void GameDirector::renderTransition(Uint8 index)
{
	switch (index)
	{
	case 0:
		SDL_Rect rect;
		rect.x = 0;
		rect.y = 0;
		rect.w = SCREEN_WIDTH;
		rect.h = 0;

		SDL_RenderPresent(gRenderer);
		SDL_SetRenderDrawColor(gRenderer, 0x27, 0x27, 0x36, 0);

		for (Uint16 i = 0; i < SCREEN_HEIGHT; i = i + 2)
		{
			rect.h = i;
			SDL_RenderFillRect(gRenderer, &rect);
			SDL_RenderPresent(gRenderer);
		}
		break;

	case 1:
		SDL_Rect rect1;
		rect1.x = 0;
		rect1.y = 0;
		rect1.w = SCREEN_WIDTH;
		rect1.h = 0;

		SDL_Rect rect2;
		rect2.x = 0;
		rect2.y = 0;
		rect2.w = SCREEN_WIDTH;
		rect2.h = 0;

		SDL_RenderPresent(gRenderer);
		SDL_SetRenderDrawBlendMode(gRenderer, SDL_BLENDMODE_BLEND);
		SDL_SetRenderDrawColor(gRenderer, 0x27, 0x27, 0x36, 64);

		for (Uint16 i = 0; i < (SCREEN_HEIGHT / 2); i = i + 4)
		{
			rect1.h = i;
			SDL_RenderFillRect(gRenderer, &rect1);

			rect2.h = i;
			rect2.y = SCREEN_HEIGHT - (i);
			SDL_RenderFillRect(gRenderer, &rect2);

			SDL_RenderPresent(gRenderer);
		}

		rect1.x = 0;
		rect1.y = 0;
		rect1.w = SCREEN_WIDTH;
		rect1.h = SCREEN_HEIGHT;
		SDL_SetRenderDrawColor(gRenderer, 0, 0, 0, 64);

		for (Uint16 i = 0; i < 32; i++)
		{
			SDL_RenderFillRect(gRenderer, &rect1);
			SDL_RenderPresent(gRenderer);
		}
		break;

	default:
		break;
	}
}

//Pinta el texto GetReady en pantalla
void GameDirector::renderGetReady()
{
	if (mGetReady.isEnabled())
	{
		mGetReady.move();
		mGetReady.render();
		if (mGetReady.getPosX() > PLAY_AREA_RIGHT)
		{
			mGetReady.init(-113, PLAY_AREA_CENTER_Y - 10, 109, 20, 2, 0, false, 0, &gMiscTexture, gRenderer);
			setPlayFieldDrawOnly(false);
		}
	}
}

//Agita la pantalla
void GameDirector::shackeScreen()
{
	int v[] = {-1, 1, -1, 1, -1, 1, -1, 0};
	for (Uint8 n = 0; n < 8; n++)
	{
		//Limpia la pantalla
		SDL_SetRenderDrawColor(gRenderer, 0x00, 0x00, 0x00, 0xFF);
		SDL_RenderClear(gRenderer);

		//Dibuja los objetos
		gameBackground.setPosX(v[n]);
		gameBackground.render();
		renderBalloons();
		renderBullets();
		player.render();
		renderScoreBoard(whiteText);
		renderGetReady();

		//Actualiza la pantalla
		SDL_RenderPresent(gRenderer);
		SDL_Delay(50);
	}
}

//Bucle para el titulo del juego
void GameDirector::runTitle()
{
	//Si la música no está sonando
	if (Mix_PlayingMusic() == 0)
	{
		//Reproduce la música
		Mix_PlayMusic(gTitleMusic, -1);
	}

	//Comprueba los eventos que hay en la cola
	while (SDL_PollEvent(&eventHandler) != 0)
	{
		//Evento de salida de la aplicación
		if (eventHandler.type == SDL_QUIT)
		{
			setGameStatus(GAME_STATE_QUIT);
		}
	}

	//Limpia la pantalla
	SDL_SetRenderDrawColor(gRenderer, 0x00, 0x00, 0x00, 0xFF);
	SDL_RenderClear(gRenderer);

	//Dibuja los objetos
	titleBackground.render();
	menuTitle.render();

	//Actualiza la pantalla
	SDL_RenderPresent(gRenderer);

	//Comprueba las entradas para el menu
	checkMenuInput(&menuTitle);

	//Comprueba si se ha seleccionado algún item del menú
	switch (menuTitle.getItemSelected())
	{
	case 0:
		setGameStatus(GAME_STATE_PLAYING);
		menuTitle.resetMenu();
		Mix_PlayChannel(-1, gMenuSelectedFX, 0);
		renderTransition(1);
		Mix_HaltMusic();
		//SDL_Delay(1200);
		init(true);
		break;
	case 1:
		setGameStatus(GAME_STATE_QUIT);
		menuTitle.resetMenu();
		renderTransition(1);
		Mix_HaltMusic();
		break;
	default:
		break;
	}
}

//Bucle para el juego
void GameDirector::runGame()
{
	//Si la música no está sonando
	if (Mix_PlayingMusic() == 0)
	{
		//Reproduce la música
		Mix_PlayMusic(gPlayingMusic, -1);
	}

	//Lógica del juego
	//Comprueba que la diferencia de ticks sea mayor a la velocidad del juego
	if (SDL_GetTicks() - mOldTicks > mGameSpeed)
	{
		//Actualiza el contador de ticks
		mOldTicks = SDL_GetTicks();

		//Comprueba los eventos que hay en la cola
		while (SDL_PollEvent(&eventHandler) != 0)
		{
			//Evento de salida de la aplicación
			if (eventHandler.type == SDL_QUIT)
			{
				setGameStatus(GAME_STATE_QUIT);
			}

			//Tecla T pulsada
			if (eventHandler.key.keysym.sym == SDLK_t)
			{

				break;
			}
		}

		if (isPlayFieldDrawOnly() == false)
		{
			//Comprueba el teclado/mando
			checkGameInput();

			//Actualiza el jugador
			player.update();

			//Mueve los globos
			moveBalloons();

			//Mueve las balas
			moveBullets();

			//Procesa las colisiones entre globos y balas
			processBulletBallonCollision();

			//Comprueba el nivel de amenaza
			checkMenaceLevel();

			//Comprueba la colisión entre el jugador y los globos
			if (checkPlayerBallonCollision())
			{
				if (player.isAlive())
				{
					killPlayer();
				}
			}
		}
	}

	//Limpia la pantalla
	SDL_SetRenderDrawColor(gRenderer, 0x00, 0x00, 0x00, 0xFF);
	SDL_RenderClear(gRenderer);

	//Dibuja los objetos
	gameBackground.render();
	renderBalloons();
	renderBullets();
	player.render();
	renderScoreBoard(whiteText);
	renderGetReady();

	//Actualiza la pantalla
	SDL_RenderPresent(gRenderer);
}

//Bucle para el menu de pausa del juego
void GameDirector::runPausedGame()
{
	//Comprueba los eventos que hay en la cola
	while (SDL_PollEvent(&eventHandler) != 0)
	{
		//Evento de salida de la aplicación
		if (eventHandler.type == SDL_QUIT)
		{
			setGameStatus(GAME_STATE_QUIT);
		}
	}

	//Dibuja los objetos
	gameBackground.render();
	renderBalloons();
	renderBullets();
	player.render();
	renderScoreBoard(whiteText);
	menuPause.render();

	//Limpia la pantalla
	SDL_RenderPresent(gRenderer);

	//Comprueba las entradas para el menu
	checkMenuInput(&menuPause);

	//Comprueba si se ha seleccionado algún item del menú
	switch (menuPause.getItemSelected())
	{
	case 0:
		setGameStatus(GAME_STATE_PLAYING);
		menuPause.resetMenu();
		break;
	case 1:
		setGameStatus(GAME_STATE_TITLE);
		menuPause.resetMenu();
		Mix_PlayChannel(-1, gMenuSelectedFX, 0);
		renderTransition(1);
		init(true);
		break;
	default:
		break;
	}
}

//Bucle para la pantalla de game over
void GameDirector::runGameOverScreen()
{
	//Comprueba los eventos que hay en la cola
	while (SDL_PollEvent(&eventHandler) != 0)
	{
		//Evento de salida de la aplicación
		if (eventHandler.type == SDL_QUIT)
		{
			setGameStatus(GAME_STATE_QUIT);
		}
	}

	//Limpia la pantalla
	SDL_SetRenderDrawColor(gRenderer, 0x27, 0x27, 0x36, 0xFF);
	SDL_RenderClear(gRenderer);

	//Dibuja los objetos
	renderScoreBoard(whiteText);
	whiteText.write(PLAY_AREA_CENTER_X - (whiteText.lenght("GAME OVER", 0) / 2), PLAY_AREA_CENTER_Y, "GAME OVER", 0);

	//Muestra la pantalla
	SDL_RenderPresent(gRenderer);

	SDL_Delay(4000);
	SDL_RenderClear(gRenderer);
	SDL_RenderPresent(gRenderer);
	SDL_Delay(1200);
	setGameStatus(GAME_STATE_TITLE);
}
