void Bullet::moveUp( std::vector<SDL_Rect>& otherColliders )
{
	mVelY++;

    //Move the dot left or right
    mPosX += mVelX;
    shiftColliders();

    //If the dot collided or went too far to the left or right
    if( ( mPosX < 0 ) || ( mPosX + DOT_WIDTH > SCREEN_WIDTH ) || checkCollision( mColliders, otherColliders ) )
    {
        if (!bulletsUp.empty())
		{
			bulletsUp.pop_back();
		}
		mVelY = 0;
    }

    //Move the dot up or down
    mPosY -= mVelY;
	shiftColliders();

    //If the dot collided or went too far up or down
    if( ( mPosY < 0 ) || ( mPosY + DOT_HEIGHT > SCREEN_HEIGHT ) || checkCollision( mColliders, otherColliders ) )
    {
        if (!bulletsUp.empty())
		{
			bulletsUp.pop_back();
			mVelY = 0;
		}
    }
}

void LevelPlaySelect::checkMouse(ImageManager &imageManager, SDL_Renderer &renderer){
	int x,y;
	
	//Get the current mouse location.
	SDL_GetMouseState(&x,&y);
	
	//Check if we should replay the record.
	if(selectedNumber!=NULL){
		SDL_Rect mouse={x,y,0,0};
		if(!bestTimeFilePath.empty()){
			SDL_Rect box={SCREEN_WIDTH-420,SCREEN_HEIGHT-130,372,32};
			if(checkCollision(box,mouse)){
				Game::recordFile=bestTimeFilePath;
				levels->setCurrentLevel(selectedNumber->getNumber());
				setNextState(STATE_GAME);
				return;
			}
		}
		if(!bestRecordingFilePath.empty()){
			SDL_Rect box={SCREEN_WIDTH-420,SCREEN_HEIGHT-98,372,32};
			if(checkCollision(box,mouse)){
				Game::recordFile=bestRecordingFilePath;
				levels->setCurrentLevel(selectedNumber->getNumber());
				setNextState(STATE_GAME);
				return;
			}
		}
	}
	
	//Call the base method from the super class.
    LevelSelect::checkMouse(imageManager, renderer);
}

void BallController::updateCollision(Grid* grid)
{
	for (int i = 0; i < grid->_cells.size(); i++)
	{
		int x = i % grid->_numXCells;
		int y = i / grid->_numXCells;

		Cell* cell = grid->getCell(x, y);
		for (int j = 0; j < cell->balls.size(); j++)
		{
			Ball* ball = cell->balls[j];
			checkCollision(ball, cell->balls, j+1);

			if (x > 0)
			{
				checkCollision(ball, grid->getCell(x - 1, y)->balls, 0);
				if (y > 0)
				{
					checkCollision(ball, grid->getCell(x-1,y-1)->balls, 0);
				}
				if (y < grid->_numYCells - 1)
				{
					checkCollision(ball, grid->getCell(x - 1, y + 1)->balls, 0);
				}
			}

			if (y > 0)
			{
				checkCollision(ball, grid->getCell(x, y - 1)->balls, 0);
			}
		}
	}
}

void Dot::move( SDL_Rect& wall )
{
    //Move the dot left or right
    mPosX += mVelX;
	mCollider.x = mPosX;

    //If the dot collided or went too far to the left or right
    if( ( mPosX < 0 ) || ( mPosX + DOT_WIDTH > SCREEN_WIDTH ) || checkCollision( mCollider, wall ) )
    {
        //Move back
        mPosX -= mVelX;
		mCollider.x = mPosX;
    }

    //Move the dot up or down
    mPosY += mVelY;
	mCollider.y = mPosY;

    //If the dot collided or went too far up or down
    if( ( mPosY < 0 ) || ( mPosY + DOT_HEIGHT > SCREEN_HEIGHT ) || checkCollision( mCollider, wall ) )
    {
        //Move back
        mPosY -= mVelY;
		mCollider.y = mPosY;
    }
}

