#include "const.h"
#include "player.h"

//Constructor
Player::Player()
{
	mSprite = new AnimatedSprite();
	init(0, 0, nullptr, nullptr);
}

//Destructor
Player::~Player()
{
	init(0, 0, nullptr, nullptr);
	mSprite = nullptr;
	delete mSprite;
}

//Iniciador
void Player::init(float x, int y, LTexture *texture, SDL_Renderer *renderer)
{
	//Inicializa variables de estado
	mAlive = true;
	mStatus = PLAYER_STATE_STOPPED;
	mInvulnerable = false;
	mInvulnerableTimer = PLAYER_INVULNERABLE_TIMER;
	mExtraHit = false;

	//Establece la altura y el ancho del jugador
	mWidth = 3 * BLOCK;
	mHeight = 3 * BLOCK;

	//Establece la posición inicial del jugador
	mPosX = x;
	mPosY = y;

	//Establece el tamaño del circulo de colisión
	mCollider.r = 7;

	//Actualiza la posición del circulo de colisión
	shiftColliders();

	//Establece la velocidad inicial
	mVelX = 0;
	mVelY = 0;

	//Establece la velocidad base
	mBaseSpeed = 1.5;

	//Establece el numero inicial de vidas
	mStartingLives = 3;
	mLives = mStartingLives;

	//Establece la puntuación inicial
	mScore = 0;

	//Establece el multiplicador de puntos inicial
	mScoreMultiplier = 1.0f;

	//Inicia el contador para la cadencia de disparo
	mCooldown = 10;

	//Inicia el sprite
	mSprite->init(texture, renderer);

	//Establece el alto y ancho del sprite
	mSprite->setWidth(mWidth);
	mSprite->setHeight(mHeight);

	//Establece la posición del sprite
	mSprite->setPosX(int(mPosX));
	mSprite->setPosY(mPosY);

	//Inicializa las variables para la animación
	mSprite->setCurrentFrame(0);
	mSprite->setAnimationCounter(0);

	//Establece el numero de frames de cada animacion
	mSprite->setAnimationNumFrames(PLAYER_STATE_STOPPED, 1);
	mSprite->setAnimationNumFrames(PLAYER_STATE_WALKING_LEFT, 4);
	mSprite->setAnimationNumFrames(PLAYER_STATE_WALKING_RIGHT, 4);
	mSprite->setAnimationNumFrames(PLAYER_STATE_STOPPED_EXTRA_HIT, 1);
	mSprite->setAnimationNumFrames(PLAYER_STATE_WALKING_LEFT_EXTRA_HIT, 4);
	mSprite->setAnimationNumFrames(PLAYER_STATE_WALKING_RIGHT_EXTRA_HIT, 4);

	//Establece la velocidad de cada animación
	mSprite->setAnimationSpeed(PLAYER_STATE_STOPPED, 10);
	mSprite->setAnimationSpeed(PLAYER_STATE_WALKING_LEFT, 5);
	mSprite->setAnimationSpeed(PLAYER_STATE_WALKING_RIGHT, 5);
	mSprite->setAnimationSpeed(PLAYER_STATE_STOPPED_EXTRA_HIT, 10);
	mSprite->setAnimationSpeed(PLAYER_STATE_WALKING_LEFT_EXTRA_HIT, 5);
	mSprite->setAnimationSpeed(PLAYER_STATE_WALKING_RIGHT_EXTRA_HIT, 5);

	//Establece si la animación se reproduce en bucle
	mSprite->setAnimationLoop(PLAYER_STATE_STOPPED, true);
	mSprite->setAnimationLoop(PLAYER_STATE_WALKING_LEFT, true);
	mSprite->setAnimationLoop(PLAYER_STATE_WALKING_RIGHT, true);
	mSprite->setAnimationLoop(PLAYER_STATE_STOPPED_EXTRA_HIT, true);
	mSprite->setAnimationLoop(PLAYER_STATE_WALKING_LEFT_EXTRA_HIT, true);
	mSprite->setAnimationLoop(PLAYER_STATE_WALKING_RIGHT_EXTRA_HIT, true);

	//Establece los frames de cada animación
	mSprite->setAnimationFrames(PLAYER_STATE_WALKING_LEFT, 0, mWidth * 0, mHeight * 0, mWidth, mHeight);
	mSprite->setAnimationFrames(PLAYER_STATE_WALKING_LEFT, 1, mWidth * 1, mHeight * 0, mWidth, mHeight);
	mSprite->setAnimationFrames(PLAYER_STATE_WALKING_LEFT, 2, mWidth * 2, mHeight * 0, mWidth, mHeight);
	mSprite->setAnimationFrames(PLAYER_STATE_WALKING_LEFT, 3, mWidth * 3, mHeight * 0, mWidth, mHeight);

	mSprite->setAnimationFrames(PLAYER_STATE_WALKING_RIGHT, 0, mWidth * 0, mHeight * 1, mWidth, mHeight);
	mSprite->setAnimationFrames(PLAYER_STATE_WALKING_RIGHT, 1, mWidth * 1, mHeight * 1, mWidth, mHeight);
	mSprite->setAnimationFrames(PLAYER_STATE_WALKING_RIGHT, 2, mWidth * 2, mHeight * 1, mWidth, mHeight);
	mSprite->setAnimationFrames(PLAYER_STATE_WALKING_RIGHT, 3, mWidth * 3, mHeight * 1, mWidth, mHeight);

	mSprite->setAnimationFrames(PLAYER_STATE_STOPPED, 0, mWidth * 0, mHeight * 2, mWidth, mHeight);

	mSprite->setAnimationFrames(PLAYER_STATE_WALKING_LEFT_EXTRA_HIT, 0, mWidth * 0, mHeight * 3, mWidth, mHeight);
	mSprite->setAnimationFrames(PLAYER_STATE_WALKING_LEFT_EXTRA_HIT, 1, mWidth * 1, mHeight * 3, mWidth, mHeight);
	mSprite->setAnimationFrames(PLAYER_STATE_WALKING_LEFT_EXTRA_HIT, 2, mWidth * 2, mHeight * 3, mWidth, mHeight);
	mSprite->setAnimationFrames(PLAYER_STATE_WALKING_LEFT_EXTRA_HIT, 3, mWidth * 3, mHeight * 3, mWidth, mHeight);

	mSprite->setAnimationFrames(PLAYER_STATE_WALKING_RIGHT_EXTRA_HIT, 0, mWidth * 0, mHeight * 4, mWidth, mHeight);
	mSprite->setAnimationFrames(PLAYER_STATE_WALKING_RIGHT_EXTRA_HIT, 1, mWidth * 1, mHeight * 4, mWidth, mHeight);
	mSprite->setAnimationFrames(PLAYER_STATE_WALKING_RIGHT_EXTRA_HIT, 2, mWidth * 2, mHeight * 4, mWidth, mHeight);
	mSprite->setAnimationFrames(PLAYER_STATE_WALKING_RIGHT_EXTRA_HIT, 3, mWidth * 3, mHeight * 4, mWidth, mHeight);

	mSprite->setAnimationFrames(PLAYER_STATE_STOPPED_EXTRA_HIT, 0, mWidth * 0, mHeight * 5, mWidth, mHeight);

	//Selecciona un frame para pintar
	mSprite->setSpriteClip(mSprite->getAnimationClip(PLAYER_STATE_STOPPED, 0));
}

