public override Card GetCardFromHandToTrash(GameState gameState, CardPredicate acceptableCard, bool isOptional, CollectionCards cardsTrashedSoFar)
{
if (gameState.Self == gameState.players.CurrentPlayer)
{
if (Strategy.CountInHand(Dominion.Cards.Gold, gameState) > 0)
return Dominion.Cards.Gold;
}
return base.GetCardFromHandToTrash(gameState, acceptableCard, isOptional, cardsTrashedSoFar);
}
public void AddAllCardsFromInSomeOrder(CollectionCards other)
{
base.AddAllCardsFrom(other);
foreach (Card card in other.AllTypes)
{
int count = other.CountOf(card);
for (int i = 0; i < count; ++i)
this.cards.Add(card);
}
}
public static int CountInSetMatching(this ICardPicker pickOrder, GameState gameState, CollectionCards collectionCards)
{
int result = 0;
foreach(var cardType in collectionCards.AllTypes)
{
if (pickOrder.DoesCardPickerMatch(gameState, cardType))
{
result += collectionCards.CountOf(cardType);
}
}
return result;
}
public override void DoSpecializedAction(PlayerState currentPlayer, GameState gameState)
{
CollectionCards trashedCards = currentPlayer.RequestPlayerTrashCardsFromHand(gameState, currentPlayer.Hand.Count, isOptional: true);
int totalCoinCost = trashedCards.Select(card => card.CurrentCoinCost(currentPlayer)).Sum();
int totalPotionCost = trashedCards.Select(card => card.potionCost).Sum();
currentPlayer.RequestPlayerGainCardFromSupply(
gameState,
card => card.CurrentCoinCost(currentPlayer) == totalCoinCost && card.potionCost == totalPotionCost,
"Must gain a card costing exactly equal to the total cost of the trashed cards>",
isOptional: false);
}
override public Card GuessCardTopOfDeck(GameState gameState)
{
PlayerState self = gameState.Self;
if (self.KnownCardsInDeck.Any())
{
return(self.KnownCardsInDeck.First());
}
CollectionCards cards = self.CardsInDeck.Any ? self.CardsInDeck : self.Discard;
if (cards.Any)
{
return(cards.MostCommonCardWhere(card => card != Dominion.Cards.Estate && !card.isShelter));
}
else
{
return(Dominion.Cards.Estate);
}
}
internal Card RequestPlayerTrashCardFromHand(GameState gameState, CardPredicate acceptableCardsToTrash, bool isOptional, CollectionCards cardsTrashedSoFar = null)
{
Card cardTypeToTrash = RequestPlayerTrashCardFromHandButDontTrash(gameState, acceptableCardsToTrash, isOptional, cardsTrashedSoFar);
if (cardTypeToTrash != null)
this.TrashCardFromHandOfType(gameState, cardTypeToTrash, guaranteeInHand: true);
return cardTypeToTrash;
}
public static int CountInSetMatching(this ICardPicker pickOrder, GameState gameState, CollectionCards collectionCards)
{
int result = 0;
foreach (var cardType in collectionCards.AllTypes)
{
if (pickOrder.DoesCardPickerMatch(gameState, cardType))
{
result += collectionCards.CountOf(cardType);
}
}
return(result);
}
public virtual Card GetCardFromHandToTrash(GameState gameState, CardPredicate acceptableCard, bool isOptional, CollectionCards cardsTrashedSoFar)
{
return PlayerMustMakeCardChoice();
}
public int ValueOf(CollectionCards cards)
{
return(cards.Select(c => c.plusCoin).Sum());
}
internal new void MoveAllCardsFrom(CollectionCards other)
{
base.MoveAllCardsFrom(other);
}
public int ValueOf(CollectionCards cards)
{
return cards.Select( c => c.plusCoin ).Sum();
}
// always optional
public Card GetCardFromHandToTrash(GameState gameState, CardPredicate acceptableCard, bool isOptional, CollectionCards cardsTrashedSoFar)
{
var saved = gameState.self;
gameState.self = this.self;
var result = this.playerAction.GetCardFromHandToTrash(gameState, acceptableCard, isOptional, cardsTrashedSoFar);
gameState.self = saved;
return result;
}
public override Card GetCardFromHandToTrash(GameState gameState, CardPredicate acceptableCard, bool isOptional, CollectionCards cardsTrashedSoFar)
{
if (gameState.Self == gameState.players.CurrentPlayer)
{
if (Strategy.CountInHand(Dominion.Cards.Gold, gameState) > 0)
{
return(Dominion.Cards.Gold);
}
}
return(base.GetCardFromHandToTrash(gameState, acceptableCard, isOptional, cardsTrashedSoFar));
}
private void WriteAllCards(CollectionCards cards)
{
bool needComma = false;
foreach (Card currentCard in cards.AllTypes.OrderBy(card => card.name))
{
int cardCount = cards.CountOf(currentCard);
if (!needComma)
{
needComma = true;
}
else
{
this.textWriter.Write(", ");
}
this.textWriter.Write("{0} {1}", cardCount, cardCount > 1 ? currentCard.pluralName : currentCard.name);
}
this.textWriter.WriteLine();
}
internal Card RequestPlayerTrashCardFromHandButDontTrash(GameState gameState, CardPredicate acceptableCardsToTrash, bool isOptional, CollectionCards cardsTrashedSoFar = null)
{
if (!this.hand.HasCard(acceptableCardsToTrash))
{
return null;
}
if (cardsTrashedSoFar == null)
cardsTrashedSoFar = gameState.emptyCardCollection;
Card cardTypeToTrash = this.actions.GetCardFromHandToTrash(gameState, acceptableCardsToTrash, isOptional, cardsTrashedSoFar);
if (cardTypeToTrash == null)
{
if (isOptional)
{
return null;
}
else
{
throw new Exception("Player must choose a card to trash");
}
}
if (!acceptableCardsToTrash(cardTypeToTrash))
{
throw new Exception("Tried to trash a card that didn't match the constraint");
}
return cardTypeToTrash;
}
public override Card GetCardFromHandToTrash(GameState gameState, CardPredicate acceptableCard, bool isOptional, CollectionCards cardsTrashedSoFar)
{
IPlayerAction playerAction = this.GetActionForCurrentCardContext(gameState);
if (playerAction != null)
return playerAction.GetCardFromHandToTrash(gameState, acceptableCard, isOptional, cardsTrashedSoFar);
else
return base.GetCardFromHandToTrash(gameState, acceptableCard, isOptional, cardsTrashedSoFar);
}
private void MoveAllCardsToDiscard(CollectionCards cards, GameState gameState, DeckPlacement source)
{
foreach (Card card in cards)
{
this.DiscardCard(card, gameState, source);
}
cards.Clear();
}
public override Card GetCardFromHandToTrash(GameState gameState, CardPredicate acceptableCard, bool isOptional, CollectionCards cardsTrashedSoFar)
{
IPlayerAction playerAction = this.GetActionForCurrentCardContext(gameState);
if (playerAction != null)
{
return(playerAction.GetCardFromHandToTrash(gameState, acceptableCard, isOptional, cardsTrashedSoFar));
}
else
{
return(base.GetCardFromHandToTrash(gameState, acceptableCard, isOptional, cardsTrashedSoFar));
}
}
public override Card GetCardFromHandToTrash(GameState gameState, CardPredicate acceptableCard, bool isOptional, CollectionCards cardsTrashedSoFar)
{
var self = gameState.Self;
Card result = this.trashOrder.GetPreferredCard(
gameState,
card => self.Hand.HasCard(card) && acceptableCard(card));
// warning, strategy didnt' include what to, try to do a reasonable default.
if (result == null && !isOptional)
{
result = self.Hand.Where(c => acceptableCard(c)).OrderBy(c => c, new DefaultPlayRules.CompareCardByFirstToTrash()).FirstOrDefault();
}
return(result);
}
public GameState(
IPlayerAction[] playerActions,
int[] playerPositions,
Game game)
{
if (playerActions.Length != playerPositions.Length)
throw new Exception();
this.game = game;
GameConfig gameConfig = game.GameConfig;
this.emptyCardCollection = new CollectionCards(this.CardGameSubset, null);
int playerCount = playerActions.Length;
this.supplyPiles = gameConfig.GetSupplyPiles(playerCount, game.random);
this.nonSupplyPiles = gameConfig.GetNonSupplyPiles(playerCount);
this.mapCardToPile = new MapOfCardsForGameSubset<PileOfCards>(this.CardGameSubset);
this.BuildMapOfCardToPile();
this.players = new PlayerCircle(playerCount, playerActions, playerPositions, game);
this.hasPileEverBeenGained = new MapPileOfCards<bool>(this.supplyPiles);
this.pileEmbargoTokenCount = new MapPileOfCards<int>(this.supplyPiles);
this.trash = new BagOfCards(this.CardGameSubset);
this.cardContextStack = new CardContextStack();
this.GainStartingCards(gameConfig);
foreach (PileOfCards cardPile in this.supplyPiles)
{
cardPile.ProtoTypeCard.DoSpecializedSetupIfInSupply(this);
}
this.players.AllPlayersDrawInitialCards(gameConfig, this);
}
