protected override async Task ActAsync(IActionHost host)
{
await host.Attack(async target =>
{
var revealed = target.RevealUntil(card => card.GetCost(host).GreaterThan(2));
if (revealed.Any())
{
var trashed = revealed.Last();
target.Trash(trashed, Zone.Revealed);
var gained = await target.SelectCards(
"Choose a card to gain, or none.",
Zone.SupplyAvailable,
card => card.GetCost(host).LessThanOrEqual(trashed.GetCost(host).Minus(2)),
0, 1
);
if (gained.Any())
{
await target.Gain(gained.Single());
}
target.Discard(revealed.Take(revealed.Length - 1).ToArray(), Zone.Revealed);
}
});
}
protected override async Task ActAsync(IActionHost host)
{
host.DrawCards(1);
host.AddActions(1);
await host.Attack(target => target.Gain("Curse"));
}
protected override async Task ActAsync(IActionHost host)
{
var trashed = await host.SelectCard("Choose a card to trash.", Zone.Hand);
if (trashed != null)
{
var cost = trashed.GetCost(host);
host.Trash(trashed);
var gained = await host.SelectCard(
"Choose a card to gain.",
Zone.SupplyAvailable,
card => card.GetCost(host).LessThanOrEqual(cost.Plus(2))
);
if (gained != null)
{
if (gained.Types.Contains(CardType.Action) || gained.Types.Contains(CardType.Treasure))
{
await host.Gain(gained, Zone.Deck);
}
else
{
await host.Gain(gained);
}
if (gained.Types.Contains(CardType.Victory))
{
await host.Attack(target => target.Gain("Curse"));
}
}
}
}
protected override async Task ActAsync(IActionHost host)
{
await host.Gain("Gold");
var trashed = new List <ICard>();
await host.Attack(async player =>
{
var top2 = player.Reveal(Zone.DeckTop(2));
var trashed = false;
foreach (var card in top2)
{
if (!trashed && card.Types.Contains(CardType.Treasure) && card.Name != "Copper")
{
trashed = true;
player.Trash(card, Zone.Deck);
}
else
{
player.Discard(card, Zone.Deck);
}
}
});
}
protected override async Task ActAsync(IActionHost host)
{
await host.Attack(async target =>
{
target.Discard(Zone.DeckTop(1));
await target.Gain("Curse", Zone.Deck);
});
}
protected override async Task ActAsync(IActionHost host)
{
host.AddCoins(2);
await host.Attack(player => player.Count(Zone.Hand) > 3, async player =>
{
var n = player.Count(Zone.Hand) - 3;
var discardedCards = await player.SelectCards(n == 1 ? "Choose a card to discard." : $"Choose {n} cards to discard.", n, n);
player.Discard(discardedCards);
});
}
protected override async Task ActAsync(IActionHost host)
{
host.DrawCards(2);
await host.Attack(target => target.Count(Zone.Hand) >= 4, async target =>
{
while (target.Count(Zone.Hand) > 3)
{
var put = await target.SelectCard("Choose a card to put onto your deck");
target.PutOnDeck(put);
}
});
}
protected override async Task ActAsync(IActionHost host)
{
var revealed = await host.SelectCard("Choose a card to reveal.");
if (revealed != null)
{
host.Reveal(revealed);
var hand = host.Examine(Zone.Hand);
var copies = hand.Where(c => c == revealed);
var returned = await host.SelectCards("Choose copies to return.", copies);
host.ReturnToSupply(returned);
await host.Attack(target => target.Gain(revealed));
}
}
protected override async Task ActAsync(IActionHost host)
{
host.AddCoins(2);
await host.Attack(target =>
{
var hand = target.Examine(Zone.Hand);
if (hand.Any(card => card.Name == "Copper"))
{
target.Discard("Copper");
}
else
{
target.Reveal(Zone.Hand);
}
});
}
protected override async Task ActAsync(IActionHost host)
{
host.AddActions(1);
await host.ChooseOne("Minion",
new NamedOption("<sym>+coin2</sym>", () => host.AddCoins(2)),
new NamedOption("<run>More</run><card suffix='s!'>Minion</card>", async() =>
{
host.Discard(Zone.Hand);
host.DrawCards(4);
await host.Attack(target => target.Count(Zone.Hand) >= 5, target =>
{
target.Discard(Zone.Hand);
target.DrawCards(4);
});
})
);
}
protected override async Task ActAsync(IActionHost host)
{
host.AddCoins(2);
await host.Attack(async target =>
{
var topDeck = target.Examine(Zone.DeckTop(1)).SingleOrDefault();
if (topDeck != null)
{
var topDeckCost = topDeck.GetCost(host);
target.Trash(topDeck, Zone.Deck);
var gained = await host.SelectCard(
$"Choose a card for {target.Player} to gain.",
Zone.SupplyAvailable,
card => card.GetCost(host).Equals(topDeckCost)
);
await target.Gain(gained);
}
});
}
protected override async Task ActAsync(IActionHost host)
{
await host.Gain("Silver", Zone.Deck);
await host.Attack(async player =>
{
var hand = player.Examine(Zone.Hand);
if (hand.Any(card => card.Types.Contains(CardType.Victory)))
{
var onTop = await player.SelectCard(
"Choose a card to put onto your deck.",
Zone.Hand,
cards => cards.OfType <IVictoryCard>()
);
player.Reveal(onTop, Zone.Hand);
player.PutOnDeck(onTop, Zone.Hand);
}
else
{
player.Reveal(Zone.Hand);
}
});
}
protected override async Task ActAsync(IActionHost host)
{
var tokens = host.Count(Zone.PlayerMat("PirateShipMat"));
await host.ChooseOne("Pirate Ship",
new NamedOption($"<sym>+coin1</sym><run>per Coin token (+${tokens}).</run>", () =>
{
host.AddCoins(tokens);
}),
new NamedOption("Raid for Treasures!", async() =>
{
var anyTrashes = false;
await host.Attack(async target =>
{
var top2 = target.Reveal(Zone.DeckTop(2));
var top2Treasures = top2.OfType <ITreasureCard>();
if (top2Treasures.Count() == 1)
{
target.Trash(top2Treasures.Single(), Zone.Deck);
anyTrashes = true;
}
else if (top2Treasures.Count() == 2)
{
var trashed = await host.SelectCard($"Choose a Treasure for {target.Player} to trash.", top2Treasures);
target.Trash(trashed, Zone.Deck);
anyTrashes = true;
}
target.Discard(top2.Without(top2Treasures).ToArray(), Zone.Deck);
});
if (anyTrashes)
{
host.PutOnMat("PirateShipMat", "Coin", Zone.Create);
}
})
);
}
protected override async Task ActAsync(IActionHost host)
{
var trashed = new List <ICard>();
await host.Attack(async player =>
{
var top2 = player.Reveal(Zone.DeckTop(2));
var treasures = top2.OfType <ITreasureCard>();
if (treasures.Any())
{
if (treasures.Count() == 1 || treasures.First().Equals(treasures.Last()))
{
var soleTreasure = treasures.First();
player.Trash(soleTreasure, Zone.Deck);
trashed.Add(soleTreasure);
}
else
{
var chosenTreasure = await host.SelectCard("Choose a Treasure to trash.", treasures);
player.Trash(chosenTreasure, Zone.Deck);
trashed.Add(chosenTreasure);
}
}
});
if (trashed.Any())
{
var gained = await host.SelectCards("Choose trashed Treasures to gain.", trashed);
if (gained.Any())
{
await host.GainFrom(gained, Zone.Trash);
}
}
}
protected override async Task ActAsync(IActionHost host)
{
host.DrawCards(3);
await host.Attack(async target =>
{
await target.ChooseOne("Torturer",
new NamedOption("Discard 2 cards", async() =>
{
var handSize = target.Count(Zone.Hand);
if (handSize > 2)
{
var discarded = await target.SelectCards("Choose cards to discard.", Zone.Hand, 2, 2);
target.Discard(discarded);
}
else
{
target.Discard(Zone.Hand);
}
}),
new NamedOption("Gain a Curse", () => target.Gain("Curse", Zone.Hand))
);
});
}
