public Card checkIfCardInHand(Card card, PlayerModel pm)
{
foreach (Card c in pm.hand.cardsInHand)
{
if (c.cardID == card.cardID)
{
return c;
}
}
return null;
}
public void drawFiveCards(PlayerModel player)
{
//draws five cards to players hand Unsafe
player.hand.addCardToHand(currentPlayFieldModel.drawPile.drawcard());
player.hand.addCardToHand(currentPlayFieldModel.drawPile.drawcard());
player.hand.addCardToHand(currentPlayFieldModel.drawPile.drawcard());
player.hand.addCardToHand(currentPlayFieldModel.drawPile.drawcard());
player.hand.addCardToHand(currentPlayFieldModel.drawPile.drawcard());
//actionPerformed();
updateState(TurnActionTypes.drawFiveCardsAtStartOfTurn, currentPlayFieldModel, player.guid);
}
//Clone Constructors
public PlayerModel(PlayerModel player, PlayFieldModel state)
{
this.hand = new PlayerHand(player.hand, state);
this.bank = new PlayerBank(player.bank, state);
this.propertySets = new PlayerPropertySets(player.propertySets, state);
this.guid = player.guid;
this.id = player.id;
this.isThisPlayersTurn = player.isThisPlayersTurn;
this.name = player.name;
this.actionsCurrentlyAllowed = player.actionsCurrentlyAllowed.cloneListTurnActionTypes();
this.isReadyToStartGame = player.isReadyToStartGame;
this.owesAnotherPlayer = player.owesAnotherPlayer;
this.amountOwedToAnotherPlayer = player.amountOwedToAnotherPlayer;
}
public bool createGame(List<LobbyClient> clients, Guid guidForGame, ILobby lobby)
{
try
{
List<PlayerModel> playersMD = new List<PlayerModel>();
foreach (LobbyClient lc in clients)
{
PlayerModel p = new PlayerModel(lc.getName());
p.guid = lc.getGuid();
p.isReadyToStartGame = true;
playersMD.Add(p);
}
MonopolyDeal game = new MonopolyDeal(playersMD, guidForGame, lobby);
games.Add(game);
return true;
}
catch (Exception)
{
return false;
}
}
private BoolResponseBox playActionCardDealBreaker(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, Statephase nextStatePhase, MoveInfo moveInformation)
{
//Check
//Perform action in next state
//Clone the current state to create next state then draws 5 cards in the next state
nextState = currentState.clone(generateGuidForNextState());
PlayerModel playerModelForPlayer = getPlayerModel(playerPerformingAction.guid, nextState);
PlayerModel playerModelForPlayerToDealBreaker = getPlayerModel(moveInformation.guidOfPlayerWhoIsBeingDealBreakered, nextState);
Card cardInHandToBePlayed = nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed);
//Get the reference to the players playerModel in the current PlayFieldModel
//Get the reference to the Card in the current PlayFieldModel
if (cardInHandToBePlayed != null && cardInHandToBePlayed is ActionCard && ((ActionCard)cardInHandToBePlayed).actionType.CompareTo(ActionCardAction.DealBreaker) == 0)
{
Card card = removeCardFromHand(cardInHandToBePlayed, playerModelForPlayer);
if (card != null)
{
ActionCard actionCard = card as ActionCard;
//Do action
PropertyCardSet setToDealBreaker = getPropertyCardSet(playerModelForPlayerToDealBreaker.propertySets, moveInformation.guidOfFullSetToBeDealBreakered);
if (setToDealBreaker != null && setToDealBreaker.isFullSet() == true)
{
if (playerModelForPlayerToDealBreaker.propertySets.playersPropertySets.Remove(setToDealBreaker) == true)
{
//Set taken from player
//give to player using dealbreaker card
playerModelForPlayer.propertySets.addSet(setToDealBreaker);
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = nextStatePhase;
//Used to set the allowable actions for player
playerModelForPlayerToDealBreaker.hasHadCardsTaken = true;
//Put card in discard pile
nextState.playpile.playCardOnPile(actionCard);
//Create event information for rollback and display
nextState.actionCardEvent = new ActionCardEvent();
nextState.actionCardEvent.playerAffectedByAction = moveInformation.guidOfPlayerWhoIsBeingDealBreakered;
nextState.actionCardEvent.playerWhoPerformedActionOffTurn = moveInformation.playerMakingMove;
nextState.actionCardEvent.playerOnTurnPerformingAction = true;
nextState.actionCardEvent.actionTypeTaken = TurnActionTypes.PlayActionCard;
nextState.actionCardEvent.propertySetTakenFromPlayer = setToDealBreaker.guid;
nextState.actionCardEvent.actionCardTypeUsed = ActionCardAction.DealBreaker;
List<CardIDSetGuid> listOfCardDealbreakered = new List<CardIDSetGuid>();
foreach (Card property in setToDealBreaker.properties)
{
listOfCardDealbreakered.Add(new CardIDSetGuid(property.cardID, setToDealBreaker.guid));
}
if (setToDealBreaker.hasHouse)
{
listOfCardDealbreakered.Add(new CardIDSetGuid(setToDealBreaker.house.cardID, setToDealBreaker.guid));
}
if (setToDealBreaker.hasHotel)
{
listOfCardDealbreakered.Add(new CardIDSetGuid(setToDealBreaker.hotel.cardID, setToDealBreaker.guid));
}
nextState.actionCardEvent.propertyCardsTakenFromPlayerAndSetTheCardWasIn = listOfCardDealbreakered;
//change the current state to the next state
List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStatesPerPlayerCardsTaken(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, setAllowableActionsNotOnTurnCardsTaken(new List<TurnActionTypes>(), nextState));
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has used a Deal Breaker Card");
}
else
{
return new BoolResponseBox(false, "Unable to take set from player");
}
}
else
{
return new BoolResponseBox(false, "Set to Deal Breaker is not a full set or does not exist");
}
}
return new BoolResponseBox(false, "Card is not in hand.");
}
return new BoolResponseBox(false, "Card id does not exist or is not a Deal Breaker Card");
}
private BoolResponseBox doNotPlayJustSayNo(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, MoveInfo moveInformation, Statephase justSayNoAble, Statephase notJustSayNoAble)
{
//Check
//Perform action in next state
//Clone the current state to create next state then draws 5 cards in the next state
nextState = currentState.clone(generateGuidForNextState());
//Player Not using Just Say No
PlayerModel playerModelForNotUsingJustSayNo = getPlayerModel(moveInformation.playerMakingMove, nextState);
//Player no longer can Just Say no
playerModelForNotUsingJustSayNo.hasHadCardsTaken = false;
//Change state on success
//has been performed, advance the phase of the game
Statephase nextStatePhaseIfSuccessful;
nextStatePhaseIfSuccessful = notJustSayNoAble;
nextState.currentPhase = nextStatePhaseIfSuccessful;
List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has chosen to not use a Just Say No!");
}
private BoolResponseBox endTurn(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction)
{
//Allowed to end turn
//Clone the current state to create next state then draws two cards in the next state
nextState = currentState.clone(generateGuidForNextState());
PlayerModel playerModelForPlayer = getPlayerModel(playerPerformingAction.guid, nextState);
//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
//Check if Game is over
if (checkAndSetIfGameIsOver(nextState, playerPerformingAction.guid).success)
{
//Game is now over as player has enough unique full sets
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Ended their turn and won the game!");
}
//Change phase
switch (playerModelForPlayer.hand.cardsInHand.Count)
{
case 8:
{
nextState.currentPhase = Statephase.Turn_Ended_8_Cards_In_Hand_Discard_1_Card;
onTurn.Add(TurnActionTypes.Discard_1_Card);
//Update the moves for players
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Ended their turn with 8 cards and must discard 1 card");
}
case 9:
{
nextState.currentPhase = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards;
onTurn.Add(TurnActionTypes.Discard_1_Card);
//Update the moves for players
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Ended their turn with 9 cards and must discard 2 cards");
}
case 10:
{
nextState.currentPhase = Statephase.Turn_Ended_10_Cards_In_Hand_Discard_3_Cards;
onTurn.Add(TurnActionTypes.Discard_1_Card);
//Update the moves for players
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Ended their turn with 10 cards and must discard 3 cards");
}
case 11:
{
nextState.currentPhase = Statephase.Turn_Ended_11_Cards_In_Hand_Discard_4_Cards;
onTurn.Add(TurnActionTypes.Discard_1_Card);
//Update the moves for players
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Ended their turn with 11 cards and must discard 4 cards");
}
case 12:
{
nextState.currentPhase = Statephase.Turn_Ended_12_Cards_In_Hand_Discard_5_Cards;
onTurn.Add(TurnActionTypes.Discard_1_Card);
//Update the moves for players
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Ended their turn with 12 cards and must discard 5 cards");
}
default:
{
nextState.currentPhase = Statephase.Turn_Ended_7_Or_Less_Cards_In_Hand_Setup_NextPlayer;
setNextPlayerOnTurn(nextState);
if (getPlayerModel(nextState.guidOfPlayerWhosTurnItIs, nextState).hand.cardsInHand.Count == 0)
{
//Player has 0 cards draws 5 on turn start instead of 2
nextState.currentPhase = Statephase.Turn_Started_Draw_5_Cards;
onTurn.Add(TurnActionTypes.drawFiveCardsAtStartOfTurn);
//Update the moves for players
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Ended their turn." + "Player:" + getPlayerModel(nextState.guidOfPlayerWhosTurnItIs, nextState).name + "\'s Turn. Draw 5 Cards.");
}
else
{
//Player has at least one and at most seven cards, draws 2
nextState.currentPhase = Statephase.Turn_Started_Draw_2_Cards;
onTurn.Add(TurnActionTypes.drawTwoCardsAtStartOfTurn);
//Update the moves for players
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Ended their turn." + "Player:" + getPlayerModel(nextState.guidOfPlayerWhosTurnItIs, nextState).name + "\'s Turn. Draw 2 Cards.");
}
}
}
}
/// <summary>
/// Allows a player to Draw 5 Cards at the start of their turn
/// </summary>
/// <param name="currentState"></param>
/// <param name="nextState"></param>
/// <param name="playerPerformingAction"></param>
/// <param name="nextStatePhaseIfSuccessful"></param>
/// <returns></returns>
private BoolResponseBox draw5CardsAtStartOfTurn(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, Statephase nextStatePhaseIfSuccessful)
{
//Check
//Perform action in next state
//Clone the current state to create next state then draws 5 cards in the next state
nextState = currentState.clone(generateGuidForNextState());
PlayerModel playerModelForPlayer = getPlayerModel(playerPerformingAction.guid, nextState);
//Perform action
playerModelForPlayer.hand.addCardToHand(nextState.drawPile.drawcard());
playerModelForPlayer.hand.addCardToHand(nextState.drawPile.drawcard());
playerModelForPlayer.hand.addCardToHand(nextState.drawPile.drawcard());
playerModelForPlayer.hand.addCardToHand(nextState.drawPile.drawcard());
playerModelForPlayer.hand.addCardToHand(nextState.drawPile.drawcard());
//drawtwocards has been performed, advance the phase of the game
nextState.currentPhase = nextStatePhaseIfSuccessful;
//Respond that the move has been performed
//player has drawn their 5 cards, Now can play up to three cards on their turn
//Set the allowable moves for all players for the next state
List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has drawn 5 cards");
}
/// <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
}
/// <summary>
/// Plays a Property Card from a Players Hand on their turn to an existing Property Set
/// </summary>
/// <param name="currentState"></param>
/// <param name="nextState"></param>
/// <param name="playerPerformingAction"></param>
/// <param name="moveInformation"></param>
/// <param name="notJustSayNoAble"></param>
/// <returns></returns>
private BoolResponseBox playPropertyCardFromHand(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, MoveInfo moveInformation, Statephase notJustSayNoAble)
{
if (moveInformation.guidOfExistingSetToPlayPropertyTo.CompareTo(new Guid()) != 0)
{
//Clone the current state to create next state
nextState = currentState.clone(generateGuidForNextState());
PropertyColor oldColour = ((PropertyCard)currentState.deck.getCardByID(moveInformation.idOfCardBeingUsed)).getPropertyColor();
bool oldOrientation = ((PropertyCard)currentState.deck.getCardByID(moveInformation.idOfCardBeingUsed)).isCardUp;
((PropertyCard)nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed)).setPropertyColor(moveInformation.isPropertyToPlayOrientedUp);
/*
if ((getPropertyCardSet(getPlayerModel(playerPerformingAction.guid, nextState).propertySets, moveInformation.guidOfExistingSetToPlayPropertyTo)).propertySetColor.CompareTo(
((PropertyCard)nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed)).currentPropertyColor) == 0)
{
*/
if (getPropertyCardSet(getPlayerModel(playerPerformingAction.guid, nextState).propertySets, moveInformation.guidOfExistingSetToPlayPropertyTo).isPropertyCompatible((PropertyCard)nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed)))
{
//Get CurrentPlayFieldModelState
Card cardInHandToBePlayed = nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed);
PlayerModel player = getPlayerModel(playerPerformingAction.guid, nextState);
Card card = removeCardFromHand(cardInHandToBePlayed, player);
if (card != null)
{
PropertyCard cP = cardInHandToBePlayed as PropertyCard;
cP.setPropertyColor(moveInformation.isPropertyToPlayOrientedUp);
PropertyCardSet ps = getPropertyCardSet(player.propertySets, moveInformation.guidOfExistingSetToPlayPropertyTo);
if (ps.addProperty(cP) == false)
{
return new BoolResponseBox(false, "Property Card not played. Set full or card incompatible.");
}
else
{
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = notJustSayNoAble;
List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has played to a existing set " + card.cardName);
}
}
return new BoolResponseBox(false, "Card is not in hand.");
}
else
{
nextState = null;
((PropertyCard)currentState.deck.getCardByID(moveInformation.idOfCardBeingUsed)).setPropertyColor(oldOrientation);//change back the orientation of the property
return new BoolResponseBox(false, "Property Card is not the correct colour to be added to this set");
}
}
else
{
return playPropertyCardFromHandToNewSet(currentState, nextState, playerPerformingAction, moveInformation, notJustSayNoAble);
}
}
/// <summary>
/// Replays a its my birthday card after being just say no'd
/// </summary>
/// <param name="currentState"></param>
/// <param name="nextState"></param>
/// <param name="playerPerformingAction"></param>
/// <param name="nextStatePhase"></param>
/// <param name="moveInformation"></param>
/// <returns></returns>
private BoolResponseBox replayActionCardItsMyBirthday(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, Statephase nextStatePhase, MoveInfo moveInformation)
{
//Check
//Perform action in next state
//Clone the current state to create next state then draws 5 cards in the next state
nextState = currentState.clone(generateGuidForNextState());
ActionCardEvent acevent = currentState.actionCardEvent;
foreach (PlayerModel player in nextState.playerModels)
{
if (player.guid.CompareTo(acevent.playerAffectedByAction) != 0)
{
player.owesAnotherPlayer = true;
player.amountOwedToAnotherPlayer = ActionCard.Its_My_Birthday_Value;
break;
}
}
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = nextStatePhase;
List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStatesDebtPaid(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, setAllowableActionsNotOnTurnInDebt(new List<TurnActionTypes>(), nextState));
nextState.actionCardEvent = new ActionCardEvent();
nextState.actionCardEvent.actionTypeTaken = TurnActionTypes.PlayActionCard;
nextState.actionCardEvent.actionCardTypeUsed = ActionCardAction.ItsMyBirthday;
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + getPlayerModel(currentState.guidOfPlayerWhosTurnItIs, currentState).name + " Has used a It's My Birthday after Just Say No");
}
private BoolResponseBox replayActionCardRentWild(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerModel, Statephase nextStatePhase, MoveInfo moveInformation)
{
//Check
//Perform action in next state
//Clone the current state to create next state then draws 5 cards in the next state
nextState = currentState.clone(generateGuidForNextState());
//Get the reference to the players playerModel in the current PlayFieldModel
//Do action
foreach (PlayerModel p in nextState.playerModels)
{
if (p.guid.CompareTo(currentState.actionCardEvent.playerAffectedByAction) != 0)
{
p.owesAnotherPlayer = true;
p.amountOwedToAnotherPlayer = currentState.actionCardEvent.debtAmount;
break;//Only replay for the player who used a just say no against debt
}
else
{
//Player on turn does not have to pay rent
}
}
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = nextStatePhase;
List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStatesDebtPaid(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, setAllowableActionsNotOnTurnInDebt(new List<TurnActionTypes>(), nextState));
nextState.actionCardEvent = new ActionCardEvent();
nextState.actionCardEvent.actionTypeTaken = TurnActionTypes.PlayActionCard;
nextState.actionCardEvent.actionCardTypeUsed = ActionCardAction.RentMultiColor;
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + getPlayerModel(currentState.guidOfPlayerWhosTurnItIs, currentState).name + " Has used a Wild Rent Card after a Just Say No");
}
/// <summary>
/// Allows a player to play a just say no on their turn or when an action is played against them
/// </summary>
/// <param name="currentState"></param>
/// <param name="nextState"></param>
/// <param name="playerPerformingAction"></param>
/// <param name="nextStatePhase"></param>
/// <param name="justSayNoAble"></param>
/// <param name="JustSayNoUsedByOpposition"></param>
/// <param name="moveInformation"></param>
/// <returns></returns>
private BoolResponseBox playActionCardJustSayNo(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, Statephase nextStatePhase, Statephase justSayNoAble, Statephase JustSayNoUsedByOpposition, MoveInfo moveInformation)
{
#region Player not on turn canceling effect of ActionCard being played against them
if (currentState.actionCardEvent != null && currentState.actionCardEvent.actionJustSayNoUsedByAffectedPlayer == false)
{
#region Just Say No used against debt incurring card
if (currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.DebtCollector) == 0 || currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.DoubleTheRent) == 0 || currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.ItsMyBirthday) == 0 || currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.RentMultiColor) == 0 || currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.RentStandard) == 0)
{
//Money events are just say noable before action is taken so rollback is unneccessary
//Check
//Perform action in next state
//Clone the current state to create next state
nextState = currentState.clone(generateGuidForNextState());
//Player Paying Debt
PlayerModel playerModelForPlayerPaying = getPlayerModel(playerPerformingAction.guid, nextState);
//Player Being paid debt
PlayerModel playerModelForPlayerToBePaid = getPlayerModel(moveInformation.guidOfPlayerToPayDebtTo, nextState);
//Discard Just say no card
Card cardInHandToBePlayed = nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed);
//Get the reference to the players playerModel in the current PlayFieldModel
//Get the reference to the Card in the current PlayFieldModel
if (cardInHandToBePlayed != null && cardInHandToBePlayed is ActionCard && ((ActionCard)cardInHandToBePlayed).actionType.CompareTo(ActionCardAction.JustSayNo) == 0)
{
Card card = removeCardFromHand(cardInHandToBePlayed, playerModelForPlayerPaying);
if (card != null)
{
ActionCard actionCard = card as ActionCard;
//Do action
bool otherPlayersPaying = false;
//Get if player paying is the only player who has to pay
foreach (PlayerModel player in nextState.playerModels)
{
if (player.guid.CompareTo(playerModelForPlayerPaying.guid) != 0 && player.owesAnotherPlayer)
{
//Another player owes money
otherPlayersPaying = true;
break;
}
}
Statephase nextStatePhaseIfSuccessful;
if (otherPlayersPaying)
{
//Other players must pay so states phase does not change
nextStatePhaseIfSuccessful = JustSayNoUsedByOpposition;
}
else
{
//No other players have to pay debt
nextStatePhaseIfSuccessful = JustSayNoUsedByOpposition;
}
//Generate action card event to give the chance to just say no
ActionCardEvent justSayNoUsedAgainstDebt = new ActionCardEvent();
justSayNoUsedAgainstDebt.actionCardTypeUsed = currentState.actionCardEvent.actionCardTypeUsed;//Will be a debt incurring card
justSayNoUsedAgainstDebt.actionJustSayNoUsedByAffectedPlayer = true;//The player affected by the debt inccuring card has used a just say no to cancel the debt incurring card
justSayNoUsedAgainstDebt.debtAmount = playerModelForPlayerPaying.amountOwedToAnotherPlayer;//The amount the player would owe if a just say no is played against thier just say no
justSayNoUsedAgainstDebt.actionTypeTaken = TurnActionTypes.PlayJustSayNo;//The action type taken
justSayNoUsedAgainstDebt.playerAffectedByAction = playerModelForPlayerPaying.guid;//The player using a just say no to cancel the debt incurring card
justSayNoUsedAgainstDebt.playerWhoPerformedActionOnTurn = currentState.guidOfPlayerWhosTurnItIs;//The player on turn who played a debt inccuring card who can play a just say not against the cancelling players just say no
//Set the action card event
nextState.actionCardEvent = justSayNoUsedAgainstDebt;
//Player has now paid debt
playerModelForPlayerPaying.owesAnotherPlayer = false;
playerModelForPlayerPaying.amountOwedToAnotherPlayer = 0;
//Update the state
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = nextStatePhaseIfSuccessful;
List<TurnActionTypes> notInDebt = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
List<TurnActionTypes> inDebt = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
inDebt = setAllowableActionsNotOnTurnInDebt(inDebt, nextState);
updateAllowableStatesDebtPaid(nextState, notInDebt, onTurn, nextState.guidOfPlayerWhosTurnItIs, inDebt);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has used a Just Say No to avoid paying.");
}
}
}
#endregion Just Say No used against debt incurring card
#region Just Say No used against non-debt incurring card
#region DealBreaker Being Just Say No'd
else if (currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.DealBreaker) == 0)
{
//Money events are just say noable before action is taken so rollback is unneccessary
//Check
//Perform action in next state
//Clone the current state to create next state
nextState = currentState.clone(generateGuidForNextState());
//Player Lost Set in DealBreaker using Just Say No to get it back
PlayerModel playerModelForLostSet = getPlayerModel(playerPerformingAction.guid, nextState);
//Player Gained Set in DealBreaker
PlayerModel playerModelForPlayerGainedSet = getPlayerModel(moveInformation.guidOfPlayerToPayDebtTo, nextState);
//Discard Just say no card
Card cardInHandToBePlayed = nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed);
//Get the reference to the players playerModel in the current PlayFieldModel
//Get the reference to the Card in the current PlayFieldModel
if (cardInHandToBePlayed != null && cardInHandToBePlayed is ActionCard && ((ActionCard)cardInHandToBePlayed).actionType.CompareTo(ActionCardAction.JustSayNo) == 0)
{
Card card = removeCardFromHand(cardInHandToBePlayed, playerModelForLostSet);
if (card != null)
{
ActionCard actionCard = card as ActionCard;
//Do action
if (undoDealBreaker(currentState, nextState) == false)
{
return new BoolResponseBox(false, "Failed to undo dealbreaker");
}
else
{
Statephase nextStatePhaseIfSuccessful;
nextStatePhaseIfSuccessful = JustSayNoUsedByOpposition;
//Generate action card event to give the chance to just say no
ActionCardEvent justSayNoUsedAgainstDealBreaker = new ActionCardEvent();
justSayNoUsedAgainstDealBreaker.actionCardTypeUsed = currentState.actionCardEvent.actionCardTypeUsed;//Will be a debt incurring card
justSayNoUsedAgainstDealBreaker.actionJustSayNoUsedByAffectedPlayer = true;//The player affected by the DealBreaker card has used a just say no to cancel the debt incurring card
justSayNoUsedAgainstDealBreaker.actionTypeTaken = TurnActionTypes.PlayJustSayNo;//The action type taken
justSayNoUsedAgainstDealBreaker.playerAffectedByAction = playerModelForLostSet.guid;//The player using a just say no to cancel the DealBreaker card
justSayNoUsedAgainstDealBreaker.playerWhoPerformedActionOnTurn = currentState.guidOfPlayerWhosTurnItIs;//The player on turn who played a DealBreaker card who can play a just say not against the cancelling players just say no
justSayNoUsedAgainstDealBreaker.propertySetTakenFromPlayer = currentState.actionCardEvent.propertySetTakenFromPlayer;
justSayNoUsedAgainstDealBreaker.originalActionCardId = currentState.actionCardEvent.originalActionCardId;//Dealbreaker card id
justSayNoUsedAgainstDealBreaker.playerOnTurnPerformingAction = false;//Player using Just Say No is performing this action
justSayNoUsedAgainstDealBreaker.playerWhoPerformedActionOffTurn = moveInformation.playerMakingMove;
//Set the action card event
nextState.actionCardEvent = justSayNoUsedAgainstDealBreaker;
//Update the state
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = nextStatePhaseIfSuccessful;
List<TurnActionTypes> allowedForPlayerWhoDontHaveCardsTaken = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
List<TurnActionTypes> allowedForPlayersWhoDoHaveCardsTaken = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStatesPerPlayerCardsTaken(nextState, allowedForPlayerWhoDontHaveCardsTaken, onTurn, currentState.guidOfPlayerWhosTurnItIs, allowedForPlayersWhoDoHaveCardsTaken);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has used a Just Say No to regain Set.");
}
}
}
}
#endregion DealBreaker Being Just Say No'd
#region Forced Deal Being Just Say No'd
else if (currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.ForcedDeal) == 0)
{
//Money events are just say noable before action is taken so rollback is unneccessary
//Check
//Perform action in next state
//Clone the current state to create next state
nextState = currentState.clone(generateGuidForNextState());
//Player Lost Set in DealBreaker using Just Say No to get it back
PlayerModel playerModelForLostSet = getPlayerModel(playerPerformingAction.guid, nextState);
//Player Gained Set in DealBreaker
PlayerModel playerModelForPlayerGainedSet = getPlayerModel(moveInformation.guidOfPlayerToPayDebtTo, nextState);
//Discard Just say no card
Card cardInHandToBePlayed = nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed);
//Get the reference to the players playerModel in the current PlayFieldModel
//Get the reference to the Card in the current PlayFieldModel
if (cardInHandToBePlayed != null && cardInHandToBePlayed is ActionCard && ((ActionCard)cardInHandToBePlayed).actionType.CompareTo(ActionCardAction.JustSayNo) == 0)
{
Card card = removeCardFromHand(cardInHandToBePlayed, playerModelForLostSet);
if (card != null)
{
ActionCard actionCard = card as ActionCard;
//Do action
Statephase nextStatePhaseIfSuccessful;
nextStatePhaseIfSuccessful = JustSayNoUsedByOpposition;
//Generate action card event to give the chance to just say no
ActionCardEvent justSayNoUsedAgainstForcedDeal = new ActionCardEvent();
justSayNoUsedAgainstForcedDeal.actionCardTypeUsed = currentState.actionCardEvent.actionCardTypeUsed;//
justSayNoUsedAgainstForcedDeal.actionJustSayNoUsedByAffectedPlayer = true;//The player affected by the Forced Deal card has used a just say no to cancel the debt incurring card
justSayNoUsedAgainstForcedDeal.actionTypeTaken = TurnActionTypes.PlayJustSayNo;//The action type taken
justSayNoUsedAgainstForcedDeal.playerAffectedByAction = playerModelForLostSet.guid;//The player using a just say no to cancel the Forced Deal card
justSayNoUsedAgainstForcedDeal.playerWhoPerformedActionOnTurn = currentState.guidOfPlayerWhosTurnItIs;//The player on turn who played a Forced Deal card who can play a just say not against the cancelling players just say no
justSayNoUsedAgainstForcedDeal.originalActionCardId = currentState.actionCardEvent.originalActionCardId;//Forced Deal card id
justSayNoUsedAgainstForcedDeal.playerOnTurnPerformingAction = false;//Player using Just Say No is performing this action
justSayNoUsedAgainstForcedDeal.playerWhoPerformedActionOffTurn = moveInformation.playerMakingMove;
justSayNoUsedAgainstForcedDeal.propertyCardGivenUpInForcedDeal = currentState.actionCardEvent.propertyCardGivenUpInForcedDeal;
justSayNoUsedAgainstForcedDeal.propertyCardsTakenFromPlayerAndSetTheCardWasIn = currentState.actionCardEvent.propertyCardsTakenFromPlayerAndSetTheCardWasIn;
//Set the action card event
nextState.actionCardEvent = justSayNoUsedAgainstForcedDeal;
//Update the state
undoForcedDeal(currentState, nextState);
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = nextStatePhaseIfSuccessful;
List<TurnActionTypes> allowedForPlayerWhoDontHaveCardsTaken = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
List<TurnActionTypes> allowedForPlayersWhoDoHaveCardsTaken = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStatesPerPlayerCardsTaken(nextState, allowedForPlayerWhoDontHaveCardsTaken, onTurn, currentState.guidOfPlayerWhosTurnItIs, allowedForPlayersWhoDoHaveCardsTaken);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has used a Just Say No to undo Forced Deal.");
}
}
}
#endregion Forced Deal Being Just Say No'd
#region Sly Deal Being Just Say No'd
else if (currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.SlyDeal) == 0)
{
//Money events are just say noable before action is taken so rollback is unneccessary
//Check
//Perform action in next state
//Clone the current state to create next state
nextState = currentState.clone(generateGuidForNextState());
//Player Lost Set in DealBreaker using Just Say No to get it back
PlayerModel playerModelForLostCard = getPlayerModel(playerPerformingAction.guid, nextState);
//Player Gained Set in DealBreaker
PlayerModel playerModelForPlayerGainedCard = getPlayerModel(currentState.guidOfPlayerWhosTurnItIs, nextState);
//Discard Just say no card
Card cardInHandToBePlayed = nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed);
//Get the reference to the players playerModel in the current PlayFieldModel
//Get the reference to the Card in the current PlayFieldModel
if (cardInHandToBePlayed != null && cardInHandToBePlayed is ActionCard && ((ActionCard)cardInHandToBePlayed).actionType.CompareTo(ActionCardAction.JustSayNo) == 0)
{
Card card = removeCardFromHand(cardInHandToBePlayed, playerModelForLostCard);
if (card != null)
{
ActionCard actionCard = card as ActionCard;
//Do action
Statephase nextStatePhaseIfSuccessful;
nextStatePhaseIfSuccessful = JustSayNoUsedByOpposition;
//Generate action card event to give the chance to just say no
ActionCardEvent justSayNoUsedAgainstSlyDeal = new ActionCardEvent();
justSayNoUsedAgainstSlyDeal.actionCardTypeUsed = currentState.actionCardEvent.actionCardTypeUsed;//
justSayNoUsedAgainstSlyDeal.actionJustSayNoUsedByAffectedPlayer = true;//The player affected by the Forced Deal card has used a just say no to cancel the debt incurring card
justSayNoUsedAgainstSlyDeal.actionTypeTaken = TurnActionTypes.PlayJustSayNo;//The action type taken
justSayNoUsedAgainstSlyDeal.playerAffectedByAction = playerModelForLostCard.guid;//The player using a just say no to cancel the Forced Deal card
justSayNoUsedAgainstSlyDeal.playerWhoPerformedActionOnTurn = currentState.guidOfPlayerWhosTurnItIs;//The player on turn who played a Forced Deal card who can play a just say not against the cancelling players just say no
justSayNoUsedAgainstSlyDeal.originalActionCardId = currentState.actionCardEvent.originalActionCardId;//Forced Deal card id
justSayNoUsedAgainstSlyDeal.playerOnTurnPerformingAction = false;//Player using Just Say No is performing this action
justSayNoUsedAgainstSlyDeal.playerWhoPerformedActionOffTurn = moveInformation.playerMakingMove;
justSayNoUsedAgainstSlyDeal.propertyCardsTakenFromPlayerAndSetTheCardWasIn = currentState.actionCardEvent.propertyCardsTakenFromPlayerAndSetTheCardWasIn;//card that was sly dealed
//Set the action card event
nextState.actionCardEvent = justSayNoUsedAgainstSlyDeal;
//Update the state
undoSlyDeal(currentState, nextState);
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = nextStatePhaseIfSuccessful;
List<TurnActionTypes> allowedForPlayerWhoDontHaveCardsTaken = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
List<TurnActionTypes> allowedForPlayersWhoDoHaveCardsTaken = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStatesPerPlayerCardsTaken(nextState, allowedForPlayerWhoDontHaveCardsTaken, onTurn, currentState.guidOfPlayerWhosTurnItIs, allowedForPlayersWhoDoHaveCardsTaken);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has used a Just Say No to undo Sly Deal.");
}
}
}
#endregion Sly Deal Being Just Say No'd
#endregion Just Say No used against non-debt incurring card
}
#endregion Player not on turn canceling effect of ActionCard being played against them
#region Player on turn is playing a Just Say No to Cancel the Effect of another Just Say No against them
else if (currentState.actionCardEvent.actionJustSayNoUsedByAffectedPlayer == true)
{
//The on turn player has played a just say no to cancel a just say no
#region Use Just Say No to Cancel Another Just Say No For Debt Collector, It's My Birthday, Standard and MultiColor Rent Cards
if (currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.DebtCollector) == 0 || currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.DoubleTheRent) == 0 || currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.ItsMyBirthday) == 0 || currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.RentMultiColor) == 0 || currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.RentStandard) == 0)
{
//Perform action again
//Clone the current state to create next state
nextState = currentState.clone(generateGuidForNextState());
#region Debt Redo
if (currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.DebtCollector) == 0)
{
//Card Played was a debt collector card
return replayActionCardDebtCollector(currentState, nextState, getPlayerModel(moveInformation.guidOfPlayerToPayDebtTo, currentState), nextStatePhase, moveInformation);
}
else if (currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.ItsMyBirthday) == 0)
{
return replayActionCardItsMyBirthday(currentState, nextState, getPlayerModel(moveInformation.guidOfPlayerToPayDebtTo, currentState), nextStatePhase, moveInformation);
}
else if (currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.RentStandard) == 0)
{
return replayActionCardRentStandard(currentState, nextState, getPlayerModel(moveInformation.guidOfPlayerToPayDebtTo, currentState), nextStatePhase, moveInformation);
}
else if (currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.RentMultiColor) == 0)
{
return replayActionCardRentWild(currentState, nextState, getPlayerModel(moveInformation.guidOfPlayerToPayDebtTo, currentState), nextStatePhase, moveInformation);
}
#endregion Debt Redo
#endregion Use Just Say No to Cancel Another Just Say No For Debt Collector, It's My Birthday, Standard and MultiColor Rent Cards
}
else if (currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.DealBreaker) == 0)
{
return replayActionCardDealBreaker(currentState, nextState, nextStatePhase, moveInformation);
}
else if (currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.ForcedDeal) == 0)
{
return replayActionCardForcedDeal(currentState, nextState, nextStatePhase, moveInformation);
}
else if (currentState.actionCardEvent.actionCardTypeUsed.CompareTo(ActionCardAction.SlyDeal) == 0)
{
return replayActionCardSlyDeal(currentState, nextState, nextStatePhase, moveInformation);
}
}
#endregion Player on turn is playing a Just Say No to Cancel the Effect of another Just Say No against them
throw new NotImplementedException("Replaying action card type " + moveInformation.actionCardActionType.ToString() + " is not implemented");
}
/// <summary>
/// Plays a Wild Rent Card on a players turn.
/// </summary>
/// <param name="currentState"></param>
/// <param name="nextState"></param>
/// <param name="playerPerformingAction"></param>
/// <param name="nextStatePhase"></param>
/// <param name="moveInformation"></param>
/// <returns></returns>
private BoolResponseBox playActionCardRentMultiColor(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, Statephase nextStatePhase, MoveInfo moveInformation)
{
//Check
//Perform action in next state
//Clone the current state to create next state then draws 5 cards in the next state
nextState = currentState.clone(generateGuidForNextState());
PlayerModel playerModelForPlayer = getPlayerModel(playerPerformingAction.guid, nextState);
PlayerModel playerModelForPlayerToRent = getPlayerModel(moveInformation.guidOfPlayerToPayRent, nextState);
Card cardInHandToBePlayed = nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed);
//Get the reference to the players playerModel in the current PlayFieldModel
//Get the reference to the Card in the current PlayFieldModel
if (cardInHandToBePlayed != null && cardInHandToBePlayed is ActionCard && ((ActionCard)cardInHandToBePlayed).actionType.CompareTo(ActionCardAction.RentMultiColor) == 0)
{
Card card = removeCardFromHand(cardInHandToBePlayed, playerModelForPlayer);
if (card != null)
{
ActionCard actionCard = card as ActionCard;
PropertyCardSet ps = getPropertyCardSet(playerModelForPlayer.propertySets, moveInformation.guidOfSetToCollectRentOnAgainstOnePlayer);
if (ps != null)
{
//rent card is wild so is compatible
PropertySetInfo psinfo = new PropertySetInfo(ps.getPropertySetColor());
int rentValue = psinfo.getRentValue(ps.getPropertySetColor(), ps.properties.Count, ps.hasHouse, ps.hasHotel);
nextState.actionCardEvent = new ActionCardEvent();
nextState.actionCardEvent.actionTypeTaken = TurnActionTypes.PlayActionCard;
nextState.actionCardEvent.actionCardTypeUsed = ActionCardAction.RentMultiColor;
nextState.actionCardEvent.doubleTheRentCardUsed = false;
//Double the rent card is being used
if (moveInformation.isDoubleTheRentCardBeingUsed == true)
{
ActionCard cardDoubleTheRentPlayed = removeCardFromHand(nextState.deck.getCardByID(moveInformation.idOfDoubleTheRentCardBeingUsed), playerModelForPlayer) as ActionCard;
if (cardDoubleTheRentPlayed != null && cardDoubleTheRentPlayed.actionType.CompareTo(ActionCardAction.DoubleTheRent) == 0)
{
//Check if the player has not played more than one card on turn so far
if (currentState.currentPhase.CompareTo(Statephase.Turn_Started_Cards_Drawn_0_Cards_Played) == 0 || currentState.currentPhase.CompareTo(Statephase.Turn_Started_Cards_Drawn_1_Cards_Played) == 0)
{
rentValue *= 2;
nextState.actionCardEvent.doubleTheRentCardUsed = true;
}
else
{
return new BoolResponseBox(false, "Can not use double the rent card as you do not have enough card plays left in your turn");
}
}
else
{
//Card is not in hand
return new BoolResponseBox(false, "Double the rent card selected is not in players hand");
}
}
//Do action
playerModelForPlayerToRent.owesAnotherPlayer = true;
playerModelForPlayerToRent.amountOwedToAnotherPlayer = rentValue;
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = nextStatePhase;
//Put card in discard pile
nextState.playpile.playCardOnPile(actionCard);
List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStatesDebtPaid(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, setAllowableActionsNotOnTurnInDebt(new List<TurnActionTypes>(), nextState));
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has used a Wild Rent Card");
}
}
return new BoolResponseBox(false, "Card is not in hand.");
}
return new BoolResponseBox(false, "Card is not in hand or is not a Wild Rent card");
}
public void referenceAllDataContracts(ActionCard ac, Card c, FieldUpdateMessage fum, Message msg, MoneyCard mc, PlayerBank pb, PlayerHand ph, PlayerModel pm, PlayerPropertySets pps, PlayFieldModel pfm, PlayPile pp, PollForFieldUpdateMessage pffum, PropertyCard pc, PropertyCardSet pcs, PropertySetInfo psi, RentStandard rs, TakeActionOnTurnMessage taotm, TurnActionModel tam)
{
throw new NotImplementedException();
}
/// <summary>
/// Removes a Card from a players Hand and returns the card
/// </summary>
/// <param name="card"></param>
/// <param name="pm"></param>
/// <returns></returns>
private Card removeCardFromHand(Card card, PlayerModel pm)
{
Card cardInHand = checkIfCardInHand(card, pm);
if (cardInHand != null && pm.hand.cardsInHand.Remove(cardInHand))
{
return cardInHand;
}
return null;
}
/// <summary>
/// Plays a Property Card from a Players Hand on their turn to a new Property Set
/// </summary>
/// <param name="currentState"></param>
/// <param name="nextState"></param>
/// <param name="playerPerformingAction"></param>
/// <param name="moveInformation"></param>
/// <param name="notJustSayNoAble"></param>
/// <returns></returns>
private BoolResponseBox playPropertyCardFromHandToNewSet(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, MoveInfo moveInformation, Statephase notJustSayNoAble)
{
//Clone the current state to create next state
nextState = currentState.clone(generateGuidForNextState());
//Get CurrentPlayFieldModelState
Card cardInHandToBePlayed = nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed);
PlayerModel player = getPlayerModel(playerPerformingAction.guid, nextState);
Card card = removeCardFromHand(cardInHandToBePlayed, player);
if (card != null)
{
PropertyCard cP = cardInHandToBePlayed as PropertyCard;
cP.setPropertyColor(moveInformation.isPropertyToPlayOrientedUp);
PropertyCardSet ps = new PropertyCardSet(cP);
player.propertySets.addSet(ps);
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = notJustSayNoAble;
List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has played to a new set " + card.cardName);
}
return new BoolResponseBox(false, "Card is not in hand.");
}
/// <summary>
/// Determines if a Player has enough cards to pay Debt
/// </summary>
/// <param name="player"></param>
/// <param name="amountOwed"></param>
/// <returns></returns>
private bool hasPlayerEnoughCardsToPayFullValue(PlayerModel player, int amountOwed)
{
int playersTotalValue = 0;
//Player has insufficent cards selected to pay debt
//Find players net worth to see if they have payed everthing they have
foreach (Card c in player.bank.cardsInBank)
{
playersTotalValue += c.cardValue;
}
foreach (PropertyCardSet ps in player.propertySets.playersPropertySets)
{
foreach (Card c in ps.properties)
{
playersTotalValue += c.cardValue;
}
if (ps.hasHouse)
{
playersTotalValue += ps.house.cardValue;
if (ps.hasHotel)
{
playersTotalValue += ps.hotel.cardValue;
}
}
}
if (playersTotalValue >= amountOwed)
{
//Player has enough cards to pay
return true;
}
else
{
//Player does not have enough cards to pay
return false;
}
}
/// <summary>
/// Moves a property card that has been played to a set to a new set
/// </summary>
/// <param name="currentState"></param>
/// <param name="nextState"></param>
/// <param name="playerPerformingAction"></param>
/// <param name="moveInformation"></param>
/// <param name="rearrangeProperties"></param>
/// <returns></returns>
private BoolResponseBox movePropertyCard(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, MoveInfo moveInformation, Statephase rearrangeProperties)
{
//Clone the current state to create next state
nextState = currentState.clone(generateGuidForNextState());
PropertyColor oldColour = ((PropertyCard)currentState.deck.getCardByID(moveInformation.idOfCardBeingUsed)).getPropertyColor();
bool oldOrientation = ((PropertyCard)currentState.deck.getCardByID(moveInformation.idOfCardBeingUsed)).isCardUp;
((PropertyCard)nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed)).setPropertyColor(moveInformation.isPropertyToMoveOrientedUp);
if (moveInformation.addPropertyToMoveToExistingSet == false || getPropertyCardSet(getPlayerModel(playerPerformingAction.guid, nextState).propertySets, moveInformation.guidOfExistingSetToMovePropertyTo).isPropertyCompatible((PropertyCard)nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed)))
{
//Get CurrentPlayFieldModelState
PropertyCard propertyCardToMove = nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed) as PropertyCard;
PlayerModel player = getPlayerModel(playerPerformingAction.guid, nextState);
//Remove Property Card from it's current set.
PropertyCard property = player.removePropertyCardFromPlayersPropertySet(propertyCardToMove, moveInformation.guidOfSetPropertyToMoveIsIn);
if (property != null)
{
PropertyCard cP = propertyCardToMove;
bool propertyAdded = false;
cP.setPropertyColor(moveInformation.isPropertyToPlayOrientedUp);
PropertyCardSet ps = getPropertyCardSet(player.propertySets, moveInformation.guidOfExistingSetToMovePropertyTo);
if (moveInformation.addPropertyToMoveToExistingSet == false)
{
player.propertySets.addSet(new PropertyCardSet(cP));
}
else if (ps == null)
{
//card was intended to be played to an existing set
return new BoolResponseBox(false, "Property not moved. Selected set does not exist");
}
else if (ps != null)
{
propertyAdded = ps.addProperty(cP);
}
if (propertyAdded == false)
{
return new BoolResponseBox(false, "Property Card not played. Set full or card incompatible.");
}
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = rearrangeProperties;
List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has moved a Property to a existing set " + propertyCardToMove.cardName);
}
return new BoolResponseBox(false, "Card is not in set.");
}
else
{
nextState = null;
((PropertyCard)currentState.deck.getCardByID(moveInformation.idOfCardBeingUsed)).setPropertyColor(oldOrientation);//change back the orientation of the property
return new BoolResponseBox(false, "Property Card is not the correct colour to be added to this set");
}
}
/// <summary>
/// If a Player is unable to pay a debt as they do not have cards at least equal to the debt this method takes all the players cards.
/// </summary>
/// <param name="player">Player to take Cards from</param>
/// <returns>List of Cards taken</returns>
private List<Card> takeAllCardsFromPlayer(PlayerModel player)
{
List<Card> cardsTaken = new List<Card>();
//Find players net worth to see if they have payed everthing they have
while (player.bank.cardsInBank.Count > 0)
{
Card c = player.bank.cardsInBank.Last();
Card card = player.bank.removeCardFromBank(c);
if (card != null)
{
cardsTaken.Add(card);
}
}
/* Cannot remove objects from set being iterated over in foreach loop
foreach (Card c in player.bank.cardsInBank)
{
Card card = player.bank.removeCardFromBank(c);
if (card != null)
{
cardsTaken.Add(card);
}
}
* */
while (player.propertySets.playersPropertySets.Count > 0)
{
PropertyCardSet ps = player.propertySets.playersPropertySets.Last();
foreach (Card c in ps.properties)
{
cardsTaken.Add(c);
}
if (ps.hasHouse)
{
cardsTaken.Add(ps.removeHouse());
if (ps.hasHotel)
{
cardsTaken.Add(ps.removeHotel());
}
}
//player property set now empty remove the set from the player
player.propertySets.removeEmptySet(ps);
}
return cardsTaken;
/* As the sets are being removed in foreach the code is invalid
foreach (PropertyCardSet ps in player.propertySets.playersPropertySets)
{
foreach (Card c in ps.properties)
{
cardsTaken.Add(c);
}
if (ps.hasHouse)
{
cardsTaken.Add(ps.removeHouse());
if (ps.hasHotel)
{
cardsTaken.Add(ps.removeHotel());
}
}
//player property set now empty remove the set from the player
player.propertySets.removeEmptySet(ps);
}
return cardsTaken;
* */
}
/// <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");
}
}
/// <summary>
/// Allows a player to pay their debt owing from rent, birthday or debt collector cards
/// </summary>
/// <param name="currentState"></param>
/// <param name="nextState"></param>
/// <param name="playerPerformingAction"></param>
/// <param name="moveInformation"></param>
/// <param name="justSayNoAble"></param>
/// <param name="notJustSayNoAble"></param>
/// <returns></returns>
private BoolResponseBox payDebt(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, MoveInfo moveInformation, Statephase justSayNoAble, Statephase notJustSayNoAble)
{
//Check
//Perform action in next state
//Clone the current state to create next state then draws 5 cards in the next state
nextState = currentState.clone(generateGuidForNextState());
//Player Paying Debt
PlayerModel playerModelForPlayerPaying = getPlayerModel(playerPerformingAction.guid, nextState);
//Player Being paid debt
PlayerModel playerModelForPlayerToBePaid = getPlayerModel(moveInformation.guidOfPlayerToPayDebtTo, nextState);
//Get all the cards the player intends to pay with
List<Card> cardsToUseToPayDebt = new List<Card>();
foreach (int i in moveInformation.listOfIDsOfCardsBeingUsedToPayDebt)
{
Card card = nextState.deck.getCardByID(i);
if (card is PropertyCard)
{
PropertyCard property = (PropertyCard)card;
if (playerModelForPlayerPaying.removePropertyCardFromPlayersPropertySets(property) != null)
{
//Property was in set and has been removed
cardsToUseToPayDebt.Add(property);
}
}
else if (playerModelForPlayerPaying.bank.removeCardFromBank(card) != null)
{
//not a propertyCard
cardsToUseToPayDebt.Add(card);
}
}
bool otherPlayersPaying = false;
//Get if player paying is the only player who has to pay
foreach (PlayerModel player in nextState.playerModels)
{
if (player.guid.CompareTo(playerModelForPlayerPaying.guid) != 0 && player.owesAnotherPlayer)
{
//Another player owes money
otherPlayersPaying = true;
break;
}
}
//Determine if payment is sufficent
//Value of all cards must be at least the same as the debt owed or must be every property, house, hotel, banked card the player has
int valueOfPayment = 0;
foreach (Card c in cardsToUseToPayDebt)
{
valueOfPayment += c.cardValue;
}
if (valueOfPayment < moveInformation.amountOwed)
{
if (hasPlayerEnoughCardsToPayFullValue(playerModelForPlayerPaying, moveInformation.amountOwed))
{
return new BoolResponseBox(false, "Player has enough played cards to pay debt but has not selected enough to pay.");
}
else
{
//Player does not have enough to pay. Take all players played cards
cardsToUseToPayDebt = takeAllCardsFromPlayer(playerModelForPlayerPaying);
}
}
//put properties used as payment into new sets for player being paid and put money and actioncards into player being paids bank
foreach (Card card in cardsToUseToPayDebt)
{
if (card is PropertyCard)
{
playerModelForPlayerPaying.removePropertyCardFromPlayersPropertySets((PropertyCard)card);
playerModelForPlayerToBePaid.propertySets.addSet(new PropertyCardSet((PropertyCard)card));
}
else
{
removeCardFromHand(card, playerModelForPlayerPaying);
playerModelForPlayerToBePaid.bank.addCardToBank(card);
}
}
//Player has now paid debt
playerModelForPlayerPaying.owesAnotherPlayer = false;
playerModelForPlayerPaying.amountOwedToAnotherPlayer = 0;
//Update the state
//Change state on success
//has been performed, advance the phase of the game
Statephase nextStatePhaseIfSuccessful;
if (otherPlayersPaying)
{
//Other players must pay so states phase does not change
nextStatePhaseIfSuccessful = nextState.currentPhase;
}
else
{
//No other players have to pay debt
if (currentState.actionCardEvent != null && currentState.actionCardEvent.doubleTheRentCardUsed)
{
if (notJustSayNoAble.CompareTo(Statephase.Turn_Started_Cards_Drawn_1_Cards_Played) == 0)
{
//zero cards played before turn. Advance to 2 cards played as double the rent counts as a card played
nextStatePhaseIfSuccessful = Statephase.Turn_Started_Cards_Drawn_2_Cards_Played;
}
else if (notJustSayNoAble.CompareTo(Statephase.Turn_Started_Cards_Drawn_2_Cards_Played) == 0)
{
//one card played before turn. Advance to 3 cards played as double the rent counts as a card played
nextStatePhaseIfSuccessful = Statephase.Turn_Started_Cards_Drawn_3_Cards_Played_Swap_Properties_Or_End_Turn_Only;
}
else
{
//Double the rent card should not have been used
throw new Exception("Invalid State");
}
}
else
{
nextStatePhaseIfSuccessful = notJustSayNoAble;
}
}
nextState.currentPhase = nextStatePhaseIfSuccessful;
if (nextStatePhaseIfSuccessful.CompareTo(Statephase.Turn_Started_Cards_Drawn_1_Cards_Played) == 0 || nextStatePhaseIfSuccessful.CompareTo(Statephase.Turn_Started_Cards_Drawn_2_Cards_Played) == 0 || nextStatePhaseIfSuccessful.CompareTo(Statephase.Turn_Started_Cards_Drawn_3_Cards_Played_Swap_Properties_Or_End_Turn_Only) == 0)
{
List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
}
else
{
List<TurnActionTypes> notInDebt = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
List<TurnActionTypes> inDebt = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
inDebt = setAllowableActionsNotOnTurnInDebt(inDebt, nextState);
updateAllowableStatesDebtPaid(nextState, notInDebt, onTurn, nextState.guidOfPlayerWhosTurnItIs, inDebt);
}
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has paid");
}
/// <summary>
/// Allows a player on their turn to play a Pass Go card
/// </summary>
/// <param name="currentState"></param>
/// <param name="nextState"></param>
/// <param name="playerPerformingAction"></param>
/// <param name="nextStatePhaseIfSuccessful"></param>
/// <param name="passGoInfo"></param>
/// <returns></returns>
public BoolResponseBox playActionCardPassGo(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, Statephase nextStatePhaseIfSuccessful, MoveInfo passGoInfo)
{
//Check
//Perform action in next state
//Clone the current state to create next state then draws 5 cards in the next state
nextState = currentState.clone(generateGuidForNextState());
PlayerModel playerModelForPlayer = getPlayerModel(playerPerformingAction.guid, nextState);
Card cardInHandToBePlayed = nextState.deck.getCardByID(passGoInfo.idOfCardBeingUsed);
//Get the reference to the players playerModel in the current PlayFieldModel
PlayerModel player = getPlayerModel(passGoInfo.playerMakingMove, nextState);
//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(nextState.drawPile.drawcard());
player.hand.addCardToHand(nextState.drawPile.drawcard());
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = nextStatePhaseIfSuccessful;
//Put card in discard pile
nextState.playpile.playCardOnPile(card);
List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has passed go and drawn 2 cards");
}
return new BoolResponseBox(false, "Card is not in hand.");
}
return new BoolResponseBox(false, "Card is not in hand or is not a pass go card");
}
/// <summary>
/// Allows a player on their turn to Play A Debt Collector Action Card
/// </summary>
/// <param name="currentState"></param>
/// <param name="nextState"></param>
/// <param name="playerPerformingAction"></param>
/// <param name="nextStatePhaseIfSuccessful"></param>
/// <param name="debtCollectorInfo"></param>
/// <returns></returns>
private BoolResponseBox playActionCardDebtCollector(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, Statephase nextStatePhaseIfSuccessful, MoveInfo debtCollectorInfo)
{
//Check
//Perform action in next state
//Clone the current state to create next state then draws 5 cards in the next state
nextState = currentState.clone(generateGuidForNextState());
PlayerModel playerModelForPlayer = getPlayerModel(playerPerformingAction.guid, nextState);
PlayerModel playerModelForPlayerToDebtCollect = getPlayerModel(debtCollectorInfo.guidOfPlayerBeingDebtCollected, nextState);
Card cardInHandToBePlayed = nextState.deck.getCardByID(debtCollectorInfo.idOfCardBeingUsed);
//Get the reference to the players playerModel in the current PlayFieldModel
//Get the reference to the Card in the current PlayFieldModel
if (cardInHandToBePlayed != null && cardInHandToBePlayed is ActionCard && ((ActionCard)cardInHandToBePlayed).actionType.CompareTo(ActionCardAction.DebtCollector) == 0)
{
Card card = removeCardFromHand(cardInHandToBePlayed, playerModelForPlayer);
if (card != null)
{
ActionCard actionCard = card as ActionCard;
//Do action
playerModelForPlayerToDebtCollect.owesAnotherPlayer = true;
playerModelForPlayerToDebtCollect.amountOwedToAnotherPlayer = ActionCard.Debt_Collector_Value;
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = nextStatePhaseIfSuccessful;
//Put card in discard pile
nextState.playpile.playCardOnPile(actionCard);
List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStatesDebtPaid(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, setAllowableActionsNotOnTurnInDebt(new List<TurnActionTypes>(), nextState));
nextState.actionCardEvent = new ActionCardEvent();
nextState.actionCardEvent.actionTypeTaken = TurnActionTypes.PlayActionCard;
nextState.actionCardEvent.actionCardTypeUsed = ActionCardAction.DebtCollector;
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has used a Debt Collector");
}
return new BoolResponseBox(false, "Card is not in hand.");
}
return new BoolResponseBox(false, "Card is not in hand or is not a Debt Collector card");
}
/// <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());
}
}
/// <summary>
/// Plays a debt collector cards effect again after it being canceled then uncanceled by Just Say No Cards
/// </summary>
/// <param name="currentState"></param>
/// <param name="nextState"></param>
/// <param name="playerPerformingAction"></param>
/// <param name="nextStatePhaseIfSuccessful"></param>
/// <param name="debtCollectorInfo"></param>
/// <returns></returns>
private BoolResponseBox replayActionCardDebtCollector(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, Statephase nextStatePhaseIfSuccessful, MoveInfo debtCollectorInfo)
{
//Check
//Perform action in next state
//Clone the current state to create next state
nextState = currentState.clone(generateGuidForNextState());
PlayerModel playerModelForPlayer = getPlayerModel(nextState.guidOfPlayerWhosTurnItIs, nextState);
PlayerModel playerModelForPlayerToDebtCollect = getPlayerModel(debtCollectorInfo.guidOfPlayerBeingDebtCollected, nextState);
//Get the reference to the players playerModel in the current PlayFieldModel
//Do action
playerModelForPlayerToDebtCollect.owesAnotherPlayer = true;
playerModelForPlayerToDebtCollect.amountOwedToAnotherPlayer = ActionCard.Debt_Collector_Value;
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = nextStatePhaseIfSuccessful;
List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStatesDebtPaid(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, setAllowableActionsNotOnTurnInDebt(new List<TurnActionTypes>(), nextState));
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Debt Collector replayed after Just Say No");
}
private BoolResponseBox playActionCardHouse(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, Statephase nextStatePhase, MoveInfo moveInformation)
{
//Check
//Perform action in next state
//Clone the current state to create next state then draws 5 cards in the next state
nextState = currentState.clone(generateGuidForNextState());
PlayerModel playerModelForPlayer = getPlayerModel(playerPerformingAction.guid, nextState);
Card cardInHandToBePlayed = nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed);
//Get the reference to the players playerModel in the current PlayFieldModel
//Get the reference to the Card in the current PlayFieldModel
if (cardInHandToBePlayed != null && cardInHandToBePlayed is ActionCard && ((ActionCard)cardInHandToBePlayed).actionType.CompareTo(ActionCardAction.House) == 0)
{
Card card = removeCardFromHand(cardInHandToBePlayed, playerModelForPlayer);
if (card != null)
{
ActionCard actionCard = card as ActionCard;
PropertyCardSet ps = getPropertyCardSet(playerModelForPlayer.propertySets, moveInformation.guidFullSetToAddHouseTo);
if (ps != null)
{
if (ps.addHouse(actionCard))
{
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = nextStatePhase;
//Put card in discard pile
nextState.playpile.playCardOnPile(actionCard);
List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has added a house to a set");
}
else
{
return new BoolResponseBox(false, "House can not be added to this set");
}
}
return new BoolResponseBox(false, "Set does not exist");
}
return new BoolResponseBox(false, "Card is not in hand.");
}
return new BoolResponseBox(false, "Card is not in hand or is not a House card");
}
/// <summary>
/// Allows a Player to discard one card from their Hand when they have finished thier turn with more than the max allowable cards in hand
/// </summary>
/// <param name="currentState"></param>
/// <param name="nextState"></param>
/// <param name="playerPerformingAction"></param>
/// <param name="moveInformation"></param>
/// <param name="notJustSayNoAble"></param>
/// <returns></returns>
private BoolResponseBox discard1Card(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, MoveInfo moveInformation, Statephase notJustSayNoAble)
{
//Clone the current state to create next state then draws two cards in the next state
nextState = currentState.clone(generateGuidForNextState());
Card cardInHandToBeDiscarded = nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed);
//Get the reference to the players playerModel in the current PlayFieldModel
PlayerModel playerWhoIsDiscardingCard = getPlayerModel(playerPerformingAction.guid, nextState);
//Get the reference to the Card in the current PlayFieldModel
Card card = removeCardFromHand(cardInHandToBeDiscarded, playerWhoIsDiscardingCard);
if (card != null)
{
nextState.drawPile.discardCard(card);
//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 (playerWhoIsDiscardingCard.hand.cardsInHand.Count)
{
case 8:
{
nextState.currentPhase = Statephase.Turn_Ended_8_Cards_In_Hand_Discard_1_Card;
onTurn.Add(TurnActionTypes.Discard_1_Card);
//Update the moves for players
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Ended their turn with 8 cards and must discard 1 card");
}
case 9:
{
nextState.currentPhase = Statephase.Turn_Ended_9_Cards_In_Hand_Discard_2_Cards;
onTurn.Add(TurnActionTypes.Discard_1_Card);
//Update the moves for players
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Ended their turn with 9 cards and must discard 2 cards");
}
case 10:
{
nextState.currentPhase = Statephase.Turn_Ended_10_Cards_In_Hand_Discard_3_Cards;
onTurn.Add(TurnActionTypes.Discard_1_Card);
//Update the moves for players
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Ended their turn with 10 cards and must discard 3 cards");
}
case 11:
{
nextState.currentPhase = Statephase.Turn_Ended_11_Cards_In_Hand_Discard_4_Cards;
onTurn.Add(TurnActionTypes.Discard_1_Card);
//Update the moves for players
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Ended their turn with 11 cards and must discard 4 cards");
}
case 12:
{
nextState.currentPhase = Statephase.Turn_Ended_12_Cards_In_Hand_Discard_5_Cards;
onTurn.Add(TurnActionTypes.Discard_1_Card);
//Update the moves for players
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Ended their turn with 12 cards and must discard 5 cards");
}
default:
{
nextState.currentPhase = Statephase.Turn_Ended_7_Or_Less_Cards_In_Hand_Setup_NextPlayer;
setNextPlayerOnTurn(nextState);
if (getPlayerModel(nextState.guidOfPlayerWhosTurnItIs, nextState).hand.cardsInHand.Count == 0)
{
//Player has 0 cards draws 5 on turn start instead of 2
nextState.currentPhase = Statephase.Turn_Started_Draw_5_Cards;
onTurn.Add(TurnActionTypes.drawFiveCardsAtStartOfTurn);
//Update the moves for players
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Ended their turn." + "Player:" + getPlayerModel(nextState.guidOfPlayerWhosTurnItIs, nextState).name + "\'s Turn. Draw 5 Cards.");
}
else
{
//Player has at least one and at most seven cards, draws 2
nextState.currentPhase = Statephase.Turn_Started_Draw_2_Cards;
onTurn.Add(TurnActionTypes.drawTwoCardsAtStartOfTurn);
//Update the moves for players
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Ended their turn." + "Player:" + getPlayerModel(nextState.guidOfPlayerWhosTurnItIs, nextState).name + "\'s Turn. Draw 2 Cards.");
}
}
}
}
else
{
//Card not in players hand, can't be discarded
return new BoolResponseBox(false, "Card not in hand");
}
}
private BoolResponseBox playActionCardForcedDeal(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, Statephase nextStatePhase, MoveInfo moveInformation)
{
//Check
//Perform action in next state
//Clone the current state to create next state then draws 5 cards in the next state
nextState = currentState.clone(generateGuidForNextState());
PlayerModel playerModelForPlayer = getPlayerModel(playerPerformingAction.guid, nextState);
PlayerModel playerModelForPlayerToForcedDeal = getPlayerModel(moveInformation.guidOfPlayerWhoIsBeingForcedDealed, nextState);
Card cardInHandToBePlayed = nextState.deck.getCardByID(moveInformation.idOfCardBeingUsed);
//Get the reference to the players playerModel in the current PlayFieldModel
//Get the reference to the Card in the current PlayFieldModel
if (cardInHandToBePlayed != null && cardInHandToBePlayed is ActionCard && ((ActionCard)cardInHandToBePlayed).actionType.CompareTo(ActionCardAction.ForcedDeal) == 0)
{
Card card = removeCardFromHand(cardInHandToBePlayed, playerModelForPlayer);
if (card != null)
{
ActionCard actionCard = card as ActionCard;
//Do action
PropertyCardSet setToForcedDealFrom = getPropertyCardSet(playerModelForPlayerToForcedDeal.propertySets, moveInformation.guidOfSetCardToBeForcedDealedIsIn);
PropertyCard cardToForcedDealFor = nextState.deck.getCardByID(moveInformation.idOfCardToBeForcedDealed) as PropertyCard;
PropertyCardSet setToGiveUpCardFrom = getPropertyCardSet(playerModelForPlayer.propertySets, moveInformation.guidOfSetCardGivenUpInForcedDealIsIn);
PropertyCard cardToGiveUp = nextState.deck.getCardByID(moveInformation.idOfCardToBeGivenUpInForcedDeal) as PropertyCard;
if (setToForcedDealFrom != null && cardToForcedDealFor != null && setToGiveUpCardFrom != null && cardToGiveUp != null)
{
if (playerModelForPlayerToForcedDeal.removePropertyCardFromPlayersPropertySet(cardToForcedDealFor, moveInformation.guidOfSetCardToBeForcedDealedIsIn) != null)
{
//Card Removed from set
//Create new set with card Forced Dealed in it
PropertyCardSet newSetForcedDealCard = new PropertyCardSet(cardToForcedDealFor);
playerModelForPlayer.propertySets.addSet(newSetForcedDealCard);
if (playerModelForPlayer.removePropertyCardFromPlayersPropertySet(cardToGiveUp, moveInformation.guidOfSetCardGivenUpInForcedDealIsIn) != null)
{
//Forced dealed player recieves card given up in forced deal
PropertyCardSet newSetGivenUpCard = new PropertyCardSet(cardToGiveUp);
playerModelForPlayerToForcedDeal.propertySets.addSet(newSetGivenUpCard);
playerModelForPlayerToForcedDeal.hasHadCardsTaken = true;
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = nextStatePhase;
//Put card in discard pile
nextState.playpile.playCardOnPile(actionCard);
List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
nextState.actionCardEvent = new ActionCardEvent();
nextState.actionCardEvent.playerAffectedByAction = moveInformation.guidOfPlayerWhoIsBeingForcedDealed;
nextState.actionCardEvent.playerWhoPerformedActionOffTurn = moveInformation.playerMakingMove;
nextState.actionCardEvent.playerOnTurnPerformingAction = true;
nextState.actionCardEvent.actionTypeTaken = TurnActionTypes.PlayActionCard;
nextState.actionCardEvent.actionCardTypeUsed = ActionCardAction.ForcedDeal;
List<CardIDSetGuid> listOfCardsForcedDealed = new List<CardIDSetGuid>();
listOfCardsForcedDealed.Add(new CardIDSetGuid(moveInformation.idOfCardToBeForcedDealed, moveInformation.guidOfSetCardToBeForcedDealedIsIn));
nextState.actionCardEvent.propertyCardsTakenFromPlayerAndSetTheCardWasIn = listOfCardsForcedDealed;
nextState.actionCardEvent.propertyCardGivenUpInForcedDeal = new CardIDSetGuid(moveInformation.idOfCardToBeGivenUpInForcedDeal, moveInformation.guidOfSetCardGivenUpInForcedDealIsIn);
//change the current state to the next state
updateAllowableStatesPerPlayerCardsTaken(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, setAllowableActionsNotOnTurnCardsTaken(new List<TurnActionTypes>(), nextState));
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has used a Forced Deal Card");
}
else
{
return new BoolResponseBox(false, "Unable to remove card to be given up");
}
}
else
{
return new BoolResponseBox(false, "Unable to remove card from player being forced dealed set");
}
}
else
{
return new BoolResponseBox(false, "Card to Forced Deal or set the card is in does not exist");
}
}
return new BoolResponseBox(false, "Card is not in hand.");
}
return new BoolResponseBox(false, "Card is not in hand or is not a Forced Deal Card");
}
/// <summary>
/// Plays a Card from a Players Hand on their turn to their Bank
/// </summary>
/// <param name="currentState"></param>
/// <param name="nextState"></param>
/// <param name="playerPerformingAction"></param>
/// <param name="moveInformation"></param>
/// <param name="notJustSayNoAble"></param>
/// <returns></returns>
private BoolResponseBox playCardFromHandToBank(PlayFieldModel currentState, PlayFieldModel nextState, PlayerModel playerPerformingAction, MoveInfo moveInformation, Statephase notJustSayNoAble)
{
//Check
//Perform action in next state
//Clone the current state to create next state
nextState = currentState.clone(generateGuidForNextState());
PlayerModel playerModelForPlayer = getPlayerModel(playerPerformingAction.guid, nextState);
Card cardInHandToBePlayed = currentState.deck.getCardByID(moveInformation.idOfCardBeingUsed);
//Get the reference to the players playerModel in the current PlayFieldModel
PlayerModel player = getPlayerModel(moveInformation.playerMakingMove, nextState);
//Get the reference to the Card in the current PlayFieldModel
if (cardInHandToBePlayed != null)
{
Card card = removeCardFromHand(cardInHandToBePlayed, player);
if (card != null)
{
player.bank.addCardToBank(card);
//Change state on success
//has been performed, advance the phase of the game
nextState.currentPhase = notJustSayNoAble;
List<TurnActionTypes> notOnTurn = new List<TurnActionTypes>();
List<TurnActionTypes> onTurn = new List<TurnActionTypes>();
onTurn = setAllowableActionsOnTurn(onTurn, nextState);
updateAllowableStates(nextState, notOnTurn, onTurn, nextState.guidOfPlayerWhosTurnItIs, nextState.guidOfPlayerWhosTurnItIs);
//change the current state to the next state
addNextState(nextState);
return new BoolResponseBox(true, "Player:" + playerPerformingAction.name + " Has banked " + card.cardName);
}
return new BoolResponseBox(false, "Card is not in hand.");
}
return new BoolResponseBox(false, "Card id does not exist");
}
