|
private DrawAdditionalCardsIntoHand ( int count, |
||
| count | int | |
| gameState | ||
| return | void | |
public override bool DoSpecializedTrash(PlayerState selfPlayer, GameState gameState)
{
selfPlayer.DrawAdditionalCardsIntoHand(3, gameState);
return true;
}
private void GainBenefitFromCard(Card card, PlayerState currentPlayer)
{
if (card.isAction)
{
currentPlayer.AddActions(2);
}
if (card.isTreasure)
{
currentPlayer.AddCoins(2);
}
if (card.isVictory)
{
currentPlayer.DrawAdditionalCardsIntoHand(2);
}
}
public override void DoSpecializedDurationActionAtBeginningOfTurn(PlayerState currentPlayer, GameState gameState)
{
currentPlayer.DrawAdditionalCardsIntoHand(2);
currentPlayer.AddBuys(1);
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
for (int i = 0; i < 3; ++i)
{
Card cardPlayed = gameState.DoPlayOneTreasure(currentPlayer);
if (cardPlayed == null)
break;
}
currentPlayer.DrawAdditionalCardsIntoHand(currentPlayer.AvailableCoins, gameState);
currentPlayer.turnCounters.RemoveCoins(currentPlayer.turnCounters.AvailableCoins);
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
if (currentPlayer.RequestPlayerDiscardCardFromHand(gameState, card => card.isTreasure, isOptional: true))
{
currentPlayer.DrawAdditionalCardsIntoHand(3);
currentPlayer.AddActions(1);
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
PlayerActionChoice playerChoice = currentPlayer.RequestPlayerChooseBetween(gameState, acceptableChoice =>
acceptableChoice == PlayerActionChoice.GainCard ||
acceptableChoice == PlayerActionChoice.PlusCard ||
acceptableChoice == PlayerActionChoice.Trash);
switch (playerChoice)
{
case PlayerActionChoice.PlusCard:
{
currentPlayer.DrawAdditionalCardsIntoHand(3, gameState);
foreach (PlayerState otherPlayer in gameState.players.OtherPlayers)
{
otherPlayer.DrawAdditionalCardsIntoHand(1, gameState);
}
break;
}
case PlayerActionChoice.GainCard:
{
currentPlayer.GainCardFromSupply(gameState, Gold.card);
foreach (PlayerState otherPlayer in gameState.players.OtherPlayers)
{
otherPlayer.GainCardFromSupply(gameState, Silver.card);
}
break;
}
case PlayerActionChoice.Trash:
{
currentPlayer.RequestPlayerTrashCardFromHandAndGainCard(
gameState,
acceptableCardsToTrash => true,
CostConstraint.Exactly,
2,
CardRelativeCost.RelativeCost,
isOptionalToTrash: true,
isOptionalToGain: false);
foreach (PlayerState otherPlayer in gameState.players.OtherPlayers)
{
otherPlayer.RequestPlayerTrashCardFromHandAndGainCard(
gameState,
acceptableCardsToTrash => true,
CostConstraint.Exactly,
1,
CardRelativeCost.RelativeCost,
isOptionalToTrash: true,
isOptionalToGain: false);
}
break;
}
}
}
public override void DoSpecializedTrash(PlayerState currentPlayer, GameState gameState)
{
currentPlayer.DrawAdditionalCardsIntoHand(1);
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
if (!currentPlayer.CardsInPlay.Where(card => card == CrossRoads.card).Any())
{
currentPlayer.AddActions(3);
}
int countVictoryCards = currentPlayer.hand.Count(card => card.isVictory);
currentPlayer.DrawAdditionalCardsIntoHand(countVictoryCards);
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
if (currentPlayer.MoveCardFromPlayToPile(gameState))
{
currentPlayer.DrawAdditionalCardsIntoHand(currentPlayer.Hand.Count);
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
bool[] otherPlayersAffectedByAttacks = new bool[gameState.players.OtherPlayers.Count()];
// from rule book
// "Players responding to this attack must choose to do so before you decide whether or not to trash 2 cards"
int otherIndex = 0;
foreach (PlayerState otherPlayer in gameState.players.OtherPlayers)
{
otherPlayersAffectedByAttacks[otherIndex++] = otherPlayer.IsAffectedByAttacks(gameState);
}
if (currentPlayer.RequestPlayerTrashCardsFromHand(gameState, 2, isOptional: true, allOrNone:true).Length == 2)
{
currentPlayer.DrawAdditionalCardsIntoHand(2);
currentPlayer.AddCoins(2);
otherIndex = 0;
foreach (PlayerState otherPlayer in gameState.players.OtherPlayers)
{
if (otherPlayersAffectedByAttacks[otherIndex++])
{
otherPlayer.RequestPlayerDiscardDownToCountInHand(gameState, 3);
}
}
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
currentPlayer.RevealCardsFromDeck(3);
PlayerActionChoice choice = currentPlayer.RequestPlayerChooseBetween(gameState, actionChoice => actionChoice == PlayerActionChoice.Discard || actionChoice == PlayerActionChoice.PutInHand);
switch (choice)
{
case PlayerActionChoice.Discard:
{
currentPlayer.MoveRevealedCardsToDiscard(gameState);
currentPlayer.DrawAdditionalCardsIntoHand(3);
break;
}
case PlayerActionChoice.PutInHand:
{
currentPlayer.MoveAllRevealedCardsToHand();
break;
}
default:
throw new Exception();
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
int discardedCount = currentPlayer.RequestPlayerDiscardCardsFromHand(gameState, currentPlayer.Hand.Count, isOptional:true);
currentPlayer.DrawAdditionalCardsIntoHand(discardedCount);
discardedCount = currentPlayer.RequestPlayerDiscardCardsFromHand(gameState, currentPlayer.Hand.Count, isOptional: true);
currentPlayer.AddCoins(discardedCount);
// TODO: How does the player know they are discarding for coins or for card?
// throw new NotImplementedException();
}
private static void ApplyChoice(PlayerActionChoice choice, PlayerState currentPlayer, GameState gameState)
{
switch (choice)
{
case PlayerActionChoice.PlusCard: currentPlayer.DrawAdditionalCardsIntoHand(2, gameState); break;
case PlayerActionChoice.PlusAction: currentPlayer.AddActions(2); break;
case PlayerActionChoice.PlusCoin: currentPlayer.AddCoins(2); break;
case PlayerActionChoice.GainCard: currentPlayer.GainCardsFromSupply(gameState, Cards.Silver, 4); break;
default: throw new Exception();
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
currentPlayer.RevealHand();
if (currentPlayer.hand.HasDuplicates())
{
currentPlayer.DrawOneCardIntoHand();
}
else
{
currentPlayer.DrawAdditionalCardsIntoHand(3);
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
// Choose one: ...
PlayerActionChoice actionChoice = currentPlayer.RequestPlayerChooseBetween(
gameState,
acceptableChoice => acceptableChoice == PlayerActionChoice.Discard || acceptableChoice == PlayerActionChoice.PlusCoin);
PlayerState.AttackAction attackAction = this.DoEmptyAttack;
if (actionChoice == PlayerActionChoice.PlusCoin)
{
// +2 coin;
currentPlayer.AddCoins(2);
}
else
{
// discard your hand,
currentPlayer.DiscardHand(gameState);
// +4 cards
currentPlayer.DrawAdditionalCardsIntoHand(4);
attackAction = this.DoSpecializedAttackInternal;
}
currentPlayer.AttackOtherPlayers(gameState, attackAction);
}
public override void DoSpecializedAttack(PlayerState currentPlayer, PlayerState otherPlayer, GameState gameState)
{
if (otherPlayer.GainCardFromSupply(Curse.card, gameState))
{
otherPlayer.DrawAdditionalCardsIntoHand(1, gameState);
}
}
private void DoSpecializedAttackInternal(PlayerState currentPlayer, PlayerState otherPlayer, GameState gameState)
{
// with at least 5 cards in hand
if (otherPlayer.hand.Count >= 5)
{
// discards his hand
otherPlayer.DiscardHand(gameState);
// and draws 4 cards
otherPlayer.DrawAdditionalCardsIntoHand(4);
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
if (currentPlayer.RequestPlayerTrashCardFromHand(gameState, card => card.isTreasure, isOptional:true) != null)
{
PlayerActionChoice choice = currentPlayer.RequestPlayerChooseBetween(
gameState,
acceptableChoice => acceptableChoice == PlayerActionChoice.PlusCard || acceptableChoice == PlayerActionChoice.PlusCoin);
switch (choice)
{
case PlayerActionChoice.PlusCard:
{
currentPlayer.DrawAdditionalCardsIntoHand(2);
currentPlayer.AddActions(1);
break;
}
case PlayerActionChoice.PlusCoin:
{
currentPlayer.AddCoins(2);
currentPlayer.AddBuys(1);
break;
}
default:
throw new Exception();
}
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
PlayerActionChoice actionChoice = currentPlayer.RequestPlayerChooseBetween(
gameState,
acceptableChoice => acceptableChoice == PlayerActionChoice.PlusCard || acceptableChoice == PlayerActionChoice.PlusAction);
if (actionChoice == PlayerActionChoice.PlusCard)
{
currentPlayer.DrawAdditionalCardsIntoHand(3);
}
else
{
currentPlayer.AddActions(2);
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
int countCardsDiscarded = 0;
while (!currentPlayer.hand.IsEmpty)
{
if (!currentPlayer.RequestPlayerDiscardCardFromHand(gameState, acceptableCard => true, isOptional: true))
{
break;
}
++countCardsDiscarded;
}
currentPlayer.DrawAdditionalCardsIntoHand(countCardsDiscarded);
}
public override bool DoReactionToAttackWhileInHand(PlayerState currentPlayer, GameState gameState, out bool cancelsAttack)
{
cancelsAttack = false;
if (currentPlayer.actions.ShouldRevealCardFromHand(gameState, this))
{
currentPlayer.DrawAdditionalCardsIntoHand(2);
for (int i = 0; i < 2; ++i)
{
currentPlayer.RequestPlayerTopDeckCardFromHand(gameState, acceptableCard => true, false);
}
return true;
}
else
{
return false;
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
Card card = currentPlayer.RequestPlayerTrashCardFromHand(gameState, acceptableCard => true, isOptional: false);
if (card != null)
{
int cardsToDraw = card.CurrentCoinCost(currentPlayer) + 2 * card.potionCost;
currentPlayer.DrawAdditionalCardsIntoHand(cardsToDraw, gameState);
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
currentPlayer.RevealHand();
if (!currentPlayer.hand.Where(card => card.isAction).Any())
{
currentPlayer.DrawAdditionalCardsIntoHand(2);
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
currentPlayer.numberOfCardsToBeDrawn = 0;
while (!currentPlayer.hand.IsEmpty)
{
if (!currentPlayer.RequestPlayerDiscardCardFromHand(gameState, acceptableCard => true, isOptional: true))
{
break;
}
++currentPlayer.numberOfCardsToBeDrawn;
}
currentPlayer.DrawAdditionalCardsIntoHand(currentPlayer.numberOfCardsToBeDrawn, gameState);
currentPlayer.numberOfCardsToBeDrawn = 0;
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
PlayerActionChoice actionChoice = currentPlayer.RequestPlayerChooseBetween(
gameState,
acceptableChoice => acceptableChoice == PlayerActionChoice.PlusCard ||
acceptableChoice == PlayerActionChoice.PlusCoin ||
acceptableChoice == PlayerActionChoice.Trash);
switch (actionChoice)
{
case PlayerActionChoice.PlusCard: currentPlayer.DrawAdditionalCardsIntoHand(2); break;
case PlayerActionChoice.PlusCoin: currentPlayer.AddCoins(2); break;
case PlayerActionChoice.Trash: currentPlayer.RequestPlayerTrashCardsFromHand(gameState, 2, false); break;
default: throw new Exception("Invalid case");
}
}
private void DoNowAndAtStartOfTurn(PlayerState currentPlayer, GameState gameState)
{
currentPlayer.DrawAdditionalCardsIntoHand(2, gameState);
currentPlayer.RequestPlayerDiscardCardsFromHand(gameState, 2, isOptional: false);
}
private static void DelayedAction(PlayerState currentPlayer, GameState gameState)
{
currentPlayer.DrawAdditionalCardsIntoHand(5, gameState);
currentPlayer.AddBuys(1);
currentPlayer.AddActions(1);
}
