public TurnActionModel(TurnActionModel ta) { //GameStateManager generates a TurnActionModel for each PlayFieldModel //All players recieve the field and check if the turnActionModel has their guid //if it has their guid it is their turn //The player on their turn fills a subclass of TurnActionModel for the move they want to make using the information in this TurnActionModel //The player then sends that back to the service and GameStateManager does the move playerGuids = ta.playerGuids;//List of players who can use the actions listed serverGuid = ta.serverGuid; currentPlayFieldModelGuid = ta.currentPlayFieldModelGuid; thisTurnactionGuid = ta.thisTurnactionGuid;//server side generated typesOfActionListedPlayersCanTake = ta.typesOfActionListedPlayersCanTake; typeOfActionToTake = ta.typeOfActionToTake; actionTaken = ta.actionTaken; }
public TurnActionModel(List <Guid> playerGuidsP, Guid serverGuidP, Guid currentPlayFieldModelGuidP, Guid guidOfThisTurnAction, List <TurnActionTypes> typesOfActionsAllowedForPlayersListed, TurnActionTypes typeOfActionToTake, bool actionTaken) { //GameStateManager generates a TurnActionModel for each PlayFieldModel //All players recieve the field and check if the turnActionModel has their guid //if it has their guid it is their turn //The player on their turn fills a subclass of TurnActionModel for the move they want to make using the information in this TurnActionModel //The player then sends that back to the service and GameStateManager does the move playerGuids = playerGuidsP;//List of players who can use the actions listed serverGuid = serverGuidP; currentPlayFieldModelGuid = currentPlayFieldModelGuidP; thisTurnactionGuid = guidOfThisTurnAction;//server side generated typesOfActionListedPlayersCanTake = typesOfActionsAllowedForPlayersListed; this.typeOfActionToTake = typeOfActionToTake; this.actionTaken = actionTaken; }
/// <summary> /// Determines what state the game is currently in and sets the appropriate possible next states for the move being played and calls doAppropriateAction to play the move /// </summary> /// <param name="lastState"></param> /// <param name="currentState"></param> /// <param name="nextState"></param> /// <param name="playerPerformingAction"></param> /// <param name="typeOfActionToPerform"></param> /// <param name="cardsAndPlayersInvolved"></param> /// <returns></returns> public BoolResponseBox evaluateMove(PlayFieldModel lastState, PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, TurnActionTypes typeOfActionToPerform, MoveInfo cardsAndPlayersInvolved) { BoolResponseBox result; #region Draw2State if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Draw_2_Cards) == 0) { //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played;//Action cards not playable at this phase //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played;//No cards playable at this phase //Just Say No card played by off turn player Statephase JustSayNoUsedByOpposition = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played; //Property card rearranging next state Statephase rearrangeProperties = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played;//No cards can be rearranged at this phase //Draw Statephase drawCardsAtTurnStart = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played;//Only action allowable at this phase Statephase discard = Statephase.Turn_Started_Draw_2_Cards; BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } #endregion Draw2State #region Draw5State else if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Draw_5_Cards) == 0) { //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played;//Action cards not playable at this phase //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played;//No cards playable at this phase //Just Say No card played by off turn player Statephase JustSayNoUsedByOpposition = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played; //Property card rearranging next state Statephase rearrangeProperties = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played;//No cards can be rearranged at this phase //Draw Statephase drawCardsAtTurnStart = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played;//Only action allowable at this phase Statephase discard = Statephase.Turn_Started_Draw_5_Cards; BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } #endregion Draw5State #region Turn Started Cards Drawn 0 Cards Played else if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Cards_Drawn_0_Cards_Played) == 0) { //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played_Ask_Just_Say_No;//Action cards not playable at this phase //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played;//No cards playable at this phase //Just Say No card played by off turn player Statephase JustSayNoUsedByOpposition = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played_Just_Say_No_Used_By_Oppostion_Ask_Player_On_Turn_Just_Say_No; //Property card rearranging next state Statephase rearrangeProperties = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played;//No cards can be rearranged at this phase //Draw Statephase discard = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played; Statephase drawCardsAtTurnStart = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played;//Only action allowable at this phase BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } #endregion Turn Started Cards Drawn 0 Cards Played #region 0 Cards Played Just Say Noable Card Played else if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Cards_Drawn_0_Cards_Played_Ask_Just_Say_No) == 0) { Statephase discard = Statephase.Invalid_Action_For_Turn; //Player used Just Say No Statephase JustSayNoUsedByOpposition = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played_Just_Say_No_Used_By_Oppostion_Ask_Player_On_Turn_Just_Say_No; /* //Player did not play just say no and is dealbreakered or sly dealed or forced dealed Statephase JustSayNoNotUsed = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played; //Player has to pay rent or Birthday or Debt Collector Statephase PayDebt = Statephase.Turn_Started_Cards_Drawn_1_Cards_Play */ //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played_Ask_Just_Say_No;//Action cards not playable at this phase //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played;//cards playable at this phase //Property card rearranging next state Statephase rearrangeProperties = Statephase.Invalid_Action_For_Turn;//cards can be rearranged at this phase //Draw Statephase drawCardsAtTurnStart = Statephase.Invalid_Action_For_Turn;//not allowable at this phase BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); //In this state players may be required to pay rent, birthday or debt collector money or use a just say no if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } #endregion 0 Cards Played Just Say Noable Card Played #region 0 Cards Played Just Say Noable Card Just Say No'd else if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Cards_Drawn_0_Cards_Played_Just_Say_No_Used_By_Oppostion_Ask_Player_On_Turn_Just_Say_No) == 0) { Statephase discard = Statephase.Invalid_Action_For_Turn; //Player used Just Say No Statephase JustSayNoUsedByOpposition = Statephase.Invalid_Action_For_Turn; /* //Player did not play just say no and is dealbreakered or sly dealed or forced dealed Statephase JustSayNoNotUsed = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played; //Player has to pay rent or Birthday or Debt Collector Statephase PayDebt = Statephase.Turn_Started_Cards_Drawn_1_Cards_Play */ //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played_Ask_Just_Say_No;//Action cards not playable at this phase except just say no //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played;//cards playable at this phase //Property card rearranging next state Statephase rearrangeProperties = Statephase.Invalid_Action_For_Turn;//cards can be rearranged at this phase //Draw Statephase drawCardsAtTurnStart = Statephase.Invalid_Action_For_Turn;//not allowable at this phase BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); //In this state players may be required to pay rent, birthday or debt collector money or use a just say no if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } #endregion 0 Cards Played Just Say Noable Card Just Say No'd #region 1 Card Played State else if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Cards_Drawn_1_Cards_Played) == 0) { //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played_Ask_Just_Say_No;//Action cards not playable at this phase //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Turn_Started_Cards_Drawn_2_Cards_Played;//cards playable at this phase //Just Say No card played by off turn player Statephase JustSayNoUsedByOpposition = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played_Just_Say_No_Used_By_Oppostion_Ask_Player_On_Turn_Just_Say_No; //Property card rearranging next state Statephase rearrangeProperties = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played;//cards can be rearranged at this phase //Draw Statephase drawCardsAtTurnStart = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played;//not allowable at this phase BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); Statephase discard = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played; if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } #endregion 1 Card Played State #region 1 Card Played Just Say Noable Card Played else if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Cards_Drawn_1_Cards_Played_Ask_Just_Say_No) == 0) { Statephase discard = Statephase.Invalid_Action_For_Turn; //Player used Just Say No Statephase JustSayNoUsedByOpposition = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played_Just_Say_No_Used_By_Oppostion_Ask_Player_On_Turn_Just_Say_No; /* //Player did not play just say no and is dealbreakered or sly dealed or forced dealed Statephase JustSayNoNotUsed = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played; //Player has to pay rent or Birthday or Debt Collector Statephase PayDebt = Statephase.Turn_Started_Cards_Drawn_1_Cards_Play */ //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played_Ask_Just_Say_No;//Action cards not playable at this phase //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Turn_Started_Cards_Drawn_2_Cards_Played;//cards playable at this phase //Property card rearranging next state Statephase rearrangeProperties = Statephase.Invalid_Action_For_Turn;//cards can be rearranged at this phase //Draw Statephase drawCardsAtTurnStart = Statephase.Invalid_Action_For_Turn;//not allowable at this phase BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); //In this state players may be required to pay rent, birthday or debt collector money or use a just say no if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } #endregion 1 Card Played Just Say Noable Card Played #region 1 Card Played Just Say Noable Card Just Say No'd else if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Cards_Drawn_1_Cards_Played_Just_Say_No_Used_By_Oppostion_Ask_Player_On_Turn_Just_Say_No) == 0) { Statephase discard = Statephase.Invalid_Action_For_Turn; //Player used Just Say No Statephase JustSayNoUsedByOpposition = Statephase.Invalid_Action_For_Turn; /* //Player did not play just say no and is dealbreakered or sly dealed or forced dealed Statephase JustSayNoNotUsed = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played; //Player has to pay rent or Birthday or Debt Collector Statephase PayDebt = Statephase.Turn_Started_Cards_Drawn_1_Cards_Play */ //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played_Ask_Just_Say_No;//Action cards not playable at this phase //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Turn_Started_Cards_Drawn_2_Cards_Played;//cards playable at this phase //Property card rearranging next state Statephase rearrangeProperties = Statephase.Invalid_Action_For_Turn;//cards can be rearranged at this phase //Draw Statephase drawCardsAtTurnStart = Statephase.Invalid_Action_For_Turn;//not allowable at this phase BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); //In this state players may be required to pay rent, birthday or debt collector money or use a just say no if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } #endregion 1 Card Played Just Say Noable Card Just Say No'd #region 2 Cards Played State else if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Cards_Drawn_2_Cards_Played) == 0) { //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Turn_Started_Cards_Drawn_2_Cards_Played_Ask_Just_Say_No;//Action cards playable at this phase //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Turn_Started_Cards_Drawn_3_Cards_Played_Swap_Properties_Or_End_Turn_Only;//cards playable at this phase //Just Say No card played by off turn player Statephase JustSayNoUsedByOpposition = Statephase.Turn_Started_Cards_Drawn_2_Cards_Played_Just_Say_No_Used_By_Oppostion_Ask_Player_On_Turn_Just_Say_No; //Property card rearranging next state Statephase rearrangeProperties = Statephase.Turn_Started_Cards_Drawn_2_Cards_Played;//cards can be rearranged at this phase //Draw Statephase drawCardsAtTurnStart = Statephase.Turn_Started_Cards_Drawn_2_Cards_Played;//not allowable at this phase BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); Statephase discard = Statephase.Turn_Started_Cards_Drawn_2_Cards_Played; if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } #endregion 2 Cards Played State #region 2 Cards Played State Just Say Noable Card Played else if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Cards_Drawn_2_Cards_Played_Ask_Just_Say_No) == 0) { Statephase discard = Statephase.Invalid_Action_For_Turn; //Player used Just Say No Statephase JustSayNoUsedByOpposition = Statephase.Turn_Started_Cards_Drawn_2_Cards_Played_Just_Say_No_Used_By_Oppostion_Ask_Player_On_Turn_Just_Say_No; /* //Player did not play just say no and is dealbreakered or sly dealed or forced dealed Statephase JustSayNoNotUsed = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played; //Player has to pay rent or Birthday or Debt Collector Statephase PayDebt = Statephase.Turn_Started_Cards_Drawn_1_Cards_Play */ //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Turn_Started_Cards_Drawn_2_Cards_Played_Ask_Just_Say_No;//Action cards not playable at this phase //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Turn_Started_Cards_Drawn_3_Cards_Played_Swap_Properties_Or_End_Turn_Only;//cards playable at this phase //Property card rearranging next state Statephase rearrangeProperties = Statephase.Invalid_Action_For_Turn;//cards can be rearranged at this phase //Draw Statephase drawCardsAtTurnStart = Statephase.Invalid_Action_For_Turn;//not allowable at this phase BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); //In this state players may be required to pay rent, birthday or debt collector money or use a just say no if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } #endregion 2 Cards Played State Just Say Noable Card Played #region 2 Cards Played State Just Say Noable Card just Say No'd else if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Cards_Drawn_2_Cards_Played_Just_Say_No_Used_By_Oppostion_Ask_Player_On_Turn_Just_Say_No) == 0) { Statephase discard = Statephase.Invalid_Action_For_Turn; //Player used Just Say No Statephase JustSayNoUsedByOpposition = Statephase.Invalid_Action_For_Turn; /* //Player did not play just say no and is dealbreakered or sly dealed or forced dealed Statephase JustSayNoNotUsed = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played; //Player has to pay rent or Birthday or Debt Collector Statephase PayDebt = Statephase.Turn_Started_Cards_Drawn_1_Cards_Play */ //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Turn_Started_Cards_Drawn_2_Cards_Played_Ask_Just_Say_No;//Action cards not playable at this phase except just say no //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Turn_Started_Cards_Drawn_3_Cards_Played_Swap_Properties_Or_End_Turn_Only;//cards playable at this phase //Property card rearranging next state Statephase rearrangeProperties = Statephase.Invalid_Action_For_Turn;//cards can be rearranged at this phase //Draw Statephase drawCardsAtTurnStart = Statephase.Invalid_Action_For_Turn;//not allowable at this phase BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); //In this state players may be required to pay rent, birthday or debt collector money or use a just say no if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } #endregion 2 Cards Played State Just Say Noable Card just Say No'd #region 3 Cards Played State else if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Cards_Drawn_3_Cards_Played_Swap_Properties_Or_End_Turn_Only) == 0) { //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Invalid_Action_For_Turn;//Action cards not playable at this phase //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Invalid_Action_For_Turn;//cards not playable at this phase //Just Say No card played by off turn player Statephase JustSayNoUsedByOpposition = Statephase.Invalid_Action_For_Turn; //Property card rearranging next state Statephase rearrangeProperties = Statephase.Turn_Started_Cards_Drawn_3_Cards_Played_Swap_Properties_Or_End_Turn_Only;//cards can be rearranged at this phase //Draw Statephase drawCardsAtTurnStart = Statephase.Invalid_Action_For_Turn;//not allowable at this phase Statephase discard = Statephase.Turn_Started_Cards_Drawn_3_Cards_Played_Swap_Properties_Or_End_Turn_Only; BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } #endregion 3 Cards Played State #region Too many cards in hand at end of turn states else if (currentState.currentPhase.CompareTo(Statephase.Turn_Ended_12_Cards_In_Hand_Discard_5_Cards) == 0) { //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Turn_Ended_12_Cards_In_Hand_Discard_5_Cards; //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Turn_Ended_12_Cards_In_Hand_Discard_5_Cards; //Just Say No card played by off turn player Statephase JustSayNoUsedByOpposition = Statephase.Turn_Ended_12_Cards_In_Hand_Discard_5_Cards; //Property card rearranging next state Statephase rearrangeProperties = Statephase.Turn_Ended_12_Cards_In_Hand_Discard_5_Cards; //Draw Statephase drawCardsAtTurnStart = Statephase.Turn_Ended_12_Cards_In_Hand_Discard_5_Cards;//not allowable at this phase //Discard Statephase discard = Statephase.Turn_Ended_11_Cards_In_Hand_Discard_4_Cards; BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } else if (currentState.currentPhase.CompareTo(Statephase.Turn_Ended_11_Cards_In_Hand_Discard_4_Cards) == 0) { //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Turn_Ended_11_Cards_In_Hand_Discard_4_Cards; //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Turn_Ended_11_Cards_In_Hand_Discard_4_Cards; //Just Say No card played by off turn player Statephase JustSayNoUsedByOpposition = Statephase.Turn_Ended_11_Cards_In_Hand_Discard_4_Cards; //Property card rearranging next state Statephase rearrangeProperties = Statephase.Turn_Ended_11_Cards_In_Hand_Discard_4_Cards; //Draw Statephase drawCardsAtTurnStart = Statephase.Turn_Ended_11_Cards_In_Hand_Discard_4_Cards;//not allowable at this phase //Discard Statephase discard = Statephase.Turn_Ended_10_Cards_In_Hand_Discard_3_Cards; BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } else if (currentState.currentPhase.CompareTo(Statephase.Turn_Ended_10_Cards_In_Hand_Discard_3_Cards) == 0) { //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Turn_Ended_10_Cards_In_Hand_Discard_3_Cards; //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Turn_Ended_10_Cards_In_Hand_Discard_3_Cards; //Just Say No card played by off turn player Statephase JustSayNoUsedByOpposition = Statephase.Turn_Ended_10_Cards_In_Hand_Discard_3_Cards; //Property card rearranging next state Statephase rearrangeProperties = Statephase.Turn_Ended_10_Cards_In_Hand_Discard_3_Cards; //Draw Statephase drawCardsAtTurnStart = Statephase.Turn_Ended_10_Cards_In_Hand_Discard_3_Cards;//not allowable at this phase //Discard Statephase discard = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards; BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } else if (currentState.currentPhase.CompareTo(Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards) == 0) { //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards; //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards; //Just Say No card played by off turn player Statephase JustSayNoUsedByOpposition = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards; //Property card rearranging next state Statephase rearrangeProperties = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards; //Draw Statephase drawCardsAtTurnStart = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards;//not allowable at this phase //Discard Statephase discard = Statephase.Turn_Ended_8_Cards_In_Hand_Discard_1_Card; BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } else if (currentState.currentPhase.CompareTo(Statephase.Turn_Ended_8_Cards_In_Hand_Discard_1_Card) == 0) { //Action card that can be just say no carded next state Statephase justSayNoAble = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards; //Any move that plays a card excluding justSayNo move next state Statephase notJustSayNoAble = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards; //Just Say No card played by off turn player Statephase JustSayNoUsedByOpposition = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards; //Property card rearranging next state Statephase rearrangeProperties = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards; //Draw Statephase drawCardsAtTurnStart = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards;//not allowable at this phase //Discard Statephase discard = Statephase.Turn_Ended_7_Or_Less_Cards_In_Hand_Setup_NextPlayer; BoolResponseBox isMoveTypeAllowableAtCurrentPhase = checkIfMoveAllowedAtThisState(typeOfActionToPerform, playerPerformingAction, currentState); if (isMoveTypeAllowableAtCurrentPhase.success) { //type of move is allowable at this point for this player. Check if move is doable ex is a set stealable result = doAppropriateAction(lastState, currentState, nextState, playerPerformingAction, typeOfActionToPerform, justSayNoAble, notJustSayNoAble, rearrangeProperties, drawCardsAtTurnStart, JustSayNoUsedByOpposition, cardsAndPlayersInvolved, discard); return result;//True if action performed, False if not } else { //No other actionTypes are allowable in this state return new BoolResponseBox(false, "Player:" + playerPerformingAction.name + " is not able to perform " + typeOfActionToPerform + " at this state:" + currentState.currentPhase.ToString()); } } #endregion Too many cards in hand at end of turn states else if (currentState.currentPhase.CompareTo(Statephase.Game_Over) == 0) { return new BoolResponseBox(false, "Game is over, move not possible"); } else { return new BoolResponseBox(false, "Game is in an invalid state"); } }
public bool isActionAllowedForPlayer(TurnActionTypes turnActionToDo, Guid playerGuid, PlayFieldModel currentState) { throw new NotImplementedException(); }
public bool playPropertyCardToNewSet(Guid gameGuid, bool isOrientedUp, Guid playerGuid, Guid gameStateActionShouldBeAppliedOnGuid, TurnActionTypes actionType, int propertyCardID) { PlayFieldModel lastState = getPreviousState(); PlayFieldModel currentState = getCurrentState(); PlayFieldModel nextState = null; PlayerModel playerModelAtCurrentState = move.getPlayerModel(playerGuid, currentState); PropertyCard playedcard = monopolyDeal.deck.getCardByID(propertyCardID) as PropertyCard; if (playedcard != null && checkIfCardInHand(playedcard, playerModelAtCurrentState) != null) { MoveInfo playPropertyCardFromHand = new MoveInfo(); playPropertyCardFromHand.playerWhoseTurnItIs = playerGuid; playPropertyCardFromHand.playerMakingMove = playerGuid; playPropertyCardFromHand.moveBeingMade = TurnActionTypes.PlayPropertyCardFromHand; playPropertyCardFromHand.idOfCardBeingUsed = propertyCardID; playPropertyCardFromHand.isPropertyToPlayOrientedUp = isOrientedUp; playPropertyCardFromHand.addPropertyToPlayToExistingSet = false;//Add to new set BoolResponseBox result = move.evaluateMove(lastState, currentState, nextState, playerModelAtCurrentState, playPropertyCardFromHand.moveBeingMade, playPropertyCardFromHand); return(result.success); } return(new BoolResponseBox(false, "Selected Card is not in players hand or is not a property card").success); }
public bool doAction(Guid gameGuid, Guid playerGuid, Guid gameStateActionShouldBeAppliedOnGuid, TurnActionTypes actionType) { throw new NotSupportedException(); }
public bool playActionCardPassGo(int passGoCardID, Guid serverGuid, Guid playerGuid, Guid playfieldModelInstanceGuid, TurnActionTypes turnActionTypes) { Card cardInHandToBePlayed = monopolyDeal.deck.getCardByID(passGoCardID); //Get the reference to the players playerModel in the current PlayFieldModel PlayerModel player = getPlayerModel(playerGuid, serverGuid, playfieldModelInstanceGuid); //Get the reference to the Card in the current PlayFieldModel if (cardInHandToBePlayed != null && cardInHandToBePlayed is ActionCard && ((ActionCard)cardInHandToBePlayed).actionType.CompareTo(ActionCardAction.PassGo) == 0) { Card card = removeCardFromHand(cardInHandToBePlayed, player); if (card != null) { ActionCard actionCard = card as ActionCard; player.hand.addCardToHand(currentPlayFieldModel.drawPile.drawcard()); player.hand.addCardToHand(currentPlayFieldModel.drawPile.drawcard()); //Change state on success //Put card in discard pile getCurrentPlayFieldModel().playpile.playCardOnPile(card); updateState(TurnActionTypes.PlayActionCard, ActionCardAction.PassGo, getCurrentPlayFieldModel(), player.guid); return true; } return false; } else { //Card not in players hand, can't be discarded not an actioncard return false; } }
public bool playDebtCollector(int debtCollectorCardID, Guid guid, Guid guid_2, Guid guid_3, Guid guid_4, TurnActionTypes turnActionTypes) { throw new NotImplementedException(); }
private void updateStateForPropertyPlayedToSet(TurnActionTypes actionToAttemptToPerform, PlayFieldModel currentState, Guid playerWhoPerformedActionGuid, PlayerModel playerWhoPerformedAction, PlayFieldModel newState) { throw new NotImplementedException(); }
public bool isActionAllowedForPlayer(TurnActionTypes turnActionToDo, Guid playerGuid, PlayFieldModel currentState) { TurnActionTypes tAT = turnActionToDo; PlayerModel playerAttemptingAction = getPlayerModel(playerGuid, monopolyDeal.MONOPOLY_DEAL_GAME_GUID, currentState.thisPlayFieldModelInstanceGuid); if (playerAttemptingAction != null) { foreach (TurnActionTypes t in playerAttemptingAction.actionsCurrentlyAllowed) { if (t.CompareTo(tAT) == 0) { //Action is in allowable list for player return true; } } } return false; //Action not allowable }
private void updateStateActionCardPassGo(TurnActionTypes actionToAttemptToPerform, PlayFieldModel currentState, Guid playerWhoPerformedAction, PlayerModel player, PlayFieldModel newState) { //action is valid for player at this time List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); onTurn = setAllowableActionsOnTurn(onTurn, newState); //updateStateForPropertyPlayedToSet(actionToAttemptToPerform, currentState, playerWhoPerformedAction, player, newState); //Change phase updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); }
public bool playPropertyCardToNewSet(Guid gameGuid, bool isOrientedUp, Guid playerGuid, Guid gameStateActionShouldBeAppliedOnGuid, TurnActionTypes actionType, int propertyCardID) { PlayFieldModel lastState = getPreviousState(); PlayFieldModel currentState = getCurrentState(); PlayFieldModel nextState = null; PlayerModel playerModelAtCurrentState = move.getPlayerModel(playerGuid, currentState); PropertyCard playedcard = monopolyDeal.deck.getCardByID(propertyCardID) as PropertyCard; if (playedcard != null && checkIfCardInHand(playedcard, playerModelAtCurrentState) != null) { MoveInfo playPropertyCardFromHand = new MoveInfo(); playPropertyCardFromHand.playerWhoseTurnItIs = playerGuid; playPropertyCardFromHand.playerMakingMove = playerGuid; playPropertyCardFromHand.moveBeingMade = TurnActionTypes.PlayPropertyCardFromHand; playPropertyCardFromHand.idOfCardBeingUsed = propertyCardID; playPropertyCardFromHand.isPropertyToPlayOrientedUp = isOrientedUp; playPropertyCardFromHand.addPropertyToPlayToExistingSet = false;//Add to new set BoolResponseBox result = move.evaluateMove(lastState, currentState, nextState, playerModelAtCurrentState, playPropertyCardFromHand.moveBeingMade, playPropertyCardFromHand); return result.success; } return new BoolResponseBox(false, "Selected Card is not in players hand or is not a property card").success; }
public bool playActionCardPassGo(int passGoCardID, Guid serverGuid, Guid playerGuid, Guid playfieldModelInstanceGuid, TurnActionTypes turnActionTypes) { PlayFieldModel lastState = getPreviousState(); PlayFieldModel currentState = getCurrentState(); PlayFieldModel nextState = null; PlayerModel playerModelAtCurrentState = move.getPlayerModel(playerGuid, currentState); ActionCard playedPassGo = monopolyDeal.deck.getCardByID(passGoCardID) as ActionCard; if (playedPassGo != null && checkIfCardInHand(playedPassGo, playerModelAtCurrentState) != null) { MoveInfo playPassGo = new MoveInfo(); playPassGo.playerWhoseTurnItIs = playerGuid; playPassGo.playerMakingMove = playerGuid; playPassGo.moveBeingMade = TurnActionTypes.PlayActionCard; playPassGo.idOfCardBeingUsed = passGoCardID; playPassGo.actionCardActionType = ActionCardAction.PassGo; BoolResponseBox result = move.evaluateMove(lastState, currentState, nextState, playerModelAtCurrentState, playPassGo.moveBeingMade, playPassGo); return result.success; } return new BoolResponseBox(false, "Selected Card is not in players hand or is not a Action Card").success; }
public TurnActionModel(List<Guid> playerGuidsP, Guid serverGuidP, Guid currentPlayFieldModelGuidP, Guid guidOfThisTurnAction, List<TurnActionTypes> typesOfActionsAllowedForPlayersListed, TurnActionTypes typeOfActionToTake, bool actionTaken) { //GameStateManager generates a TurnActionModel for each PlayFieldModel //All players recieve the field and check if the turnActionModel has their guid //if it has their guid it is their turn //The player on their turn fills a subclass of TurnActionModel for the move they want to make using the information in this TurnActionModel //The player then sends that back to the service and GameStateManager does the move playerGuids = playerGuidsP;//List of players who can use the actions listed serverGuid = serverGuidP; currentPlayFieldModelGuid = currentPlayFieldModelGuidP; thisTurnactionGuid = guidOfThisTurnAction;//server side generated typesOfActionListedPlayersCanTake = typesOfActionsAllowedForPlayersListed; this.typeOfActionToTake = typeOfActionToTake; this.actionTaken = actionTaken; }
public bool playPropertyCardToNewSet(Guid gameGuid, bool isOrientedUp, Guid playerGuid, Guid gameStateActionShouldBeAppliedOnGuid, TurnActionTypes actionType, int propertyCardID) { //Get CurrentPlayFieldModelState currentPlayFieldModel = getCurrentPlayFieldModel(); PlayerModel player = getPlayerByGuid(playerGuid, currentPlayFieldModel); if (checkIfActionIsForThisState(actionType, gameStateActionShouldBeAppliedOnGuid, playerGuid, gameGuid)) { if (actionType.CompareTo(TurnActionTypes.PlayPropertyCard_New_Set) == 0) { foreach (Card c in player.hand.cardsInHand) { if (c.cardID == propertyCardID && c is PropertyCard) { Card card = removeCardFromHand(c, player); if (card != null) { PropertyCard cP = c as PropertyCard; PropertyCardSet ps = new PropertyCardSet(cP); cP.setPropertyColor(isOrientedUp); player.propertySets.addSet(ps); updateState(TurnActionTypes.PlayPropertyCard_New_Set, ActionCardAction.NotAnActionCard, currentPlayFieldModel, player.guid); return true; } } } } } return false; }
private bool checkIfActionIsForThisState(TurnActionTypes ta, Guid stateGuid, Guid playerGuid, Guid gameGuid) { PlayerModel player = getPlayerModel(playerGuid, gameGuid, stateGuid); foreach (TurnActionTypes t in player.actionsCurrentlyAllowed) { if (t.CompareTo(ta) == 0) { return true; } } return false; }
public bool playActionCardPassGo(int passGoCardID, Guid serverGuid, Guid playerGuid, Guid playfieldModelInstanceGuid, TurnActionTypes turnActionTypes) { PlayFieldModel lastState = getPreviousState(); PlayFieldModel currentState = getCurrentState(); PlayFieldModel nextState = null; PlayerModel playerModelAtCurrentState = move.getPlayerModel(playerGuid, currentState); ActionCard playedPassGo = monopolyDeal.deck.getCardByID(passGoCardID) as ActionCard; if (playedPassGo != null && checkIfCardInHand(playedPassGo, playerModelAtCurrentState) != null) { MoveInfo playPassGo = new MoveInfo(); playPassGo.playerWhoseTurnItIs = playerGuid; playPassGo.playerMakingMove = playerGuid; playPassGo.moveBeingMade = TurnActionTypes.PlayActionCard; playPassGo.idOfCardBeingUsed = passGoCardID; playPassGo.actionCardActionType = ActionCardAction.PassGo; BoolResponseBox result = move.evaluateMove(lastState, currentState, nextState, playerModelAtCurrentState, playPassGo.moveBeingMade, playPassGo); return(result.success); } return(new BoolResponseBox(false, "Selected Card is not in players hand or is not a Action Card").success); }
private void updateState(TurnActionTypes actionToAttemptToPerform, ActionCardAction actionCardType, PlayFieldModel currentState, Guid playerWhoPerformedAction) { PlayerModel player = getPlayerByGuid(playerWhoPerformedAction, currentState); PlayFieldModel newState = copyPlayFieldModel(currentState); //List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); //List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); #region draw2state //draw 2 on turn start state if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Draw_2_Cards) == 0) { if (actionToAttemptToPerform.CompareTo(TurnActionTypes.drawTwoCardsAtStartOfTurn) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time //Could perform the action here instead, for now just change the phase of the state newState.currentPhase = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played; //player has drawn their two cards, Now can play up to three cards on their turn List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); onTurn = setAllowableActionsOnTurn(onTurn, newState); updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } } #endregion draw2state #region draw5state //draw 5 on turn start state else if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Draw_5_Cards) == 0) { if (actionToAttemptToPerform.CompareTo(TurnActionTypes.drawFiveCardsAtStartOfTurn) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time //Could perform the action here instead, for now just change the phase of the state newState.currentPhase = Statephase.Turn_Started_Cards_Drawn_0_Cards_Played; //player has drawn their five cards as they started the turn with zero cards, Now can play up to three cards on their turn List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); onTurn = setAllowableActionsOnTurn(onTurn, newState); updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } } #endregion draw5state #region Turn_Started_Cards_Drawn_0_Cards_Played //draw 2 on turn start state else if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Cards_Drawn_0_Cards_Played) == 0) { #region bankActionCard if (actionToAttemptToPerform.CompareTo(TurnActionTypes.BankActionCard) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time //Could perform the action here instead, for now just change the phase of the state //Not an action so cant be just say no'd //Change phase newState.currentPhase = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played; //player has drawn their two cards, Now can play up to three cards on their turn on List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); onTurn = setAllowableActionsOnTurn(onTurn, newState); updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } #endregion bankActionCard #region endTurn else if (actionToAttemptToPerform.CompareTo(TurnActionTypes.EndTurn) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); //Could perform the action here instead, for now just change the phase of the state //Not an action so cant be just say no'd //Change phase switch (player.hand.cardsInHand.Count) { case 8: { newState.currentPhase = Statephase.Turn_Ended_8_Cards_In_Hand_Discard_1_Card; onTurn.Add(TurnActionTypes.Discard_1_Card); break; } case 9: { newState.currentPhase = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards; onTurn.Add(TurnActionTypes.Discard_1_Card); break; } case 10: { newState.currentPhase = Statephase.Turn_Ended_10_Cards_In_Hand_Discard_3_Cards; onTurn.Add(TurnActionTypes.Discard_1_Card); break; } case 11: { newState.currentPhase = Statephase.Turn_Ended_11_Cards_In_Hand_Discard_4_Cards; onTurn.Add(TurnActionTypes.Discard_1_Card); break; } case 12: { newState.currentPhase = Statephase.Turn_Ended_12_Cards_In_Hand_Discard_5_Cards; onTurn.Add(TurnActionTypes.Discard_1_Card); break; } default: { newState.currentPhase = Statephase.Turn_Ended_7_Or_Less_Cards_In_Hand_Setup_NextPlayer; setNextPlayerOnTurn(newState); if (getPlayerByGuid(newState.guidOfPlayerWhosTurnItIs, newState).hand.cardsInHand.Count == 0) { //Player has 0 cards draws 5 on turn start instead of 2 newState.currentPhase = Statephase.Turn_Started_Draw_5_Cards; onTurn.Add(TurnActionTypes.drawFiveCardsAtStartOfTurn); updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } else { newState.currentPhase = Statephase.Turn_Started_Draw_2_Cards; onTurn.Add(TurnActionTypes.drawTwoCardsAtStartOfTurn); updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } break; } } updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } #endregion endTurn #region playPropertyToNewSet else if (actionToAttemptToPerform.CompareTo(TurnActionTypes.PlayPropertyCard_New_Set) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); onTurn = setAllowableActionsOnTurn(onTurn, newState); //updateStateForPropertyPlayedToSet(actionToAttemptToPerform, currentState, playerWhoPerformedAction, player, newState); //Change phase newState.currentPhase = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played; updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } #endregion playPropertyToNewSet //Play Action #region Actions unable to be just say no carded #region pass Go else if (actionToAttemptToPerform.CompareTo(TurnActionTypes.PlayActionCard) == 0 && actionCardType.CompareTo(ActionCardAction.PassGo) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { newState.currentPhase = Statephase.Turn_Started_Cards_Drawn_1_Cards_Played; updateStateActionCardPassGo(actionToAttemptToPerform, currentState, playerWhoPerformedAction, player, newState); } } #endregion pass Go #endregion Actions unable to be just say no carded } #endregion Turn_Started_Cards_Drawn_0_Cards_Played #region Turn_Started_Cards_Drawn_1_Cards_Played else if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Cards_Drawn_1_Cards_Played) == 0) { #region bankActionCard if (actionToAttemptToPerform.CompareTo(TurnActionTypes.BankActionCard) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time //Could perform the action here instead, for now just change the phase of the state //Not an action so cant be just say no'd //Change phase newState.currentPhase = Statephase.Turn_Started_Cards_Drawn_2_Cards_Played; //player has drawn their two cards, Now can play up to three cards on their turn List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); onTurn = setAllowableActionsOnTurn(onTurn, newState); updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } #endregion bankActionCard #region endTurn else if (actionToAttemptToPerform.CompareTo(TurnActionTypes.EndTurn) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); //Could perform the action here instead, for now just change the phase of the state //Not an action so cant be just say no'd //Change phase switch (player.hand.cardsInHand.Count) { case 8: { newState.currentPhase = Statephase.Turn_Ended_8_Cards_In_Hand_Discard_1_Card; onTurn.Add(TurnActionTypes.Discard_1_Card); break; } case 9: { newState.currentPhase = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards; onTurn.Add(TurnActionTypes.Discard_1_Card); break; } case 10: { newState.currentPhase = Statephase.Turn_Ended_10_Cards_In_Hand_Discard_3_Cards; onTurn.Add(TurnActionTypes.Discard_1_Card); break; } case 11: { newState.currentPhase = Statephase.Turn_Ended_11_Cards_In_Hand_Discard_4_Cards; onTurn.Add(TurnActionTypes.Discard_1_Card); break; } case 12: { newState.currentPhase = Statephase.Turn_Ended_12_Cards_In_Hand_Discard_5_Cards; onTurn.Add(TurnActionTypes.Discard_1_Card); break; } default: { newState.currentPhase = Statephase.Turn_Ended_7_Or_Less_Cards_In_Hand_Setup_NextPlayer; setNextPlayerOnTurn(newState); if (getPlayerByGuid(newState.guidOfPlayerWhosTurnItIs, newState).hand.cardsInHand.Count == 0) { //Player has 0 cards draws 5 on turn start instead of 2 newState.currentPhase = Statephase.Turn_Started_Draw_5_Cards; onTurn.Add(TurnActionTypes.drawFiveCardsAtStartOfTurn); } else { newState.currentPhase = Statephase.Turn_Started_Draw_2_Cards; onTurn.Add(TurnActionTypes.drawTwoCardsAtStartOfTurn); } break; } } updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } #endregion endTurn #region playPropertyToNewSet else if (actionToAttemptToPerform.CompareTo(TurnActionTypes.PlayPropertyCard_New_Set) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); onTurn = setAllowableActionsOnTurn(onTurn, newState); //updateStateForPropertyPlayedToSet(actionToAttemptToPerform, currentState, playerWhoPerformedAction, player, newState); //Change phase newState.currentPhase = Statephase.Turn_Started_Cards_Drawn_2_Cards_Played; updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } #endregion playPropertyToNewSet //Play Action #region Actions unable to be just say no carded #region pass Go else if (actionToAttemptToPerform.CompareTo(TurnActionTypes.PlayActionCard) == 0 && actionCardType.CompareTo(ActionCardAction.PassGo) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { newState.currentPhase = Statephase.Turn_Started_Cards_Drawn_2_Cards_Played; updateStateActionCardPassGo(actionToAttemptToPerform, currentState, playerWhoPerformedAction, player, newState); } } #endregion pass Go #endregion Actions unable to be just say no carded } #endregion Turn_Started_Cards_Drawn_1_Cards_Played #region Turn_Started_Cards_Drawn_2_Cards_Played else if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Cards_Drawn_2_Cards_Played) == 0) { //Actions that can be taken on this phase #region bankActionCard if (actionToAttemptToPerform.CompareTo(TurnActionTypes.BankActionCard) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time //Could perform the action here instead, for now just change the phase of the state //Not an action so cant be just say no'd //Change phase newState.currentPhase = Statephase.Turn_Started_Cards_Drawn_3_Cards_Played_Swap_Properties_Or_End_Turn_Only; //player has drawn their two cards, Now can play up to three cards on their turn List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); onTurn.Add(TurnActionTypes.SwitchAroundPlayedProperties); onTurn.Add(TurnActionTypes.EndTurn); updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } #endregion bankActionCard #region endTurn else if (actionToAttemptToPerform.CompareTo(TurnActionTypes.EndTurn) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); //Could perform the action here instead, for now just change the phase of the state //Not an action so cant be just say no'd //Change phase switch (player.hand.cardsInHand.Count) { case 8: { newState.currentPhase = Statephase.Turn_Ended_8_Cards_In_Hand_Discard_1_Card; onTurn.Add(TurnActionTypes.Discard_1_Card); break; } case 9: { newState.currentPhase = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards; onTurn.Add(TurnActionTypes.Discard_1_Card); break; } case 10: { newState.currentPhase = Statephase.Turn_Ended_10_Cards_In_Hand_Discard_3_Cards; onTurn.Add(TurnActionTypes.Discard_1_Card); break; } case 11: { newState.currentPhase = Statephase.Turn_Ended_11_Cards_In_Hand_Discard_4_Cards; onTurn.Add(TurnActionTypes.Discard_1_Card); break; } case 12: { newState.currentPhase = Statephase.Turn_Ended_12_Cards_In_Hand_Discard_5_Cards; onTurn.Add(TurnActionTypes.Discard_1_Card); break; } default: { newState.currentPhase = Statephase.Turn_Ended_7_Or_Less_Cards_In_Hand_Setup_NextPlayer; setNextPlayerOnTurn(newState); if (getPlayerByGuid(newState.guidOfPlayerWhosTurnItIs, newState).hand.cardsInHand.Count == 0) { //Player has 0 cards draws 5 on turn start instead of 2 newState.currentPhase = Statephase.Turn_Started_Draw_5_Cards; onTurn.Add(TurnActionTypes.drawFiveCardsAtStartOfTurn); } else { newState.currentPhase = Statephase.Turn_Started_Draw_2_Cards; onTurn.Add(TurnActionTypes.drawTwoCardsAtStartOfTurn); } break; } } updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } #endregion endTurn #region playPropertyToNewSet else if (actionToAttemptToPerform.CompareTo(TurnActionTypes.PlayPropertyCard_New_Set) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); onTurn.Add(TurnActionTypes.SwitchAroundPlayedProperties); onTurn.Add(TurnActionTypes.EndTurn); //onTurn = setAllowableActionsOnTurn(onTurn, newState); //updateStateForPropertyPlayedToSet(actionToAttemptToPerform, currentState, playerWhoPerformedAction, player, newState); //Change phase newState.currentPhase = Statephase.Turn_Started_Cards_Drawn_3_Cards_Played_Swap_Properties_Or_End_Turn_Only; updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } #endregion playPropertyToNewSet //Play Action #region Actions unable to be just say no carded #region pass Go else if (actionToAttemptToPerform.CompareTo(TurnActionTypes.PlayActionCard) == 0 && actionCardType.CompareTo(ActionCardAction.PassGo) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); onTurn.Add(TurnActionTypes.SwitchAroundPlayedProperties); onTurn.Add(TurnActionTypes.EndTurn); newState.currentPhase = Statephase.Turn_Started_Cards_Drawn_3_Cards_Played_Swap_Properties_Or_End_Turn_Only; updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } #endregion pass Go #endregion Actions unable to be just say no carded } #endregion Turn_Started_Cards_Drawn_2_Cards_Played #region Turn_Started_Cards_Drawn_3_Cards_Played_Swap_Properties_Or_End_Turn_Only //draw 2 on turn start state else if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Cards_Drawn_3_Cards_Played_Swap_Properties_Or_End_Turn_Only) == 0) { #region endTurn if (actionToAttemptToPerform.CompareTo(TurnActionTypes.EndTurn) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); //Could perform the action here instead, for now just change the phase of the state //Not an action so cant be just say no'd //Change phase switch (player.hand.cardsInHand.Count) { case 8: { newState.currentPhase = Statephase.Turn_Ended_8_Cards_In_Hand_Discard_1_Card; onTurn.Add(TurnActionTypes.Discard_1_Card); break; } case 9: { newState.currentPhase = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards; onTurn.Add(TurnActionTypes.Discard_1_Card); //Replace with Discard_2_Cards when discarding 2 cards at a time is supported break; } case 10: { newState.currentPhase = Statephase.Turn_Ended_10_Cards_In_Hand_Discard_3_Cards; onTurn.Add(TurnActionTypes.Discard_1_Card);//Replace with Discard_3_Cards when discarding 2 cards at a time is supported break; } case 11: { newState.currentPhase = Statephase.Turn_Ended_11_Cards_In_Hand_Discard_4_Cards; onTurn.Add(TurnActionTypes.Discard_1_Card);//Replace with Discard_4_Cards when discarding 2 cards at a time is supported break; } case 12: { newState.currentPhase = Statephase.Turn_Ended_12_Cards_In_Hand_Discard_5_Cards; onTurn.Add(TurnActionTypes.Discard_1_Card);//Replace with Discard_5_Cards when discarding 2 cards at a time is supported break; } default: { newState.currentPhase = Statephase.Turn_Ended_7_Or_Less_Cards_In_Hand_Setup_NextPlayer; setNextPlayerOnTurn(newState); if (getPlayerByGuid(newState.guidOfPlayerWhosTurnItIs, newState).hand.cardsInHand.Count == 0) { //Player has 0 cards draws 5 on turn start instead of 2 newState.currentPhase = Statephase.Turn_Started_Draw_5_Cards; onTurn.Add(TurnActionTypes.drawFiveCardsAtStartOfTurn); } else { newState.currentPhase = Statephase.Turn_Started_Draw_2_Cards; onTurn.Add(TurnActionTypes.drawTwoCardsAtStartOfTurn); } break; } } updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } #endregion endTurn //Play Action } #endregion Turn_Started_Cards_Drawn_3_Cards_Played_Swap_Properties_Or_End_Turn_Only #region Turn_Ended_12_Cards_In_Hand_Discard_5_Cards else if (currentState.currentPhase.CompareTo(Statephase.Turn_Ended_12_Cards_In_Hand_Discard_5_Cards) == 0) { #region discard1Card if (actionToAttemptToPerform.CompareTo(TurnActionTypes.Discard_1_Card) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time //Could perform the action here instead, for now just change the phase of the state //Not an action so cant be just say no'd //Change phase newState.currentPhase = Statephase.Turn_Ended_11_Cards_In_Hand_Discard_4_Cards; //player has drawn their two cards, Now can play up to three cards on their turn List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); onTurn = setAllowableActionsOnTurn(onTurn, newState); updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } #endregion discard1Card } #endregion Turn_Ended_12_Cards_In_Hand_Discard_5_Cards #region Turn_Ended_11_Cards_In_Hand_Discard_4_Cards else if (currentState.currentPhase.CompareTo(Statephase.Turn_Ended_11_Cards_In_Hand_Discard_4_Cards) == 0) { #region discard1Card if (actionToAttemptToPerform.CompareTo(TurnActionTypes.Discard_1_Card) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time //Could perform the action here instead, for now just change the phase of the state //Not an action so cant be just say no'd //Change phase newState.currentPhase = Statephase.Turn_Ended_10_Cards_In_Hand_Discard_3_Cards; //player has drawn their two cards, Now can play up to three cards on their turn List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); onTurn = setAllowableActionsOnTurn(onTurn, newState); updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } #endregion discard1Card } #endregion Turn_Ended_11_Cards_In_Hand_Discard_4_Cards #region Turn_Ended_10_Cards_In_Hand_Discard_3_Cards else if (currentState.currentPhase.CompareTo(Statephase.Turn_Ended_10_Cards_In_Hand_Discard_3_Cards) == 0) { #region discard1Card if (actionToAttemptToPerform.CompareTo(TurnActionTypes.Discard_1_Card) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time //Could perform the action here instead, for now just change the phase of the state //Not an action so cant be just say no'd //Change phase newState.currentPhase = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards; //player has drawn their two cards, Now can play up to three cards on their turn List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); onTurn = setAllowableActionsOnTurn(onTurn, newState); updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } #endregion discard1Card } #endregion Turn_Ended_10_Cards_In_Hand_Discard_3_Cards #region Turn_Ended_9_Cards_In_Hand_Discard_2_Cards else if (currentState.currentPhase.CompareTo(Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards) == 0) { #region discard1Card if (actionToAttemptToPerform.CompareTo(TurnActionTypes.Discard_1_Card) == 0) { //Move was a valid move at current state //Check if move is valid for player if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time //Could perform the action here instead, for now just change the phase of the state //Not an action so cant be just say no'd //Change phase newState.currentPhase = Statephase.Turn_Ended_8_Cards_In_Hand_Discard_1_Card; //player has drawn their two cards, Now can play up to three cards on their turn List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); onTurn = setAllowableActionsOnTurn(onTurn, newState); updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } #endregion discard1Card } #endregion Turn_Ended_9_Cards_In_Hand_Discard_2_Cards #region Turn_Ended_8_Cards_In_Hand_Discard_1_Card else if (currentState.currentPhase.CompareTo(Statephase.Turn_Ended_8_Cards_In_Hand_Discard_1_Card) == 0) { #region discard1Card if (actionToAttemptToPerform.CompareTo(TurnActionTypes.Discard_1_Card) == 0) { //Move was a valid move at current state //Check if move is valid for player List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>(); List<TurnActionTypes> onTurn = new List<TurnActionTypes>(); if (isActionAllowedForPlayer(actionToAttemptToPerform, playerWhoPerformedAction, currentState)) { //action is valid for player at this time //Could perform the action here instead, for now just change the phase of the state //Not an action so cant be just say no'd //Change phase newState.currentPhase = Statephase.Turn_Ended_7_Or_Less_Cards_In_Hand_Setup_NextPlayer; setNextPlayerOnTurn(newState); if (getPlayerByGuid(newState.guidOfPlayerWhosTurnItIs, newState).hand.cardsInHand.Count == 0) { //Player has 0 cards draws 5 on turn start instead of 2 newState.currentPhase = Statephase.Turn_Started_Draw_5_Cards; onTurn.Add(TurnActionTypes.drawFiveCardsAtStartOfTurn); } else { newState.currentPhase = Statephase.Turn_Started_Draw_2_Cards; onTurn.Add(TurnActionTypes.drawTwoCardsAtStartOfTurn); } //player has drawn their two cards, Now can play up to three cards on their turn //onTurn = setAllowableActionsOnTurn(onTurn, newState); updateAllowableStates(newState, notOnTurn, onTurn, newState.guidOfPlayerWhosTurnItIs); } } #endregion discard1Card } #endregion Turn_Ended_8_Cards_In_Hand_Discard_1_Card }
/// <summary> /// Determines if a move is valid for the current player and state /// </summary> /// <param name="turnActionToDo"></param> /// <param name="player"></param> /// <param name="currentState"></param> /// <returns></returns> private BoolResponseBox checkIfMoveAllowedAtThisState(TurnActionTypes turnActionToDo, PlayerModel player, PlayFieldModel currentState) { TurnActionTypes tAT = turnActionToDo; PlayerModel playerAttemptingAction = player; if (monopolyDeal.gameOver) { return new BoolResponseBox(false, "Can not perform action as game is over"); } if (playerAttemptingAction != null) { foreach (TurnActionTypes t in playerAttemptingAction.actionsCurrentlyAllowed) { if (t.CompareTo(tAT) == 0) { //Action is in allowable list for player return new BoolResponseBox(true, player.name + " is allowed to :" + turnActionToDo.ToString() + " at current phase"); } } } return new BoolResponseBox(false, player.name + " is not allowed to :" + turnActionToDo.ToString() + " at current phase"); ; //Action not allowable }
public bool doAction(Guid gameGuid, Guid playerGuid, Guid gameStateActionShouldBeAppliedOnGuid, TurnActionTypes actionType) { ///Returns false if action not carried out /// //Get CurrentPlayFieldModelState currentPlayFieldModel = getCurrentPlayFieldModel(); if (checkIfActionIsForThisState(actionType, gameStateActionShouldBeAppliedOnGuid, playerGuid, gameGuid)) { if (actionType.CompareTo(TurnActionTypes.drawTwoCardsAtStartOfTurn) == 0) { drawTwoCardsAtTurnStart(getPlayerByGuid(playerGuid, currentPlayFieldModel)); } if (actionType.CompareTo(TurnActionTypes.drawFiveCardsAtStartOfTurn) == 0) { drawFiveCards(getPlayerByGuid(playerGuid, currentPlayFieldModel)); } if (actionType.CompareTo(TurnActionTypes.EndTurn) == 0) { endTurn(getPlayerByGuid(playerGuid, currentPlayFieldModel), gameStateActionShouldBeAppliedOnGuid); } if (actionType.CompareTo(TurnActionTypes.PlayPropertyCard_New_Set) == 0) { //playPropertyCardToNewSet(getPlayerByGuid(playerGuid, currentPlayFieldModel)); } //turn action is for this playfieldmodel } return true; throw new NotImplementedException(); }
/// <summary> /// Determines the type of action to perform and calls the correct method to perform it /// </summary> /// <param name="lastState">The state previous to the current state.</param> /// <param name="currentState">The current state.</param> /// <param name="nextState">A reference for the next state</param> /// <param name="playerPerformingAction">The Guid of the player who is performing the action.</param> /// <param name="typeOfActionToPerform">The type of action the player is performing.</param> /// <param name="justSayNoAble">The StatePhase the state should be if the action is performed and is able to be Just Say No'd</param> /// <param name="notJustSayNoAble">The StatePhase the state should be if the action is performed and is not able to be Just Say No'd</param> /// <param name="rearrangeProperties">The StatePhase the state should be if the action is performed is to move properties between sets</param> /// <param name="drawCardsAtTurnStart">The StatePhase the state should be if the action is performed is to draw cards at the start of a turn</param> /// <param name="JustSayNoUsedByOpposition">The StatePhase the state should be if the action is performed and is a player using a Just Say No card against an Action Card affecting them played by the player who is on their turn</param> /// <param name="moveInformation">The MoveInfo containing the information required to perform the action.</param> /// <param name="discard">The StatePhase the state should be if the action is performed is to end a turn and the player has to discard cards</param> /// <returns></returns> private BoolResponseBox doAppropriateAction(PlayFieldModel lastState, PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, TurnActionTypes typeOfActionToPerform, Statephase justSayNoAble, Statephase notJustSayNoAble, Statephase rearrangeProperties, Statephase drawCardsAtTurnStart, Statephase JustSayNoUsedByOpposition, MoveInfo moveInformation, Statephase discard) { if (typeOfActionToPerform.CompareTo(TurnActionTypes.drawTwoCardsAtStartOfTurn) == 0) { return draw2CardsAtStartOfTurn(currentState, nextState, playerPerformingAction, drawCardsAtTurnStart); } else if (typeOfActionToPerform.CompareTo(TurnActionTypes.drawFiveCardsAtStartOfTurn) == 0) { return draw5CardsAtStartOfTurn(currentState, nextState, playerPerformingAction, drawCardsAtTurnStart); } else if (typeOfActionToPerform.CompareTo(TurnActionTypes.EndTurn) == 0) { return endTurn(currentState, nextState, playerPerformingAction); } else if (typeOfActionToPerform.CompareTo(TurnActionTypes.MovePropertyCard) == 0) { return movePropertyCard(currentState, nextState, playerPerformingAction, moveInformation, rearrangeProperties); } else if (typeOfActionToPerform.CompareTo(TurnActionTypes.PlayPropertyCardFromHand) == 0) { return playPropertyCardFromHand(currentState, nextState, playerPerformingAction, moveInformation, notJustSayNoAble); } else if (typeOfActionToPerform.CompareTo(TurnActionTypes.PlayPropertyCard_New_Set) == 0) { return playPropertyCardFromHandToNewSet(currentState, nextState, playerPerformingAction, moveInformation, notJustSayNoAble); } else if (typeOfActionToPerform.CompareTo(TurnActionTypes.BankActionCard) == 0) { return playCardFromHandToBank(currentState, nextState, playerPerformingAction, moveInformation, notJustSayNoAble); } else if (typeOfActionToPerform.CompareTo(TurnActionTypes.BankMoneyCard) == 0) { return playCardFromHandToBank(currentState, nextState, playerPerformingAction, moveInformation, notJustSayNoAble); } else if (typeOfActionToPerform.CompareTo(TurnActionTypes.Discard_1_Card) == 0) { return discard1Card(currentState, nextState, playerPerformingAction, moveInformation, discard); } else if (typeOfActionToPerform.CompareTo(TurnActionTypes.PayDebt) == 0) { return payDebt(currentState, nextState, playerPerformingAction, moveInformation, justSayNoAble, notJustSayNoAble); } else if (typeOfActionToPerform.CompareTo(TurnActionTypes.Dont_Play_Just_Say_No) == 0) { return doNotPlayJustSayNo(currentState, nextState, playerPerformingAction, moveInformation, justSayNoAble, notJustSayNoAble); } //ActionCards else if (typeOfActionToPerform.CompareTo(TurnActionTypes.PlayActionCard) == 0 || typeOfActionToPerform.CompareTo(TurnActionTypes.PlayCard) == 0) { if (moveInformation.actionCardActionType.CompareTo(ActionCardAction.PassGo) == 0) { Statephase nextStatePhase = notJustSayNoAble; return playActionCardPassGo(currentState, nextState, playerPerformingAction, nextStatePhase, moveInformation); } else if (moveInformation.actionCardActionType.CompareTo(ActionCardAction.DebtCollector) == 0) { Statephase nextStatePhase = justSayNoAble; return playActionCardDebtCollector(currentState, nextState, playerPerformingAction, nextStatePhase, moveInformation); } else if (moveInformation.actionCardActionType.CompareTo(ActionCardAction.ItsMyBirthday) == 0) { Statephase nextStatePhase = justSayNoAble; return playActionCardItsMyBirthday(currentState, nextState, playerPerformingAction, nextStatePhase, moveInformation); } else if (moveInformation.actionCardActionType.CompareTo(ActionCardAction.JustSayNo) == 0) { Statephase nextStatePhase = notJustSayNoAble;//TODO switch to justsaynoable return playActionCardJustSayNo(currentState, nextState, playerPerformingAction, nextStatePhase, justSayNoAble, JustSayNoUsedByOpposition, moveInformation); } else if (moveInformation.actionCardActionType.CompareTo(ActionCardAction.RentMultiColor) == 0) { Statephase nextStatePhase = justSayNoAble; return playActionCardRentMultiColor(currentState, nextState, playerPerformingAction, nextStatePhase, moveInformation); } else if (moveInformation.actionCardActionType.CompareTo(ActionCardAction.RentStandard) == 0) { Statephase nextStatePhase = justSayNoAble; return playActionCardRentStandard(currentState, nextState, playerPerformingAction, nextStatePhase, moveInformation); } else if (moveInformation.actionCardActionType.CompareTo(ActionCardAction.SlyDeal) == 0) { Statephase nextStatePhase = justSayNoAble; return playActionCardSlyDeal(currentState, nextState, playerPerformingAction, nextStatePhase, moveInformation); } else if (moveInformation.actionCardActionType.CompareTo(ActionCardAction.ForcedDeal) == 0) { Statephase nextStatePhase = justSayNoAble; return playActionCardForcedDeal(currentState, nextState, playerPerformingAction, nextStatePhase, moveInformation); } else if (moveInformation.actionCardActionType.CompareTo(ActionCardAction.DealBreaker) == 0) { Statephase nextStatePhase = justSayNoAble; return playActionCardDealBreaker(currentState, nextState, playerPerformingAction, nextStatePhase, moveInformation); } else if (moveInformation.actionCardActionType.CompareTo(ActionCardAction.House) == 0) { Statephase nextStatePhase = notJustSayNoAble; return playActionCardHouse(currentState, nextState, playerPerformingAction, nextStatePhase, moveInformation); } else if (moveInformation.actionCardActionType.CompareTo(ActionCardAction.Hotel) == 0) { Statephase nextStatePhase = notJustSayNoAble; return playActionCardHotel(currentState, nextState, playerPerformingAction, nextStatePhase, moveInformation); } throw new NotImplementedException(); } else if (typeOfActionToPerform.CompareTo(TurnActionTypes.PlayJustSayNo) == 0) { Statephase nextStatePhase = notJustSayNoAble;//should be just say noable return playActionCardJustSayNo(currentState, nextState, playerPerformingAction, nextStatePhase, justSayNoAble, JustSayNoUsedByOpposition, moveInformation); } else { return new BoolResponseBox(false, "Unsupported action:" + typeOfActionToPerform.ToString()); } }