//Comprueba el teclado y actua en consecuencia
void Player::checkInput(Uint8 input)
{
	switch (input)
	{
	case INPUT_LEFT:
		mVelX = -mBaseSpeed;
		if (mExtraHit)
		{
			setStatus(PLAYER_STATE_WALKING_LEFT_EXTRA_HIT);
		}
		else
		{
			setStatus(PLAYER_STATE_WALKING_LEFT);
		}
		break;

	case INPUT_RIGHT:
		mVelX = mBaseSpeed;
		if (mExtraHit)
		{
			setStatus(PLAYER_STATE_WALKING_RIGHT_EXTRA_HIT);
		}
		else
		{
			setStatus(PLAYER_STATE_WALKING_RIGHT);
		}
		break;

	default:
		mVelX = 0;
		if (mExtraHit)
		{
			setStatus(PLAYER_STATE_STOPPED_EXTRA_HIT);
		}
		else
		{
			setStatus(PLAYER_STATE_STOPPED);
		}
		break;
	}
}

//Mueve el jugador a la posición y animación que le corresponde
void Player::move()
{
	//Mueve el jugador a derecha o izquierda
	mPosX += mVelX;

	//Si el jugador abandona el area de juego por los laterales
	if ((mPosX < PLAY_AREA_LEFT) || (mPosX + mWidth > PLAY_AREA_RIGHT))
	{
		//Restaura su posición
		mPosX -= mVelX;
	}

	//Actualiza la posición del sprite
	mSprite->setPosX(getPosX());
	mSprite->setPosY(mPosY);
}

