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); }