void CGame::collideShellsWithEnemies()
{
	//get list of all plane shells
	std::list<std::unique_ptr<SDL_Rect>> *shells = plane.getShellsFired();

	//iterate over enemies
	for (std::list<std::unique_ptr<CEnemy>>::iterator enemy = enemyList.begin(); enemy != enemyList.end(); enemy++)
	{
		//check if enemy is on screen, and is alive
		if (checkCollision(plane.getCamera(), (*enemy)->getBox()) && (*enemy)->isAlive())
		{
			//iterate over plane shells
			for (std::list<std::unique_ptr<SDL_Rect>>::iterator shell = shells->begin(); shell != shells->end(); shell++)
			{
				SDL_Rect shell_rect = {(*shell)->x, (*shell)->y, (*shell)->w, (*shell)->h };
				if (checkCollision(shell_rect, (*enemy)->getBox()))
				{
					shell->release();
					shells->erase(shell++);
					if ((*enemy)->type == BRIDGE)
					{
						//if killed a bridge, set new starting pos
						SDL_Rect bridge = (*enemy)->getBox();
						plane.setStartingPos(bridge.x + bridge.w / 2, bridge.y - bridge.h);
						updateScoreTexture(1000);
					}
					(*enemy)->kill();
					updateScoreTexture(1000);
					break;
				}
			}
		}
	}
}

void Dot::move( std::vector<SDL_Rect>& otherColliders )
{
    //Move the dot left or right
    mPosX += mVelX;
    shiftColliders();

    //If the dot collided or went too far to the left or right
    if( ( mPosX < 0 ) || ( mPosX + DOT_WIDTH > SCREEN_WIDTH ) || checkCollision( mColliders, otherColliders ) )
    {
        //Move back
        mPosX -= mVelX;
		shiftColliders();
    }

    //Move the dot up or down
    mPosY += mVelY;
	shiftColliders();

    //If the dot collided or went too far up or down
    if( ( mPosY < 0 ) || ( mPosY + DOT_HEIGHT > SCREEN_HEIGHT ) || checkCollision( mColliders, otherColliders ) )
    {
        //Move back
        mPosY -= mVelY;
		shiftColliders();
    }
}

void getAdjacents(int i, int j, int* a)
{
	a[0] = (checkCollision(i,j-1) == COLLISION_SOLID);
	a[1] = (checkCollision(i+1,j) == COLLISION_SOLID);
	a[2] = (checkCollision(i,j+1) == COLLISION_SOLID);
	a[3] = (checkCollision(i-1,j) == COLLISION_SOLID);
}

void BallController::updateCollision(Grid* grid) {
    for (int i = 0; i < grid->m_cells.size(); i++) {

        int x = i % grid->m_numXCells;
        int y = i / grid->m_numXCells;

        Cell& cell = grid->m_cells[i];

        // Loop through all balls in a cell
        for (int j = 0; j < cell.balls.size(); j++) {
            Ball* ball = cell.balls[j];
            /// Update with the residing cell
            checkCollision(ball, cell.balls, j + 1);

            /// Update collision with neighbor cells
            if (x > 0) {
                // Left
                checkCollision(ball, grid->getCell(x - 1, y)->balls, 0);
                if (y > 0) {
                    /// Top left
                    checkCollision(ball, grid->getCell(x - 1, y - 1)->balls, 0);
                }
                if (y < grid->m_numYCells - 1) {
                    // Bottom left
                    checkCollision(ball, grid->getCell(x - 1, y + 1)->balls, 0);
                }
            }
            // Up cell
            if (y > 0) {
                checkCollision(ball, grid->getCell(x, y - 1)->balls, 0);
            }
        }
    }
}

//Eat pac-dots and the power pallets
void Pacman::eat() {
	for (unsigned int row = 0; row < map->size(); row++) {
		for (unsigned int col = 0; col < (*map)[row].size(); col++) {
			//Detect is it collided with the pac-dots
			//Add 100 score if true and erase the dot from the map
			if ((*map)[row][col] == "o") {
				if (checkCollision((col * 30) + 15, (row * 30) + 15, 0, 0)) {
					Mix_PlayChannel(-1, sound_food, 0);
					(*map)[row][col] = " ";
					score += 100;
					return;
				}
			}

			//Detect is it collided with the power pallets
			//Add 500 score if true and erase the power palletes from the map
			if ((*map)[row][col] == "p") {
				if (checkCollision((col * 30) + 15, (row * 30) + 15, 0, 0)) {
					Mix_PlayChannel(-1, sound_powerup, 0);
					(*map)[row][col] = " ";
					score += 500;
					setPowerUp(true);
					return;
				}
			}
		}
	}
}