//Pinta el jugador en pantalla
void Player::render()
{
	if (mInvulnerable)
	{
		if ((mInvulnerableTimer % 10) > 4)
		{
			mSprite->render();
		}
	}
	else
	{
		mSprite->render();
	}
}

//Establece el estado del jugador
void Player::setStatus(int status)
{
	//Si cambiamos de estado, reiniciamos la animación
	if (mStatus != status)
	{
		mStatus = status;
		mSprite->setCurrentFrame(0);
	}
}

//Establece la animación correspondiente al estado
void Player::setAnimation()
{
	mSprite->animate(mStatus);
}

//Obtiene el valor de la variable
int Player::getPosX()
{
	return int(mPosX);
}

//Obtiene el valor de la variable
int Player::getPosY()
{
	return mPosY;
}

//Obtiene el valor de la variable
int Player::getWidth()
{
	return mWidth;
}

//Obtiene el valor de la variable
int Player::getHeight()
{
	return mHeight;
}

//Indica si el jugador puede disparar
bool Player::canFire()
{
	//Si el contador a llegado a cero, podemos disparar. En caso contrario decrementamos el contador
	if (mCooldown > 0)
	{
		return false;
	}
	else
	{
		return true;
	}
}

//Establece el valor de la variable
void Player::setFireCooldown(int time)
{
	mCooldown = time;
}

//Actualiza el valor de la variable
void Player::updateCooldown()
{
	if (mCooldown > 0)
	{
		--mCooldown;
	}
}

//Actualiza al jugador a su posicion, animación y controla los contadores
void Player::update()
{
	move();
	setAnimation();
	shiftColliders();
	updateCooldown();
	updateInvulnerableTimer();
}

//Obtiene la puntuación del jugador
int Player::getScore()
{
	return mScore;
}

//Asigna un valor a la puntuación del jugador
void Player::setScore(int score)
{
	mScore = score;
}

//Incrementa la puntuación del jugador
void Player::addScore(int score)
{
	mScore += score;
}

//Obtiene el valor de la variable
bool Player::isAlive()
{
	return mAlive;
}

//Establece el valor de la variable
void Player::setAlive(bool value)
{
	mAlive = value;
}

//Obtiene el valor de la variable
float Player::getScoreMultiplier()
{
	return mScoreMultiplier;
}

//Establece el valor de la variable
void Player::setScoreMultiplier(float value)
{
	mScoreMultiplier = value;
}

//Aumenta el valor de la variable hasta un máximo
void Player::incScoreMultiplier()
{
	if (mScoreMultiplier < 5.0f)
	{
		mScoreMultiplier += 0.1f;
	}
}

//Decrementa el valor de la variable hasta un mínimo
void Player::decScoreMultiplier()
{
	if (mScoreMultiplier > 1.0f)
	{
		mScoreMultiplier -= 0.1f;
	}
}

//Obtiene el valor de la variable
bool Player::isInvulnerable()
{
	return mInvulnerable;
}

//Establece el valor de la variable
void Player::setInvulnerable(bool value)
{
	mInvulnerable = value;
}

//Obtiene el valor de la variable
bool Player::getInvulnerableTimer()
{
	return mInvulnerableTimer;
}

//Establece el valor de la variable
void Player::setInvulnerableTimer(Uint16 value)
{
	mInvulnerableTimer = value;
}

//Actualiza el valor de la variable
void Player::updateInvulnerableTimer()
{
	if (mInvulnerableTimer > 0)
	{
		--mInvulnerableTimer;
	}
	else
	{
		mInvulnerable = false;
		mInvulnerableTimer = PLAYER_INVULNERABLE_TIMER;
	}
}

//Obtiene el valor de la variable
bool Player::hasExtraHit()
{
	return mExtraHit;
}

//Concede un toque extra al jugador
void Player::giveExtraHit()
{
	mExtraHit = true;
}

//Quita el toque extra al jugador
void Player::removeExtraHit()
{
	mExtraHit = false;
	mInvulnerable = true;
	mInvulnerableTimer = PLAYER_INVULNERABLE_TIMER;
}

//Obtiene el circulo de colisión
Circle &Player::getCollider()
{
	return mCollider;
}

//Actualiza el circulo de colisión a la posición del jugador
void Player::shiftColliders()
{
	mCollider.x = Uint16(mPosX + (mWidth / 2));
	mCollider.y = mPosY + (mHeight / 2);
}