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;
}
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;
}
/// <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;
}
public bool isActionAllowedForPlayer(TurnActionTypes turnActionToDo, Guid playerGuid, PlayFieldModel currentState)
{
throw new NotImplementedException();
}
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());
}
}
public bool doAction(Guid gameGuid, Guid playerGuid, Guid gameStateActionShouldBeAppliedOnGuid, TurnActionTypes actionType)
{
throw new NotSupportedException();
}