void Hero::motion( SDL_Rect rect )
{
    /* Dla kazdego warunku - jesli uzytkownik kliknal LEFT to postac porusza sie w lewo z okreslona predkoscia, itd... */
    if( key[ SDL_SCANCODE_LEFT ] )
    {
        if( x > 0 )
        {
            x -= speed;
        }

    /* Dla kazdego warunku - jesli wystapila kolizja to cofa postac jeszcze przed wyrenderowaniem calej sytuacji */
        if( checkCollision( rect ) )
        {
            x += speed;
        }
    }

    else if( key[ SDL_SCANCODE_RIGHT ] )
    {
        if( x < 800 - texture.getWidth() )
        {
            x += speed;
        }

        if( checkCollision( rect ) )
        {
            x -= speed;
        }
    }

    if( key[ SDL_SCANCODE_UP ] )
    {
        if( y > 104 )
        {
            y -= speed;
        }

        if( checkCollision( rect ) )
        {
            y += speed;
        }
    }

    else if( key[ SDL_SCANCODE_DOWN ] )
    {
        if( y < 600 - texture.getHeight() )
        {
            y += speed;
        }

        if( checkCollision( rect ) )
        {
            y -= speed;
        }
    }
}

/* refresh pacmans position */
void refreshPacman(void) {
  checkCollision();

  updatePacmanPosition();
  updatePacmanMovement();
  checkPacmanMovement();

  addScores();
  checkCollision();
}

//Método principal para atualização do game em tempo real
void Game::gameUpdate(){
	//Limite de Frame Rate
	gameWindow.setFramerateLimit(60);

	//Checa se algum dos players completou as 3 voltas
	isRaceOver();

	//Verifica se a tecla ESC é pressionada, abrindo o menuPause
	renderPause();
	if (sf::Keyboard::isKeyPressed(sf::Keyboard::Escape))
		menuPause.abrirMenu();

	//Toca a música que será reproduzida durante a corrida
	raceBGM.playMusic();
	raceBGM.setVolume(100);

	//Ativa os métodos de entrada de keyboard para os controles de ambos os players
	player[0].ativarMovimentos(0);
	player[1].ativarMovimentos(1);

	//Checa todas as colisões possíveis dentro da partida para cada Player
	checkCollision(0);
	checkCollision(1);

	//Checa se os players estão no sentido correto da pista (caso eles percorram ao contrário), seus
	//carros explodirão
	player[0].checarSentido();
	player[1].checarSentido();

	//Checa durante a partida quando a linha de chegada é ultrapassada
	checkLap();
	
	//Centralizando cada câmera em seu respectivo player
	player[0].centralizarCamera();
	player[1].centralizarCamera();

	//Renderizações na tela do Player1
	gameWindow.setView(player[0].getCamera());
	renderMap();
	gameWindow.draw(player[0].getSprite());
	gameWindow.draw(player[1].getSprite());
	renderProjeteis();
	renderGUI(0);
	
	//Renderizações na tela do Player 2
	gameWindow.setView(player[1].getCamera());
	renderMap();
	gameWindow.draw(player[1].getSprite());
	gameWindow.draw(player[0].getSprite());
	renderProjeteis();
	renderGUI(1);

	gameWindow.display();
	gameWindow.clear();
}

bool CGame::standingOnCollapsingBridge(SDL_Rect A)
{
	for (std::list<std::unique_ptr<CEnemy>>::iterator it = enemyList.begin(); it != enemyList.end(); it++)
	{
		//checks all bridges on screen, and returns whether A is standing on dead brigde
		if ((*it)->type == BRIDGE && checkCollision((*it)->getBox(), plane.getCamera()) && !(*it)->isAlive())
		{
			return checkCollision(A, (*it)->getBox());
		}
	}
	return false;
}

/***********************************************************************
; Name:         checkCharHitChar
; Description:  This function checks for collisions between the attack
;								of one character and the position of another character.
;								It doesn't matter which character calls the	function,
;								it performs correctly.
;***********************************************************************/
char checkCharHitChar(struct character *self, char attackx, char attacky, unsigned char attackw, unsigned char attackh)
{
    char ret = 0;
		if (self->player == 0)
		{
				ret = checkCollision(attackx, attacky, attackw, attackh, player1.x, player1.y, player1.framew, player1.frameh);
		}
		else
		{
				ret = checkCollision(attackx, attacky, attackw, attackh, player0.x, player0.y, player0.framew, player0.frameh);
		}
		return ret;
}

