Player.cpp

#include "Player.h"

#include "GameObject.h"

Player::Player(Cell * pCell, int playerNum) : stepCount(0), health(10), playerNum(playerNum), currDirection(RIGHT) , hasDoubleLaser(false), hasToolkit  (false), hasHackDevice  (false)
{
	this->pCell = pCell;
	//constructor edited by heba
	// Make all the needed initialization or validations


	///By Eyad : init move and shoot default to true.
	canMove = true;
	canShoot = true;
	beingShot = false;
	hasShield = false;
	hasRefGear = false;
}

// ====== Setters and Getters ======

void Player::SetCell(Cell * cell)
{
	pCell = cell;
}

Cell* Player::GetCell() const
{
	return pCell;
}
int Player::GetPlayerNum() const 
{
	return playerNum;
}

void Player::SetHealth(int h)
{
	//if by Eyad:
	if (h >=0 && h<=10)
	{

		this->health = h;
		
	}
	
	///TODO: Do any needed validations
}

int Player::GetHealth()
{
	return this->health;
}

///////By Eyad : shoot and move setters and getters.
void Player::SetCanMove(bool value) { canMove = value; }
bool Player::CanMove() const { return canMove; }

void Player::SetCanShoot(bool value) { canShoot = value; }
bool Player::CanShoot() const { return canShoot; }

void Player::ResetTurn(){ canShoot = true, canMove = true, beingShot= false; }

////////////////////////Consumables functions///////////By_Eyad///////////////////

void Player::SetHasToolkit(bool x)
{
	hasToolkit = x;
}

bool Player::GetHasToolkit()
{
	return hasToolkit;
}
// ====== Drawing Functions ======

void Player::Draw(Output* pOut) const
{
	color playerColor = UI.PlayerColors[playerNum];

	pOut->DrawPlayer(pCell->GetCellPosition(),playerNum,playerColor,currDirection);
	
	///TODO: use the appropriate output function to draw the player with "playerColor"

}

void Player::ClearDrawing(Output* pOut) const
{
 
    color cellColor = UI.CellColor;  // Default color, assuming no game object

    // Use the Output function to draw the player at this position with the background color
    pOut->DrawPlayer(pCell->GetCellPosition(), playerNum, cellColor, currDirection);
}

// ====== Game Functions ======

void Player::Move(Grid* pGrid, Command moveCommands[])
{
	int x = 0;
	int y = 0;

	Player* current = pGrid->GetCurrentPlayer();
	Cell* known = current->GetCell();
	CellPosition place = known->GetCellPosition();
	for (int i = 0; i < sizeof(moveCommands) + 1;i++) {
		switch (moveCommands[i]) {
		case NO_COMMAND:
			break;
		case MOVE_FORWARD_ONE_STEP:
			place.AddCellNum(1, current->currDirection);
			break;
		case MOVE_BACKWARD_ONE_STEP:
			reverse();
			place.AddCellNum(1, current->currDirection);
			reverse();
			break;
		case MOVE_FORWARD_TWO_STEPS:
			place.AddCellNum(2, current->currDirection);
			break;
		case MOVE_BACKWARD_TWO_STEPS:
			reverse();
			place.AddCellNum(2, current->currDirection);
			reverse();
			break;
		case MOVE_FORWARD_THREE_STEPS:
			place.AddCellNum(3, current->currDirection);
			break;
		case MOVE_BACKWARD_THREE_STEPS:
			reverse();
			place.AddCellNum(3, current->currDirection);
			reverse();
			break;
		case ROTATE_CLOCKWISE:
			ClearDrawing(pGrid->GetOutput());
			currDirection = (Direction)((currDirection + 3) % 4);
			break;
		case ROTATE_COUNTERCLOCKWISE:
			ClearDrawing(pGrid->GetOutput());
			currDirection = (Direction)((currDirection + 1) % 4);
			break;
		default:
			break;

		}

		pGrid->UpdatePlayerCell(current, place);
		pGrid->GetOutput()->PrintMessage("click anywhere to excute next command");
		pGrid->GetInput()->GetPointClicked(x, y);



	}
	///TODO: Implement this function using the guidelines mentioned below
	if (current->GetCell()->GetGameObject() != nullptr){
		
		current->GetCell()->GetGameObject()->Apply(pGrid, current);

	}
	if (pGrid->GetEndGame()) {
		pGrid->GetOutput()->PrintMessage("Game finished ,click anywhere ");
		pGrid->GetInput()->GetPointClicked(x, y);
		return;
	}
}






void Player::AppendPlayerInfo(string & playersInfo) const
{
	// TODO: Modify the Info as needed
	playersInfo += "P" + to_string(playerNum) + "(" ;
	playersInfo += to_string(currDirection) + ", ";
	playersInfo += to_string(health) + ")";
	playersInfo += "Equipment: ";
	if (hasDoubleLaser == true)
		playersInfo += "Double Laser, ";
	if (hasToolkit == true)
		playersInfo += "Toolkit, ";
	if (hasHackDevice == true)
		playersInfo += "Hack Device, ";
	if (!hasDoubleLaser && !hasToolkit && !hasHackDevice)
		playersInfo += "None";

}


void Player::RotateRight()
{
	switch (playerDirection)
	{
	case UP:    playerDirection = RIGHT; 
		break;
	case RIGHT: playerDirection = DOWN;
		break;
	case DOWN:  playerDirection = LEFT;
		break;
	case LEFT:  playerDirection = UP;
		break;
	}

	Output* pOut = pGrid->GetOutput();
	pOut->PrintMessage("Player rotated 90° clockwise!");
}

void Player::RotateLeft()
{
	switch (playerDirection) 
	{
	case UP:    playerDirection = LEFT; 
		break;
	case LEFT:  playerDirection = DOWN; 
		break;
	case DOWN:  playerDirection = RIGHT;
		break;
	case RIGHT: playerDirection = UP;
		break;
	}


	Output* pOut = pGrid->GetOutput();
	pOut->PrintMessage("Player rotated 90° counterclockwise!");
}


void Player::EquipDoubleLaser()
{
	hasDoubleLaser = true;
}


void Player::AddToolkit() 
{
	hasToolkit = true;
}

void Player::AddHackDevice() 
{
	hasHackDevice = true;
}

bool Player::HasDoubleLaser() const 
{
	return hasDoubleLaser;
}


bool Player::HasToolkit() const 
{
	return hasToolkit;
}

bool Player::HasHackDevice() const 
{
	return hasHackDevice;
}

bool skipTurn = false;

void Player::SkipNextTurn() 
{
	skipTurn = true;
}

bool Player::IsTurnSkipped() const 
{
	return skipTurn;
}

Direction Player::getDirection(){return currDirection;}

void Player::takeDamage()
{
	beingShot= true;
	///////////////////////////check shield;;;
	
	//////////better check it when calling the func;

	////
	if (health>0)
	{
		health -=2;
	}
}

void Player::setHasShield(bool x){ hasShield = x; }
bool Player::getHasShield(){ return hasShield;}
//

void Player::setRefGear(bool x){ hasRefGear = x;}
bool Player::getRefGear(){return hasRefGear;}

void Player::reverse() {

	switch (currDirection) {
	case RIGHT:
		currDirection = LEFT;
		break;
	case LEFT:
		currDirection = RIGHT;
		break;
	case UP:
		currDirection = DOWN;
		break;
	case DOWN:
		currDirection = UP;
		break;

	}
}

void Player::ResetAll()
{
	canMove = true;
	canShoot = true;
	beingShot = false;
	hasShield = false;
	hasRefGear = false;
	////reset cell;
}