protected override async Task ActAsync(IActionHost host)
{
host.AddCoins(2);
var top5 = host.Examine(Zone.DeckTop(5));
var namesBuilder = new StringBuilder();
{
for (var i = 0; i < top5.Length; i++)
{
var suffix = (i == top5.Length - 1) ? "" :
(i == top5.Length - 2) ? " and" :
",";
namesBuilder.Append($"<card suffix='{suffix}'>{top5[i].Name}</card>");
}
}
var names = namesBuilder.ToString();
await host.ChooseOne("Navigator",
new NamedOption($"<run>Discard cards:</run>{names}.", () => host.Discard(top5, Zone.Deck)),
new NamedOption("<run>Put cards back on deck.</run>", async() =>
{
var reordered = await host.OrderCards("Navigator", Zone.DeckTop(5));
host.Reorder(reordered, Zone.DeckTop(5));
})
);
}
protected override async Task ActAsync(IActionHost host)
{
await host.ChooseOne("Nobles",
new NamedOption("+3 Cards", () => host.DrawCards(3)),
new NamedOption("+2 Actions", () => host.AddActions(2))
);
}
protected override async Task ActAsync(IActionHost host)
{
var discarded = await host.SelectCards("Choose cards to discard.");
host.Discard(discarded);
host.AddCoins(discarded.Length);
}
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)
{
host.DrawCards(1);
host.AddActions(1);
await host.Attack(target => target.Gain("Curse"));
}
protected override async Task ReactAsync(IActionHost host)
{
host.DrawCards(2);
var discarded = await host.SelectCards("Choose cards to discard.", Zone.Hand, 3, 3);
host.Discard(discarded);
}
/// <summary>
/// Creates actions for the provided host.
/// </summary>
/// <param name="host">The host.</param>
/// <returns></returns>
public IEnumerable <IAction> CreateFor(IActionHost host)
{
var actions = new List <IAction>();
var methodGroups = SelectMethods(host.TargetType);
foreach (var methodGroup in methodGroups)
{
var methodList = methodGroup.ToList();
if (methodList.Count == 1)
{
actions.Add(CreateAction(host, methodList[0]));
}
else
{
var overloadedAction = new OverloadedAction(methodGroup.Key);
foreach (var methodInfo in methodList)
{
overloadedAction.AddOverload(CreateAction(host, methodInfo));
}
actions.Add(overloadedAction);
}
}
return(actions);
}
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 void Act(IActionHost host)
{
host.DrawCards(1);
host.AddActions(1);
host.AddBuys(1);
host.AddCoins(1);
}
protected override void OnAttack(IActionHost host, string attacker)
{
if (attacker != host.Player)
{
host.PreventNextAttack();
}
}
protected override async Task ActAsync(IActionHost host)
{
host.DrawCards(4);
host.AddBuys(1);
await host.OtherPlayers(target => target.DrawCards(1));
}
protected override async Task ActAsync(IActionHost host)
{
host.DrawCards(1);
host.AddActions(1);
var handSize = host.Count(Zone.Hand);
if (handSize >= 2 && await host.YesNo("Mill", "<run>Discard 2 cards for</run><sym>+coin2?</sym>"))
{
if (handSize > 2)
{
var discarded = await host.SelectCards("Choose cards to discard.", 2, 2);
host.Discard(discarded);
}
else
{
host.Discard(Zone.Hand);
}
if (handSize > 1)
{
host.AddCoins(2);
}
}
}
public async Task ExecuteReactionAsync(IActionHost host, Zone reactFrom, Trigger triggerType, string triggerParameter)
{
if (reactFrom == Zone.Hand && triggerType == ReactionTrigger)
{
await ReactAsync(host, triggerParameter);
}
}
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);
}
}
});
}
/// <summary>
/// Creates actions for the provided host.
/// </summary>
/// <param name="host">The host.</param>
/// <returns></returns>
public IEnumerable<IAction> CreateFor(IActionHost host)
{
var actions = new List<IAction>();
var methodGroups = SelectMethods(host.TargetType);
foreach(var methodGroup in methodGroups)
{
var methodList = methodGroup.ToList();
if(methodList.Count == 1)
actions.Add(CreateAction(host, methodList[0]));
else
{
var overloadedAction = new OverloadedAction(methodGroup.Key);
foreach(var methodInfo in methodList)
{
overloadedAction.AddOverload(CreateAction(host, methodInfo));
}
actions.Add(overloadedAction);
}
}
return actions;
}
protected override async Task ActAsync(IActionHost host)
{
var setAside = new List <string>();
while (host.Count(Zone.Hand) < 7)
{
var drawn = host.DrawCards(1).SingleOrDefault();
if (drawn == null)
{
break; // no cards left in deck or discard
}
if (drawn.Types.Contains(CardType.Action))
{
var shouldSkip = await host.YesNo("Library", $@"<spans>
<run>Skip drawing</run>
<card>{drawn.Name}</card>
<run>and put it into your discard pile?</run>
</spans>");
if (shouldSkip)
{
setAside.Add(drawn.Name);
}
}
}
if (setAside.Any())
{
host.Discard(setAside.ToArray());
}
}
protected override async Task ActAsync(IActionHost host)
{
host.DrawCards(2);
host.AddActions(1);
var inserted = await host.SelectCard("Choose a card to put in your deck.", Zone.Hand);
var deckSize = host.Count(Zone.Deck);
if (deckSize == 0)
{
host.PutOnDeck(inserted);
}
else
{
var options = Enumerable.Range(0, deckSize + 1).Select(i =>
{
var label =
i == 0 ? "Top" :
i == deckSize ? "Bottom" :
i.ToString();
return(new NamedOption(label, () => host.InsertIntoDeck(inserted.Name, i)));
});
await host.ChooseOne($"Choose where to put {inserted.Name}.", options.ToArray());
}
}
protected override async Task ActAsync(IActionHost host)
{
var matted = await host.SelectCard("Choose an additional card to put on your Island mat.");
host.PutOnMat("IslandMat", "Island", Zone.InPlay);
host.PutOnMat("IslandMat", matted, Zone.Hand);
}
protected override async Task ActAsync(IActionHost host)
{
var trashes = await host.SelectCards("Choose cards to trash.", Zone.DeckTop(2));
if (trashes.Any())
{
host.Trash(trashes, Zone.Deck);
}
if (trashes.Length < 2)
{
var discards = await host.SelectCards("Choose cards to discard.", Zone.DeckTop(trashes.Length == 1 ? 1 : 2));
if (discards.Any())
{
host.Discard(discards, Zone.Deck);
}
else if (!trashes.Any())
{
var orderedCards = await host.OrderCards("Put these cards back in any order.", Zone.DeckTop(2));
host.Reorder(orderedCards, Zone.Deck);
}
}
}
protected override async Task ActAsync(IActionHost host)
{
host.AddActions(1);
var discarded = await host.SelectCards("Choose any number of cards to discard.");
host.Discard(discarded);
host.DrawCards(discarded.Length);
}
public static Task Attack(this IActionHost host, Action <IActionHost> act)
{
return(host.AllPlayers(target => target.Player != host.Player, target =>
{
act(target);
return Task.CompletedTask;
}, true));
}
public static Task OnePlayer(this IActionHost host, string player, Action <IActionHost> act, bool isAttack = false)
{
return(host.AllPlayers(target => target.Player == player, target =>
{
act(target);
return Task.CompletedTask;
}, isAttack));
}
public static Task OtherPlayers(this IActionHost host, Action <IActionHost> act, bool isAttack = false)
{
return(host.AllPlayers(target => target.Player != host.Player, host =>
{
act(host);
return Task.CompletedTask;
}, isAttack));
}
protected override async Task ActAsync(IActionHost host)
{
await host.Attack(async target =>
{
target.Discard(Zone.DeckTop(1));
await target.Gain("Curse", Zone.Deck);
});
}
protected sealed override async Task ReactAsync(IActionHost host, string attacker)
{
if (attacker != host.Player && await host.YesNo(Name, $@"<run>Reveal</run><card>{Name}</card><run>from your hand?</run>"))
{
host.Reveal(Name);
await ReactAsync(host.Isolate());
}
}
protected override void Act(IActionHost host)
{
host.DrawCards(2);
if (host.Count(Zone.Hand) <= 5)
{
host.AddActions(2);
}
}
protected override async Task ActAsync(IActionHost host)
{
host.DrawCards(3);
var put = await host.SelectCard("Choose a card to put onto your deck.");
host.PutOnDeck(put);
}
protected override async Task ActAsync(IActionHost host)
{
host.AddCoins(2);
if (await host.YesNo("Chancellor", "Do you want to put your deck into your discard pile?"))
{
host.DiscardEntireDeck();
}
}
protected override async Task ActAsync(IActionHost host)
{
await host.ChooseMultiple("Pawn", 2,
new NamedOption("<bold>+1 Card</bold>", () => host.DrawCards(1)),
new NamedOption("<bold>+1 Action</bold>", () => host.AddActions(1)),
new NamedOption("<bold>+1 Buy</bold>", () => host.AddBuys(1)),
new NamedOption("<bold><sym>+coin1</sym></bold>", () => host.AddCoins(1))
);
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionMessageHandler"/> class.
/// </summary>
/// <param name="host">The host.</param>
/// <param name="target">The target.</param>
public ActionMessageHandler(IActionHost host, object target)
{
_target = target;
_host = host;
_host.Actions.SelectMany(x => x.Filters.HandlerAware)
.Union(_host.Filters.HandlerAware)
.Apply(x => x.MakeAwareOf(this));
}
protected override async Task ActAsync(IActionHost host)
{
host.AddCoins(2);
host.Trash("Embargo", Zone.InPlay);
var pile = await host.SelectCard("Choose a Supply pile to embargo.", Zone.SupplyAvailable);
host.AddToken("EmbargoToken", pile.Name);
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionMessageHandler"/> class.
/// </summary>
/// <param name="host">The host.</param>
/// <param name="target">The target.</param>
public ActionMessageHandler(IActionHost host, object target)
{
_weakTarget = new WeakReference<object>(target);
_host = host;
_host.SelectMany(x => x.Filters.HandlerAware)
.Union(_host.Filters.HandlerAware)
.Apply(x => x.MakeAwareOf(this));
}
/// <summary>
/// Initializes a new instance of the <see cref="ActionMessageHandler"/> class.
/// </summary>
/// <param name="host">The host.</param>
/// <param name="target">The target.</param>
public ActionMessageHandler(IActionHost host, object target)
{
this.target = target;
this.host = host;
this.host.Actions.SelectMany(x => x.Filters.HandlerAware)
.Union(this.host.Filters.HandlerAware)
.Apply(x => x.MakeAwareOf(this));
}
protected override IAction CreateAction(IActionHost host, MethodInfo methodInfo)
{
var method = _methodFactory.CreateFrom(methodInfo);
var asyncAtt = method.GetMetadata<AsyncActionAttribute>();
var backAtt = method.GetMetadata<BackgroundActionAttribute>();
var filters = host.GetFilterManager(method);
TryAddCanExecute(filters, method);
if (asyncAtt != null)
return new AsynchronousAction(method, _messageBinder, filters, asyncAtt.BlockInteraction);
if (backAtt != null && backAtt.BackgroundEndMode != EndMode.Unspecified)
return new BackgroundAction(method, _messageBinder, filters, backAtt.BlockInteraction);
return new CustomSynchronousAction(method, _messageBinder, filters);
}
protected override void given_the_context_of()
{
_target = new object();
_host = Mock<IActionHost>();
var filterManager = Stub<IFilterManager>();
filterManager.Stub(x => x.HandlerAware)
.Return(new IHandlerAware[]{})
.Repeat.Any();
_host.Stub(x => x.Filters)
.Return(filterManager)
.Repeat.Any();
_host.Stub(x => x.Actions)
.Return(new List<IAction>())
.Repeat.Any();
_handler = new ActionMessageHandler(_host, _target);
}
/// <summary>
/// Creates the action.
/// </summary>
/// <param name="host">The host.</param>
/// <param name="methodInfo">The method info.</param>
/// <returns></returns>
protected virtual IAction CreateAction(IActionHost host, MethodInfo methodInfo)
{
var method = _methodFactory.CreateFrom(methodInfo);
var asyncAtt = method.GetMetadata<AsyncActionAttribute>();
var filters = host.GetFilterManager(method);
TryAddCanExecute(filters, method);
if(asyncAtt == null)
return new SynchronousAction(method, _messageBinder, filters);
return new AsynchronousAction(method, _messageBinder, filters, asyncAtt.BlockInteraction);
}
