private new void DoSpecializedCleanupAtStartOfCleanup(PlayerState currentPlayer, GameState gameState)
{
if (currentPlayer.cardsPlayed.HasCard(Cards.Potion))
{
currentPlayer.RequestPlayerTopDeckCardFromCleanup(this, gameState);
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
Card revealedCard = currentPlayer.RequestPlayerRevealCardFromHand(acceptableCard => true, gameState);
PlayerState.AttackAction attackAction = this.DoEmptyAttack;
if (revealedCard != null && !revealedCard.isShelter)
{
int maxReturnCount = Math.Max(currentPlayer.Hand.CountOf(revealedCard), 2);
int returnCount = currentPlayer.actions.GetCountToReturnToSupply(revealedCard, gameState);
returnCount = Math.Min(returnCount, maxReturnCount);
returnCount = Math.Max(returnCount, 0);
for (int i = 0; i < returnCount; ++i)
{
if (currentPlayer.hand.HasCard(revealedCard))
{
currentPlayer.ReturnCardFromHandToSupply(revealedCard, gameState);
}
}
attackAction = delegate(PlayerState currentPlayer2, PlayerState otherPlayer, GameState gameState2)
{
otherPlayer.GainCardFromSupply(gameState, revealedCard);
};
}
currentPlayer.AttackOtherPlayers(gameState, attackAction);
}
public void DrewCardIntoHand(PlayerState playerState, Card card)
{
for (int i = 0; i < this.gameLogs.Length; ++i)
{
this.gameLogs[i].DrewCardIntoHand(playerState, card);
}
}
public void BeginTurn(PlayerState playerState)
{
for (int i = 0; i < this.gameLogs.Length; ++i)
{
this.gameLogs[i].BeginTurn(playerState);
}
}
public void DiscardedCard(PlayerState playerState, Card card)
{
for (int i = 0; i < this.gameLogs.Length; ++i)
{
this.gameLogs[i].DiscardedCard(playerState, card);
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
Card revealedCard = currentPlayer.RequestPlayerRevealCardFromHand(acceptableCard => true, gameState);
if (revealedCard == null)
{
return;
}
currentPlayer.MoveRevealedCardToHand(revealedCard);
int maxReturnCount = 1;
if (currentPlayer.Hand.CountWhere(card => card.Equals(revealedCard)) > 1)
{
maxReturnCount++;
}
int returnCount = currentPlayer.actions.GetCountToReturnToSupply(revealedCard, gameState);
returnCount = Math.Min(returnCount, maxReturnCount);
returnCount = Math.Max(returnCount, 0);
for (int i = 0; i < returnCount; ++i)
{
currentPlayer.ReturnCardFromHandToSupply(revealedCard, gameState);
}
foreach (PlayerState otherPlayer in gameState.players.OtherPlayers)
{
if (!otherPlayer.IsAffectedByAttacks(gameState))
{
otherPlayer.GainCardFromSupply(gameState, revealedCard);
}
}
}
public override void PlayerGainedCard(PlayerState playerState, Card card)
{
if (this.gainSequenceByPlayer != null)
{
List<Card> gainedList = this.gainSequenceByPlayer[playerState.PlayerIndex];
gainedList.Add(card);
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
currentPlayer.RequestPlayerGainCardFromSupply(
gameState,
card => card.CurrentCoinCost(currentPlayer) <= 4 && card.potionCost == 0,
"Gain a card costing up to 4",
defaultLocation:DeckPlacement.TopOfDeck);
}
public override DeckPlacement DoSpecializedWhenGain(PlayerState currentPlayer, GameState gameState)
{
currentPlayer.RequestPlayerGainCardFromSupply(
gameState,
card => card.CurrentCoinCost(currentPlayer) < this.CurrentCoinCost(currentPlayer) && card.potionCost == 0,
"Must gain a card costing less than this");
return DeckPlacement.Default;
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
currentPlayer.RequestPlayerTrashCardFromHandAndGainCard(
gameState,
acceptableCard => true,
CostConstraint.UpTo,
5,
CardRelativeCost.AbsoluteCost);
}
public void BeginTurn(PlayerState playerState)
{
this.textWriter.WriteLine("{0} begins turn", playerState.actions.PlayerName);
this.textWriter.Write("With hand: ");
foreach (Card card in playerState.Hand.OrderBy(card => card.name))
{
this.textWriter.Write(card.name + ",");
}
this.textWriter.WriteLine();
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
if (currentPlayer.RequestPlayerDiscardCardFromHand(gameState, acceptableCard => acceptableCard == Estate.card, isOptional: true))
{
currentPlayer.AddCoins(4);
}
else
{
currentPlayer.GainCardFromSupply(Estate.card, gameState);
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
currentPlayer.RevealCardsFromDeck(5, gameState);
Card cardType = gameState.players.PlayerLeft.actions.BanCardToDrawnIntoHandFromRevealedCards(gameState);
if (!currentPlayer.cardsBeingRevealed.HasCard(cardType))
{
throw new Exception("Must ban a card currently being revealed");
}
currentPlayer.MoveRevealedCardToDiscard(cardType, gameState);
currentPlayer.MoveAllRevealedCardsToHand();
}
public override bool ShouldPlayerDiscardCardFromDeck(GameState gameState, PlayerState player, Card card)
{
if (player == gameState.Self)
{
return !card.isAction;
}
else
{
return !playerAction.discardOrder.DoesCardPickerMatch(gameState, card);
}
}
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 DoSpecializedAttack(PlayerState currentPlayer, PlayerState otherPlayer, GameState gameState)
{
CardPredicate acceptableCard = card => card.isVictory;
Card cardTopDecked = otherPlayer.RequestPlayerTopDeckCardFromHand(gameState, acceptableCard, isOptional: false);
if (cardTopDecked == null)
{
otherPlayer.RevealHand();
}
else
{
otherPlayer.RevealCard(cardTopDecked, DeckPlacement.TopOfDeck);
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
currentPlayer.victoryTokenCount += 1;
Card trashedCard = currentPlayer.RequestPlayerTrashCardFromHand(gameState, acceptableCardsToTrash => true, isOptional: false);
if (trashedCard != null)
{
currentPlayer.victoryTokenCount += trashedCard.CurrentCoinCost(currentPlayer) / 2;
}
foreach (PlayerState otherPlayer in gameState.players.OtherPlayers)
{
otherPlayer.RequestPlayerTrashCardFromHand(gameState, acceptableCardsToTrash => true, isOptional: true);
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
PlayerActionChoice actionChoice = currentPlayer.RequestPlayerChooseBetween(
gameState,
acceptableChoice => acceptableChoice == PlayerActionChoice.GainCard ||
acceptableChoice == PlayerActionChoice.PlusCoin ||
acceptableChoice == PlayerActionChoice.Trash);
switch (actionChoice)
{
case PlayerActionChoice.GainCard: currentPlayer.GainCardFromSupply(Silver.card, gameState); break;
case PlayerActionChoice.PlusCoin: currentPlayer.AddCoins(1); break;
case PlayerActionChoice.Trash: currentPlayer.RequestPlayerTrashCardsFromHand(gameState, 1, false); break;
default: throw new Exception("Invalid case");
}
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
int countTreasureFound = 0;
while (countTreasureFound < 2)
{
Card card = currentPlayer.DrawAndRevealOneCardFromDeck(gameState);
if (card == null)
{
break;
}
if (card.isTreasure)
{
countTreasureFound += 1;
currentPlayer.MoveRevealedCardToHand(card);
}
}
currentPlayer.MoveRevealedCardsToDiscard(gameState);
}
public void Write(IndentedTextWriter textWriter, PlayerState[] players)
{
foreach (PlayerState player in players)
{
textWriter.WriteLine("{0} GainSequence was:", player.actions.PlayerName);
textWriter.Indent();
int count = 0;
foreach (Card card in this.gainSequenceByPlayer[player.PlayerIndex])
{
textWriter.Write("{0}, ", card.name);
if (++count == 5)
{
count = 0;
textWriter.WriteLine();
};
}
textWriter.Unindent();
textWriter.WriteLine();
textWriter.WriteLine();
}
}
public override Card GetCardFromOtherPlayersHandToDiscard(GameState gameState, PlayerState otherPlayer)
{
if (gameState.CurrentContext.CurrentCard != Cards.Pillage)
return base.GetCardFromOtherPlayersHandToDiscard(gameState, otherPlayer);
if (otherPlayer.ExpectedCoinValueAtEndOfTurn >= 5)
{
var returned = otherPlayer.Hand.Where(card => card != Cards.Familiar && card.isTreasure).OrderByDescending(c => c.DefaultCoinCost).FirstOrDefault();
if (returned == null)
throw new Exception();
return returned;
}
/*
Card discard = otherPlayer.Hand.Where(card => card != Cards.Familiar && card.DefaultCoinCost >= 3).OrderByDescending(c => c.DefaultCoinCost).FirstOrDefault();
if (discard != null)
return discard;*/
if (otherPlayer.Hand.HasCard(Cards.Familiar))
return Cards.Familiar;
return base.GetCardFromOtherPlayersHandToDiscard(gameState, otherPlayer);
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
Card foundCard = null;
gameState.gameLog.PushScope();
while (true)
{
foundCard = currentPlayer.DrawAndRevealOneCardFromDeck();
if (foundCard == null)
break;
if (foundCard.isAction || foundCard.isTreasure)
{
break;
}
}
gameState.gameLog.PopScope();
if (foundCard != null)
{
currentPlayer.MoveRevealedCardToHand(foundCard);
}
currentPlayer.MoveRevealedCardsToDiscard(cardToMove => true, gameState);
}
public override void EndTurn(PlayerState playerState)
{
if (playerState.TurnNumber == 2)
{
if (playerState.AllOwnedCards.Where(card => card == Cards.Witch).Any())
{
this.was25split[playerState.PlayerIndex] = true;
}
}
}
public void DrewCardIntoHand(PlayerState playerState, Card card)
{
this.textWriter.WriteLine("{0} Drew {1} into hand.", playerState.actions.PlayerName, card.name);
}
public void DiscardedCard(PlayerState playerState, Card card)
{
this.textWriter.WriteLine("{0} Discarded {1}.", playerState.actions.PlayerName, card.name);
}
public void BeginPhase(PlayerState playerState)
{
this.textWriter.WriteLine("Begins {0} phase", playerState.PlayPhase);
this.PushScope();
}
private void WriteAllCards(PlayerState playerState)
{
WriteAllCards(playerState.AllOwnedCards);
}
public void ReshuffledDiscardIntoDeck(PlayerState playerState)
{
this.textWriter.WriteLine("{0} reshuffled", playerState.actions.PlayerName);
}
public void ReceivedDurationEffectFrom(PlayerState playerState, Card card)
{
this.textWriter.WriteLine("{0} Finished Playing {1}.", playerState.actions.PlayerName, card.name);
}
public void BeginRound(PlayerState playerState)
{
this.textWriter.WriteLine("ROUND {0}", ++this.roundNumber);
this.textWriter.WriteLine("-------------");
}
