/***********************************************************************************
* Function Name: Update
* Description: Called once per frame.
**********************************************************************************/
void Update()
{
Ray ray = GameCamera.ScreenPointToRay(Input.mousePosition);
RaycastHit hitInfo;
//Raycast will only hit player 1
//TODO: Add functionality for player 2
if (Physics.Raycast(ray, out hitInfo, 25.0f, LayerMask.GetMask("Worker")))
{
//If worker is clicked, "select" it and indicate it with a material change.
if (Input.GetMouseButtonDown(0))
{
//TODO: ADD A CONDITIONAL FOR PROMETHEUS - workers can choose to build, move(but cannot move up), then build again
PlayerWorker tempWorker = hitInfo.collider.gameObject.GetComponent <PlayerWorker>();
//UpdateCamera(selectedWorker);
//Check if worker belongs to player
if (GameManager.instance.WorkerCurrentPlayer(tempWorker))
{
selectedWorker = tempWorker;
GameManager.instance.SelectWorker(selectedWorker);
selectedWorker.owner.currentGodCard.ExitState();
}
}
}
}
public override void PlaceWorker(PlayerWorker worker, Space space)
{
Debug.Log("Using Minotaur Place Worker");
//If not at game start and there is an opposing worker at the space to move to
if (worker.currentSpace && space.workerAtSpace)
{
worker.enabled = false;
worker.currentSpace.workerAtSpace = null;
GameManager.instance.MinotaurCharge.Play();
BloodEffect.PlayEffectOnce(NewOpponentSpace(worker.currentSpace, space).spacePosition);
base.PlaceWorker(space.workerAtSpace, NewOpponentSpace(worker.currentSpace, space));
//Force the opposing worker to the space the current worker is occupying
//worker.enabled = false;
//base.PlaceWorker(space.workerAtSpace, worker.currentSpace);
//Move the worker, don't use base function because current space's worker is not set to null because opposing worker was forced there
space.workerAtSpace = worker;
worker.currentSpace = space;
// Calls helper method in the gameUI class to place worker
GameManager.instance.gameUI.PlaceWorker(worker, space);
worker.enabled = true;
}
else //Use default move if not
{
base.PlaceWorker(worker, space);
}
}
public override void PlaceWorker(PlayerWorker worker, Space selectedSpace)
{
Debug.Log("Using Athena PlaceWorker");
//for athena, we need to find out if they move a worker up
base.PlaceWorker(worker, selectedSpace); //do the normal movement, this updates levelChangePerTurn
GameManager.instance.IsAthenaActive(worker.owner); //now we determine if athena is activated after movement
}
public override void PlaceWorker(PlayerWorker worker, Space space)
{
if (worker.currentSpace.GetSpaceFloorLevel() - space.GetSpaceFloorLevel() >= 2)
{
movedDownTwoLevels = true;
}
base.PlaceWorker(worker, space);
}
/***********************************************************************************
* Function Name: Start
* Description: Used for initialization.
**********************************************************************************/
void Start()
{
blockedByDome = false; // Game starts with no domes
workerAtSpace = null; // Game starts prior to players choosing starting spaces
building = null;
// Record the address of this space
spacePosition = new Vector3(transform.position.x, transform.position.y, transform.position.z);
currentFloorLevel = FloorLevel.ground;
}
/***********************************************************************************
* Script Name: PlaceWorker
* Description: Move a worker to a space (Animation related)
**********************************************************************************/
public void PlaceWorker(PlayerWorker worker, Space selectedSpace)
{
worker.transform.position = new Vector3(selectedSpace.spacePosition.x, selectedSpace.GetHeight(), selectedSpace.spacePosition.z);
if (worker.owner.currentGodCard.name == "Hermes" && GameManager.instance.currentPlayer == worker.owner && GameManager.instance.currentMode != GameManager.Mode.SettingUp)
{
HermesSpeed.Play();
PlayEffectOnce(HermesDust, worker.transform.position);
}
}
public override List <Space> GetAvailableMoves(PlayerWorker worker)
{
List <Space> AvailableMoves = base.GetAvailableMoves(worker);
//Cannot move upward if player built before moving
if (buildBeforeMove)
{
AvailableMoves.RemoveAll(moves => (int)moves.GetSpaceFloorLevel() - (int)worker.currentSpace.GetSpaceFloorLevel() > 0);
}
return(AvailableMoves);
}
public override List <Space> GetAvailableBuilds(PlayerWorker worker)
{
List <Space> AvailableBuilds = base.GetAvailableBuilds(worker);
//Remove the space that was just built on
if (!firstBuild)
{
AvailableBuilds.Remove(firstBuildSpace);
}
return(AvailableBuilds);
}
//TODO THIS IS NOT OVERRIDING THE APOLLO GetAvailableMoves()... would have to hardcode Side effect to all gods....
//restrict movement
public override List <Space> GetAvailableMoves(PlayerWorker worker)
{
Debug.Log("Athena restriction called");
List <Space> availableMoves = new List <Space>();
availableMoves.AddRange(worker.currentSpace.AdjSpaces);
//Remove all spaces that are higher
availableMoves.RemoveAll(moves => (int)moves.GetSpaceFloorLevel() - (int)worker.currentSpace.GetSpaceFloorLevel() >= 1);
//Remove all spaces that are blocked by domes
availableMoves.RemoveAll(moves => moves.blockedByDome);
return(availableMoves);
}
/***********************************************************************************
* Function Name: DetermineAvailableMovement
* Description: This function determines if there are any changes to available movements
* for that worker and outputs a Space List of legal moves for that worker
**********************************************************************************/
public List <Space> GetPossibleMovementsForWorker(PlayerWorker worker)
{
List <Space> AvailableMoves = new List <Space>();
//Get available moves allowed by player's god card
AvailableMoves = worker.owner.currentGodCard.GetAvailableMoves(worker);
//If Athena was activated, take out all moves that lead upward
if (instance.AthenaActivated)
{
AvailableMoves.RemoveAll(moves => (int)moves.GetSpaceFloorLevel() - (int)worker.currentSpace.GetSpaceFloorLevel() > 0);
}
return(AvailableMoves);
}
/***********************************************************************************
* Function Name: StartMovementPhase
* Description: This function determines how to proceed with the movement logic
* For instance, is this movement phase restricted in some way (Athena), or enhanced in someway
* i.e. (Apollo- allows swapping of positions, Minotaur- allows pushing players, Artemis- allows 2 spaces of movement)
**********************************************************************************/
public void StartMovementPhase(PlayerWorker worker, Space selectedSpace)
{
//Determine if there are any movement restrictions
//TODO: Add Hermes conditional
if (AthenaActivated)
{
worker.owner.currentGodCard.PlaceWorker(worker, selectedSpace);
instance.AthenaActivated = false; //turn off effect afterwards
}
else
{
//move with no restrictions, or move with god ability
worker.owner.currentGodCard.PlaceWorker(worker, selectedSpace);
}
}
/***********************************************************************************
* Function Name: SetWorkerStartingSpace
* Description: Setter function set PlayerWorker's starting space
**********************************************************************************/
void SetWorkerStartingSpace(PlayerWorker worker)
{
RaycastHit hit;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Physics.Raycast(ray, out hit, 25.0f, LayerMask.GetMask("Tile")))
{
Space clickedSpace = hit.collider.gameObject.GetComponent <Space>();
if (clickedSpace.workerAtSpace != null)
{ //did the user click on a space that's already occupied by another worker? then do not assign space to worker's currentSpace
return;
}
MoveWorkerToSpace(worker, clickedSpace);
}
}
/***********************************************************************************
* Function Name: ExitBuildState
* Description: Exit Build State and Enter Select Worker state for next player
**********************************************************************************/
public void ExitBuildState()
{
//Reset worker + space selection
GameManager.instance.ResetSelection(selectedWorker);
selectedWorker = null;
selectedSpace = null;
//End current player's turn
GameManager.instance.EndTurn();
//Enter worker selector state for other player
WorkerSelector workerSelect = GetComponent <WorkerSelector>();
workerSelect.EnterState();
}
/***********************************************************************************
* Function Name: GetAvailableBuilds
* Description: Get the available moves for a worker
**********************************************************************************/
public List <Space> GetAvailableBuilds(PlayerWorker worker)
{
List <Space> availableBuilds = new List <Space>();
availableBuilds.AddRange(worker.currentSpace.AdjSpaces);
//Remove all spaces with workers
//TODO: Conditionals for God cards
availableBuilds.RemoveAll(moves => moves.workerAtSpace != null);
//Remove all spaces that are blocked by domes
availableBuilds.RemoveAll(moves => moves.blockedByDome);
return(availableBuilds);
}
public override List <Space> GetAvailableMoves(PlayerWorker worker)
{
List <Space> finalOutput;
Space starting = worker.currentSpace; //starting spot of worker
AdjToWorkerSpace = base.GetAvailableMoves(worker);
List <Space> Legal = new List <Space>(); //Legal set of avaiable moves for hermes
FloodFill(starting, Legal);
Legal.RemoveAll(temp => temp.workerAtSpace != null); //remove workers
Legal.RemoveAll(temp => temp.blockedByDome);
finalOutput = AdjToWorkerSpace.Union(Legal).ToList();
return(finalOutput);
}
/***********************************************************************************
* Function Name: EnterBuildState
* Description: Enter Build State
**********************************************************************************/
public void EnterBuildState(PlayerWorker worker)
{
//added by Brian for ActionPhase UI
GameManager.instance.currentPhase = GameManager.ActionPhase.Build;
//Set state to build
state = State.build;
selectedWorker = worker;
this.enabled = true;
availableSpaces = selectedWorker.owner.currentGodCard.GetAvailableBuilds(worker);
//Highlight availableSpaces
highlightAvailableSpaces();
}
/***********************************************************************************
* Function Name: EnterMoveState
* Description: Enter Move State
**********************************************************************************/
public void EnterMoveState(PlayerWorker worker)
{
//added by Brian for ActionPhase UI
GameManager.instance.currentPhase = GameManager.ActionPhase.Move;
//Set state to move
state = State.move;
selectedWorker = worker;
this.enabled = true;
availableSpaces = GameManager.instance.GetPossibleMovementsForWorker(worker);
//Highlight availableSpaces
highlightAvailableSpaces();
}
/***********************************************************************************
* Function Name: MoveWorkerToSpace
* Description: This is the normal movement function
**********************************************************************************/
public void MoveWorkerToSpace(PlayerWorker worker, Space selectedSpace)
{
if (instance.currentMode == Mode.Playing) //added this conditional to keep track of worker level changes, used for Athena ability
{
worker.owner.levelChangeDuringTurn = GetFloorLevelChange(worker.currentSpace, selectedSpace);
}
if (worker.currentSpace)
{
worker.currentSpace.workerAtSpace = null;
}
selectedSpace.workerAtSpace = worker;
worker.currentSpace = selectedSpace;
// Calls helper method in the gameUI class to place worker
gameUI.PlaceWorker(worker, selectedSpace);
// Moving floor placement offset logic to GameUI.cs
}
/***********************************************************************************
* Function Name: GetAvailableMoves
* Description: Get the typically available moves for a worker with no buffs/debuffs
**********************************************************************************/
public List <Space> GetAvailableMoves(PlayerWorker worker)
{
List <Space> availableMoves = new List <Space>();
availableMoves.AddRange(worker.currentSpace.AdjSpaces);
//Remove all spaces with worker
availableMoves.RemoveAll(moves => moves.workerAtSpace != null);
//Remove all spaces that are too high or too low
availableMoves.RemoveAll(moves => (int)moves.GetSpaceFloorLevel() - (int)worker.currentSpace.GetSpaceFloorLevel() > 1);
//Remove all spaces that are blocked by domes
availableMoves.RemoveAll(moves => moves.blockedByDome);
return(availableMoves);
}
public override List <Space> GetAvailableMoves(PlayerWorker worker)
{
List <Space> availableMoves = new List <Space>();
availableMoves.AddRange(worker.currentSpace.AdjSpaces);
//Keep spaces with opposing workers
availableMoves.RemoveAll(moves => moves.workerAtSpace && moves.workerAtSpace.owner == GameManager.instance.currentPlayer);
availableMoves.RemoveAll(moves => (moves.workerAtSpace != null && !CanPushWorker(worker.currentSpace, moves)));
//Remove all spaces that are too high or too low
availableMoves.RemoveAll(moves => (int)moves.GetSpaceFloorLevel() - (int)worker.currentSpace.GetSpaceFloorLevel() > 1);
//Remove all spaces that are blocked by domes
availableMoves.RemoveAll(moves => moves.blockedByDome);
return(availableMoves);
}
/***********************************************************************************
* Function Name: ExitMoveState
* Description: Exit Move State and Enter Build state
**********************************************************************************/
public void ExitMoveState()
{
//Reset space selection
selectedSpace = null;
//Check win condition
if (selectedWorker.owner.currentGodCard.HasCurrentPlayerWon())
{
//Reset worker selection
GameManager.instance.ResetSelection(selectedWorker);
selectedWorker = null;
//End Game
GameManager.instance.EndGame();
}
else
{
//Enter build state
selectedWorker.owner.currentGodCard.EnterBuildState(selectedWorker);
}
}
public override void PlaceWorker(PlayerWorker worker, Space space)
{
Debug.Log("Using Apollo Place Worker");
//If not at game start and there is an opposing worker at the space to move to
if (worker.currentSpace && space.workerAtSpace)
{
//Force the opposing worker to the space the current worker is occupying
worker.enabled = false;
base.PlaceWorker(space.workerAtSpace, worker.currentSpace);
//Move the worker, don't use base function because current space's worker is not set to null because opposing worker was forced there
space.workerAtSpace = worker;
worker.currentSpace = space;
// Calls helper method in the gameUI class to place worker
GameManager.instance.gameUI.PlaceWorker(worker, space);
GameManager.instance.flash.FlashAttack();
worker.enabled = true;
}
else //Use default move if not
{
base.PlaceWorker(worker, space);
}
}
//Allows a worker to move twice, but not back to the original spot
public override List <Space> GetAvailableMoves(PlayerWorker worker)
{
Debug.Log("Inside Artemis's GetAvailableMoves");
List <Space> finalAvailableMoves = new List <Space>();
List <Space> tempMoves;
finalAvailableMoves = base.GetAvailableMoves(worker);
//If Athena was activated, take out all moves that lead upward
if (GameManager.instance.AthenaActivated)
{
finalAvailableMoves.RemoveAll(moves => (int)moves.GetSpaceFloorLevel() - (int)worker.currentSpace.GetSpaceFloorLevel() > 0);
}
//Get all moves possible for a second move
foreach (Space moves in finalAvailableMoves)
{
tempMoves = new List <Space>();
tempMoves.AddRange(moves.AdjSpaces);
//Remove all spaces with worker
tempMoves.RemoveAll(temp => temp.workerAtSpace != null);
//Remove all spaces that are too high or too low
tempMoves.RemoveAll(temp => (int)temp.GetSpaceFloorLevel() - (int)moves.GetSpaceFloorLevel() > 1);
//Remove all spaces that are blocked by domes
tempMoves.RemoveAll(temp => temp.blockedByDome);
//Union with available moves
finalAvailableMoves = finalAvailableMoves.Union(tempMoves).ToList();
}
//removing any space with domes (vs Atlas)
return(finalAvailableMoves);
}
/***********************************************************************************
* Script Name: ResetSelection
* Description: Reset worker selection.
**********************************************************************************/
public void ResetSelection(PlayerWorker worker)
{
worker.DeselectWorker();
}
/***********************************************************************************
* Script Name: SelectWorker
* Description: Show worker selection.
**********************************************************************************/
public void SelectWorker(PlayerWorker worker)
{
worker.SelectWorker();
}
public virtual void EnterMoveState(PlayerWorker worker)
{
GameManager.instance.gameUI.GetComponent <TileSelector>().EnterMoveState(worker);
}
public virtual List <Space> GetAvailableBuilds(PlayerWorker worker)
{
return(GameManager.instance.GetAvailableBuilds(worker));
}
public virtual void PlaceWorker(PlayerWorker worker, Space space)
{
GameManager.instance.MoveWorkerToSpace(worker, space);
}
/***********************************************************************************
* Function Name: Start
* Description: Used for initialization.
**********************************************************************************/
void Start()
{
enabled = false;
selectedWorker = null;
}
public PlayerManager(DataContext context)
{
_context = context ?? throw new Exception("The context cannot be null.");
_playerWorker = new PlayerWorker(_context);
}