bool ShapeRay::checkCollision( ShapeRect const *const other ) const
{
	// TODO: Do this properly (not with ray approximation
	ShapeRay bltr;
	bltr.pos = other->getCorner( diBOTTOMLEFT );
	bltr.target = other->getCorner( diTOPRIGHT );
	ShapeRay brtl;
	brtl.pos = other->getCorner( diBOTTOMRIGHT );
	brtl.target = other->getCorner( diTOPLEFT );
	if ( checkCollision( &bltr ) || checkCollision( &brtl ) )
		return true;
	return false;
}

void PlayState::update()
{
	if (TheInputHandler::Instance()->isKeyDown(SDL_SCANCODE_ESCAPE))
	{
		TheGame::Instance()->getStateMachine()->pushState(new PauseState());
	}
	for (int i = 0; i < m_gameObjects.size(); i++)
	{
		m_gameObjects[i]->update();
	}
	//dynamic_cast<SDLGameObject*>(m_gameObjects[1])->
	//if (m_gameObjects[0]->g);
	//dynamic_cast<SDLGameObject*>(m_gameObjects[1])->getBullet()->setBulletX(dynamic_cast<SDLGameObject*>(m_gameObjects[0])->getPlayer()->getPosition().getX());
	//dynamic_cast<SDLGameObject*>(m_gameObjects[1])->getVIBullet()[0]->setBulletX(dynamic_cast<SDLGameObject*>(m_gameObjects[0])->getPlayer()->getPosition().getX());
	//dynamic_cast<SDLGameObject*>(m_gameObjects[1])->getPlay
	for (int i = 2; i < m_gameObjects.size(); i++)
	{
		if (checkCollision(
			dynamic_cast<SDLGameObject*>(m_gameObjects[1]),
			dynamic_cast<SDLGameObject*>(m_gameObjects[i])))
		{

			std::string textureID = "bullet";
			std::string typeID = "Bullet";


			//pGameObject->load(new LoaderParams(x, y, width, height, textureID, numFrames, callbackID, animSpeed));

			m_gameObjects.erase(m_gameObjects.begin() + i);
			//m_gameObjects.erase(m_gameObjects.begin() + 1);

			//GameObject* pGameObject = TheGameObjectFactory::Instance()->create(typeID);
			m_gameObjects[1] = TheGameObjectFactory::Instance()->create(typeID);;
			m_gameObjects[1]->load(new LoaderParams(200, 350, 21, 21, textureID, 1, 0, 1));

			//m_gameObjects.push_back(pGameObject);
			//std::string _textID = "Bullet";
			//(x, y, width, height, textureID, numFrames, callbackID, animSpeed))
			//m_gameObjects[1]->load(LoaderParams(100, 100, 100, 100, _textID, 1, 0, 0));
			//StateParser stateParser;
			//stateParser.parseState("text.xml", s_playID, &m_gameObjects, &m_textureIDList);
		}
		if (checkCollision(
			dynamic_cast<SDLGameObject*>(m_gameObjects[0]),
			dynamic_cast<SDLGameObject*>(m_gameObjects[i])))
		{
			TheGame::Instance()->setState(State::GameOver);
		}
	}
}

void Bomb::explode()
{
	_explodeTime = Director::getInstance()->getTotalFrames();
	_isFire = true;
	_isRemote = false;
	_tick = 9999;
	GameSounds::Instance().playSound(ES_BOMB, false);
	if (_player)
	{
		_player->explodeBomb();
		_player = nullptr;
	}
	if (_brick)
	{
		_brick->explodeBomb();
		_brick = nullptr;
	}
	animate(_sprite, FCENTER);
	checkCollision(_sprite);
	_fires.push_back(_sprite);
	for (auto p : sPoints)
	{
		for (int i = 1; i <= _size; i++)
		{
			FireType type = i == _size ? FTAIL : FBODY;
			auto sprite = Sprite::createWithSpriteFrameName(typeStr[type] + "_1.png");
			sprite->setPosition(_sprite->getPosition() + p * i);

			Direction dir = pointToDir(p);
			if (dir == RIGHT)
			{
				sprite->setRotation(90);
			}
			else if (dir == LEFT)
			{
				sprite->setRotation(270);
			}
			else if (dir == DOWN)
			{
				sprite->setFlippedY(true);
			}

			animate(sprite, type);
			if (checkCollision(sprite)) break;
			_fires.push_back(sprite);
			addChild(sprite);
		}
	}
}

