//------------------ // affecting players //------------------ public bool CanHenchmanAttackTargetPlayer(BoardSpaceEnum henchmanSpace, PlayerManager target) { HenchmanCard henchman = board[henchmanSpace]; if (henchman != null) { if (!henchman.HasActedThisTurn()) { if (henchman.GetController() != target) { return(true); } else { Debug.Log("Henchman can't attack a player because the player is its controller..."); } } else { Debug.Log("Henchman can't attack a player because it already acted this turn..."); } } else { Debug.Log("Henchman can't attack a player because it doesn't exist..."); } return(false); }
private void VisuallyPutHenchmanAtSpace(HenchmanCard henchman, BoardSpaceEnum space) { RectTransform henchmanTransform = henchman.GetComponent <RectTransform>(); henchmanTransform.SetParent(visualBoardSpaces[space].transform); henchmanTransform.anchorMin = new Vector2(0.5f, 0.5f); henchmanTransform.anchorMax = new Vector2(0.5f, 0.5f); henchmanTransform.localScale = new Vector3(1f, 1f, 1f); henchmanTransform.localPosition = new Vector3(0f, 0f, 0f); }
/* * This method is called whenever the player clicks a henchman in play. It will cause the * RoTStateMachine to move to the AttackingWithHenchmanState as long as the henchman is * controlled by the active player and can still attack this turn. * * NOTE: Any behaviors related to clicking a henchman that has attacked or a henchman * controlled by the opponent should be implemented in this method. */ private void HandleHenchmanInPlaySelected(HenchmanCard henchman) { if (henchman.GetController() == rsm.GetActivePlayer()) { if (!henchman.HasActedThisTurn()) { rsm.SetAttackingHenchman(henchman); rsm.ChangeState <AttackingWithHenchmanState>(); } } }
/* * This method is called whenever the player clicks a henchman in play. If that * henchman is controlled by the non-active player, the attacking henchman will * attack it, if it can (based on Ellusive), then move the RoTStateMachine back * to the MainPhaseState. If that henchman is controlled by the active player, * the MainPhaseState will also be re-entered. */ private void HandleHenchmanInPlaySelected(HenchmanCard henchman) { //CanHenchmenFight() will make sure the henchmen are on opposing sides of the board BoardSpaceEnum attackingLocation = rsm.GetAttackingHenchman().GetLocation(); BoardSpaceEnum targetLocation = henchman.GetLocation(); if (rsm.GetBoard().CanHenchmenFight(attackingLocation, targetLocation)) { rsm.GetBoard().HaveHenchmenFight(attackingLocation, targetLocation); } rsm.ChangeState <MainPhaseState>(); }
public override void Enter() { base.Enter(); Debug.Log("Entering PlayingHenchmanState"); //the card being played must be owned by the active player Debug.Assert(rsm.GetCardToBePlayed().GetController() == rsm.GetActivePlayer()); //the card being played must be a henchman Debug.Assert(rsm.GetCardToBePlayed().GetType() == typeof(HenchmanCard)); henchmanToBePlayed = (HenchmanCard)rsm.GetCardToBePlayed(); }
//should only be called if CanHenchmanAttackTargetPlayer() returns true public void HaveHenchmanAttackTargetPlayer(BoardSpaceEnum henchmanSpace, PlayerManager target, uint damageReduction = 0) { HenchmanCard henchman = board[henchmanSpace]; if (henchman.GetAttack() > 0) { target.ApplyDamage(henchman.GetAttack() - damageReduction); } //trigger rush for combat damage henchman.RushEvent.Invoke(); henchman.ActionTaken(); }
//returns true if successful public bool TryPutHenchmanOnOpponentSide(HenchmanCard henchman) { for (int i = (int)BoardSpaceEnum.O1; i <= (int)BoardSpaceEnum.O5; i++) { BoardSpaceEnum currSpace = (BoardSpaceEnum)i; if (CanPutHenchmanAtSpace(henchman, currSpace)) { PutHenchmanAtSpace(henchman, currSpace); return(true); } } return(false); }
//this method assumes the new henchman hasn't yet been added to henchmenOrder private void TriggerAttentionSeekerEvents() { //invoke attention-seeker events on all henchman, in the order they came into play RemoveQueue <BoardSpaceEnum> newOrder = new RemoveQueue <BoardSpaceEnum>(); while (!henchmenOrder.IsEmpty()) { BoardSpaceEnum henchmanSpace = henchmenOrder.Dequeue(); HenchmanCard henchman = board[henchmanSpace]; henchman.AttentionSeekerEvent.Invoke(); newOrder.Enqueue(henchmanSpace); } henchmenOrder = newOrder; }
//NOTE: Should be called before switching the active player! public void HandleEndOfTurn(PlayerManager activePlayer) { //call HandleEndOfTurn() on all HenchmanCards in play, in the order they came into play RemoveQueue <BoardSpaceEnum> newOrder = new RemoveQueue <BoardSpaceEnum>(); while (!henchmenOrder.IsEmpty()) { BoardSpaceEnum henchmanSpace = henchmenOrder.Dequeue(); HenchmanCard henchman = board[henchmanSpace]; if (henchman.GetController() == activePlayer) { henchman.HandleEndOfTurn(); } newOrder.Enqueue(henchmanSpace); } henchmenOrder = newOrder; }
public bool CanHenchmenFight(BoardSpaceEnum playerSpace, BoardSpaceEnum opponentSpace) { bool onOpposingSides = OnOpposingSides(playerSpace, opponentSpace); if ((board[playerSpace] != null) && (board[opponentSpace] != null) && onOpposingSides) { //if both spaces are occupied by henchman and they're on opposing sides of the board, they could be able to fight HenchmanCard playerHenchman = board[playerSpace]; HenchmanCard opponentHenchman = board[opponentSpace]; if (!playerHenchman.HasActedThisTurn()) { //if the henchman hasn't already acted this turn, the henchmen could fight if (playerHenchman.IsEllusive() || (!playerHenchman.IsEllusive() && !opponentHenchman.IsEllusive())) { //if the attacking henchman is ellusive or neither henchman is ellusive, they can fight return(true); } else { Debug.Log("Henchmen wouldn've been able to fight, except one was ellusive and the other wasn't..."); return(false); } } else { Debug.Log("The henchman at playerSpace already moved this turn..."); return(false); } } else { if (board[playerSpace] == null) { Debug.Log("playerSpace passed to TryHaveHenchmanFight() didn't have a henchman in it..."); } if (board[opponentSpace] == null) { Debug.Log("opponentSpace passed to TryHaveHenchmanFight() didn't have a henchman in it..."); } if (!onOpposingSides) { Debug.Log("The two henchman trying to fight in TryHaveHenchmanFight() weren't on opposite sides of the board..."); } return(false); } }
//--------------------- // responding to events //--------------------- private void TriggerVengeanceEvents(PlayerManager prizeCardRecipient) { //invoke vengeance events on relevant henchman, in the order they came into play RemoveQueue <BoardSpaceEnum> newOrder = new RemoveQueue <BoardSpaceEnum>(); while (!henchmenOrder.IsEmpty()) { BoardSpaceEnum henchmanSpace = henchmenOrder.Dequeue(); HenchmanCard henchman = board[henchmanSpace]; if (henchman.GetController() != prizeCardRecipient) { //only invoke the event if the recipient of the prize card was not the henchman's controller henchman.VengeanceEvent.Invoke(); } newOrder.Enqueue(henchmanSpace); } henchmenOrder = newOrder; }
//should only be called if CanPutHenchmanAtSpace() returns true public void PutHenchmanAtSpace(HenchmanCard henchman, BoardSpaceEnum space) { //put it on the board board[space] = henchman; henchman.SetPlayState(PlayStateEnum.BOARD); henchman.SetLocation(space); //move the henchman visually VisuallyPutHenchmanAtSpace(henchman, space); //invoke its flashy event henchman.FlashyEvent.Invoke(); //invoke all other henchmen's attention-seeker events TriggerAttentionSeekerEvents(); //add it to the order henchmenOrder.Enqueue(space); }
//should only be called if CanRemoveHenchmanFromBoard() returns true public void RemoveHenchmanFromBoard(BoardSpaceEnum space) { HenchmanCard henchman = board[space]; //remove it from the board board[space] = null; henchman.SetPlayState(PlayStateEnum.DONE); henchman.SetLocation(BoardSpaceEnum.NONE); //remove it from the order henchmenOrder.RemoveArbitrary(space); //remove the henchman visually henchman.gameObject.SetActive(false); //set up the henchman to be destroyed henchman.GetController().GetDeck().DestroyCard(henchman); //invoke its closing-act event henchman.ClosingActEvent.Invoke(); }
//should only be called if CanHenchmanFight() returns true public void HaveHenchmenFight(BoardSpaceEnum playerSpace, BoardSpaceEnum opponentSpace) { HenchmanCard playerHenchman = board[playerSpace]; HenchmanCard opponentHenchman = board[opponentSpace]; //check if any damage needs to trample over int excess = (int)playerHenchman.GetAttack() - opponentHenchman.GetHealth(); if ((excess > 0) && playerHenchman.IsOverAchiever()) { Debug.Log("ROLLING DAMAGE OVER"); uint reduction = playerHenchman.GetAttack() - (uint)excess; HaveHenchmanAttackTargetPlayer(playerSpace, opponentHenchman.GetController(), damageReduction: reduction); } //apply damage to the henchmen after applying trample damage to prevent issues arising from the //trampler dying after taking damage from the other henchman, then not being at playerSpace anymore //FIXME: find a more elegant solution, since this could cause some unintuitive interactions with // triggered effects on the other henchman, since it technically won't "die" until after // damage has trampled over playerHenchman.ApplyDamage((int)opponentHenchman.GetAttack()); opponentHenchman.ApplyDamage((int)playerHenchman.GetAttack()); playerHenchman.ActionTaken(); }
//------------------------ // affecting cards in play //------------------------ public bool CanPutHenchmanAtSpace(HenchmanCard henchman, BoardSpaceEnum space) { //henchman can be placed if the space is on it's controller's side bool onControllersSide = false; if (henchman.GetController() == player) { if ((space == BoardSpaceEnum.P1) || (space == BoardSpaceEnum.P2) || (space == BoardSpaceEnum.P3) || (space == BoardSpaceEnum.P4) || (space == BoardSpaceEnum.P5)) { onControllersSide = true; } } else if (henchman.GetController() == opponent) { if ((space == BoardSpaceEnum.O1) || (space == BoardSpaceEnum.O2) || (space == BoardSpaceEnum.O3) || (space == BoardSpaceEnum.O4) || (space == BoardSpaceEnum.O5)) { onControllersSide = true; } } else { Debug.Log("The henchman trying to be placed has a controller that's neither the player nor the opponent..."); } if (onControllersSide) { //the space must also be empty return(board[space] == null); } else { return(false); } }
public void SetAttackingHenchman(HenchmanCard henchman) { attackingHenchman = henchman; }
/* * This method is used to clear out any temporary variables stored in the RoTStateMachine * that are used only by particular states, so there is never incorrect information being * used by those states. */ public void ResetTemporaryVariables() { cardToBePlayed = null; attackingHenchman = null; shouldDrawOnTurnStart = true; }