void MyRect::move()
{
    bool isColliding= checkCollision();
    //move down
    if(isColliding==false){
        if(pos().y()< 600){
            setPos(x(),y()+30);
            //setPos(x(),600);
            //qDebug()<<"position change";
        }
        else{
            qDebug()<<"count:"<<count;
            points+=2;
            myGame.printText(QString("Nice 2 Points: "),700,count,1.5);
            myGame.printText(QString::number(points),900,count,1.5);
            count+=50;

            if(count>=500){
                count=30;
            }
            isRowFilled(pos().y()+15);
            //qDebug()<<"rim";
            time->stop();
            myGame.spawn();
        }
    }
    else if(pos().y() < 29 &&isColliding){
        qDebug()<<"lose";
        scene()->clear();
        //        scene()->removeItem(this);
        //        delete this;
        QString yolo = QString ("You Lose");
        myGame.printText(yolo,425,250,3);
    }
    else if(checkCollision()){
        points+=2;
        myGame.printText(QString("Nice 2 Points: "),700,count,1.5);
        myGame.printText(QString::number(points),900,count,1.5);
        count+=50;
        if(count>=500){
            count=30;
        }

        isRowFilled(pos().y()+15);
        qDebug()<<"spawning";
        time->stop();
        myGame.spawn();
    }
}

void Bullet::update(){
    float deltaX = 0;
    float deltaY = 0;

    deltaX = sin(this->angle) * this->moveSpeed;
    deltaY = -cos(this->angle) * this->moveSpeed;

    if(!inShop){
        if(this->playerShot){
            for(int i = 0; i < MAX_ZOMBIES; i++){
                if(zombieList[i] != NULL && zombieList[i]->checkActive()){
                    if(checkCollision(this->posX, this->posY, zombieList[i]->posX, zombieList[i]->posY, this->width, this->height, zombieList[i]->width, zombieList[i]->height)){
                        zombieList[i]->health -= this->damage;
                        this->active = false;
                    }
                }
            }
        }else{
            if(checkCollision(this->posX, this->posY, playerCenterX, playerCenterY, this->width, this->height, playerWidth, playerHeight)){
                playerHealth -= this->damage;
                this->active = false;
            }
        }

        if(isPassable(this->posX+deltaX, this->posY, this->width, this->height, deltaX, deltaY)){
            this->posX += deltaX;
        }else{
            this->active = false;
        }

        if(isPassable(this->posX, this->posY+deltaY, this->width, this->height, deltaX, deltaY)){
            this->posY += deltaY;
        }else{
            this->active = false;
        }
    }else{
        if(this->posX+deltaX >= 0 && this->posX+deltaX + this->width < 400 && this->posY >= 0 && this->posY + this->height < 400){
            this->posX += deltaX;
        }else{
            this->active = false;
        }
        if(this->posX >= 0 && this->posX + this->width < 400 && this->posY+deltaY >= 0 && this->posY+deltaY + this->height < 400){
            this->posY += deltaY;
        }else{
            this->active = false;
        }
    }
}

float Item::checkCollision(BaseObject* object, float dt)
{
	auto collisionBody = (CollisionBody*)_listComponent["CollisionBody"];
	auto objeciId = object->getId();
	eDirection direction;

	if (collisionBody->checkCollision(object, direction, dt))
	{
		if (objeciId == eID::LAND || objeciId == eID::BRIDGE)		// => ??
		{
			if (this->getVelocity().y > 0)
				return 0.0;
			if (direction == eDirection::TOP)
			{
				auto gravity = (Gravity*)this->_listComponent["Gravity"];
				gravity->setStatus(eGravityStatus::SHALLOWED);
				gravity->setGravity(VECTOR2ZERO);

				auto move = (Movement*) this->_listComponent["Movement"];
				move->setVelocity(VECTOR2ZERO);
			}
		}
		if (objeciId == eID::BILL)
		{
			this->setStatus(eStatus::DESTROY);
			((Bill*)object)->changeBulletType(this->_type);
		}
	}
	return 0.0f;
}