public static async Task ActAsync(TargetSpaceCtx ctx)
{
// 2 fear.
ctx.AddFear(2);
// in both origin land and target land: 1 damage to each invader.
var origin = await FindOriginLand_SS(ctx, 1);
await ctx.DamageEachInvader(1);
await ctx.Target(origin).DamageEachInvader(1);
// if you have 2 fire 3 air 2 water:
if (await ctx.YouHave("2 fire,3 air,2 water"))
{
// +1 fear.
ctx.AddFear(1);
// This Power has +1 range. (see attribute)
// in a land adjacent to both origin and target
Space thirdSpace = await SelectLandAdjacentToBoth(ctx, origin);
// 1 damage to each invader.
await ctx.Target(thirdSpace).DamageEachInvader(1);
// in lands where you did Damage, Destroy 1 town
foreach (var space in new[] { ctx.Space, origin, thirdSpace }.Distinct())
{
await ctx.Target(space).Invaders.Destroy(1, Invader.Town);
}
}
}
static public async Task ActAsync(TargetSpaceCtx ctx)
{
// 4 fear
ctx.AddFear(4);
// add 1 strife
await ctx.AddStrife();
// if you have 3moon, 2 air, 3 plant (before the terror level check)
if (await ctx.YouHave("3 moon,2 air,3 plant"))
{
ctx.AddFear(3);
await ctx.DamageInvaders(3);
}
// if terror level is 2 or higher, remove 2 invaders
if (2 <= ctx.GameState.Fear.TerrorLevel)
{
for (int i = 0; i < 2; ++i)
{
var invader = await ctx.Decision(Select.Invader.ToRemove(ctx.Space, ctx.Tokens.Invaders()));
if (invader == null)
{
break;
}
await ctx.Invaders.Remove(invader, 1);
}
}
}
static public Task ActAsync(TargetSpaceCtx ctx)
{
// 2 fear
ctx.AddFear(2);
// The next time an invader is destroyed in target land this turn, 1 fear
bool addFear = true;
Task Add1MoreFearForFirstDestroyedInvader(ITokenRemovedArgs args)
{
if (addFear &&
args.Reason.IsDestroy() &&
args.Space == ctx.Space &&
args.Token.Class.IsOneOf(Invader.Town, Invader.City, Invader.Explorer)
) // !! create an override .IsInvader()
{
ctx.AddFear(1);
addFear = false;
}
return(Task.CompletedTask);
}
ctx.GameState.Tokens.TokenRemoved.ForRound.Add(Add1MoreFearForFirstDestroyedInvader);
return(Task.CompletedTask);
}
static public async Task ActAsync(TargetSpaceCtx ctx)
{
// 6 fear
ctx.AddFear(6);
// +1 fear for each town/city and for each of your presence in target land.
int fearCount = ctx.Tokens.SumAny(Invader.City, Invader.Town)
+ ctx.Self.Presence.Placed.Count(x => x == ctx.Space);
ctx.AddFear(fearCount);
// Remove 1 city, 1 town and 1 explorer.
await ctx.RemoveInvader(Invader.City);
await ctx.RemoveInvader(Invader.Town);
await ctx.RemoveInvader(Invader.Explorer);
// if you have 3 sun and 3 moon, invaders do -6 damage on their ravage.
if (await ctx.YouHave("3 sun,3 moon"))
{
ctx.Defend(6); // !! not exactly correct but close
}
// Then, Invaders in target land ravage.
await new RavageAction(ctx.GameState, ctx.Invaders).Exec();
}
static public async Task ActAsync(TargetSpaceCtx ctx)
{
await ctx.SelectActionOption(
new SpaceAction("1 fear, add 1 beast", ctx => { ctx.AddFear(1); ctx.Beasts.Add(1); } ),
new SpaceAction("3 fear", ctx => ctx.AddFear(3))
.Matches(x => ctx.Tokens.HasInvaders() && x.Beasts.Any)
);
}
static public Task ActAsync(TargetSpaceCtx ctx)
{
// 2 fear
ctx.AddFear(2);
// if town has at least 2 towns / cities, +1 fear
if (2 <= ctx.Invaders.Tokens.TownsAndCitiesCount())
{
ctx.AddFear(1);
}
return(Task.CompletedTask);
}
static public async Task ActAsync(TargetSpaceCtx ctx)
{
// you may push 1 explorer / town / dahan
await ctx.PushUpTo(1, Invader.Explorer, Invader.Town, TokenType.Dahan);
// 2 fear
ctx.AddFear(2);
// if target land has any beasts, 1 fear
if (ctx.Beasts.Any)
{
ctx.AddFear(1);
}
}
static public async Task Act(TargetSpaceCtx ctx)
{
// 1 fear
ctx.AddFear(1);
// Push 1 explorer/town
await ctx.Push(1, Invader.Explorer, Invader.Town);
if (await ctx.YouHave("2 fire"))
{
ctx.AddFear(1);
}
}
static public Task ActAsync(TargetSpaceCtx ctx)
{
// 1 fear
ctx.AddFear(1);
// Defend 3
ctx.Defend(3);
// If beast are present, +2 fear.
if (ctx.Beasts.Any)
{
ctx.AddFear(2);
}
return(Task.CompletedTask);
}
static public async Task ActAsync(TargetSpaceCtx ctx)
{
// 4 fear
ctx.AddFear(4);
// invaders skip all actions in target land this turn
ctx.SkipAllInvaderActions();
// if you have 2 air 3 earth, +4 fear
if (await ctx.YouHave("2 air,3 earth"))
{
ctx.AddFear(4);
}
}
static public async Task Act(TargetSpaceCtx ctx)
{
// 2 fear
ctx.AddFear(2);
// push up to 4 explorers or towns
await ctx.PushUpTo(4, Invader.Explorer, Invader.Town);
// if you have 4 moon, +4 fear
if (await ctx.YouHave("4 moon"))
{
ctx.AddFear(4);
}
}
private static async Task FearAndExplorer(TargetSpaceCtx ctx)
{
// 1 fear
ctx.AddFear(1);
// destroy 1 explorer
await ctx.Invaders.Destroy(1, Invader.Explorer);
}
static public Task ActAsync(TargetSpaceCtx ctx)
{
// 1 fear per type of Invader present.
ctx.AddFear(ctx.Tokens.InvaderTotal());
// Push up to 1 explorer / town per blight.
return(ctx.PushUpTo(ctx.Blight.Count, Invader.Explorer, Invader.Town));
}
static public async Task Damage3(TargetSpaceCtx ctx)
{
await DiseaseDamagesInvaders(ctx, 2);
ctx.AddFear(System.Math.Min(5, ctx.Disease.Count));
await ctx.Disease.Remove(1, RemoveReason.Removed);
}
static public async Task Option2(TargetSpaceCtx ctx)
{
// 2 plant - destroy up to 2 explorer per badland/beast/disease/wilds
int destroyCount = await DestroyFromBadlandsBeastDiseaseWilds(ctx);
ctx.AddFear(CalcFearFromExplorerDeath(destroyCount));
}
static public Task Act(TargetSpaceCtx ctx)
{
return(ctx.SelectActionOption(
new SpaceAction("push up to 4 dahan", ctx => ctx.PushUpToNDahan(4)).Matches(x => x.Dahan.Any),
new SpaceAction("2 fear", ctx => ctx.AddFear(2)).Matches(x => x.Tokens.HasInvaders())
));
}
static public async Task ActAsync(TargetSpaceCtx ctx)
{
// add 2 disease
var disease = ctx.Disease;
await disease.Add(2);
// for each disease in target land, defend 1 in target and all adjacent lands
ctx.Defend(disease.Count);
foreach (var adjacent in ctx.Adjacent)
{
ctx.Target(adjacent).Defend(disease.Count);
}
// if you have 2 earthn 4 animal:
if (await ctx.YouHave("2 earth,4 animal"))
{
// 2 fear.
ctx.AddFear(2);
// For each disease in target land, do 1 damage in target or adjacent land
int damage = disease.Count;
var space = await ctx.Decision(new Select.Space($"Select space to apply {damage} damage", ctx.Range(1), Present.Always)); // can we wrap this and make it easier to call?
await ctx.Target(space).DamageInvaders(damage);
}
}
static async Task Dissolve(TargetSpaceCtx ctx, params HealthTokenClass[] invaderCats)
{
var decision = Select.Invader.ToReplace("dissolve", ctx.Space, ctx.Tokens.OfAnyType(invaderCats));
var invader = await ctx.Decision(decision);
if (invader == null)
{
return;
}
// Replace
if (invader.Class != Invader.Explorer)
{
await ctx.Invaders.Remove(invader, 1, RemoveReason.Replaced);
await ctx.Tokens.AddDefault(Invader.Explorer, invader.RemainingHealth, AddReason.AsReplacement);
}
// !!! If they are damaged, should we distribute that damage and destroy some of the explorers?
// Push to new land
await ctx.Pusher
.AddGroup(invader.RemainingHealth, Invader.Explorer)
.FilterDestinations(ctx.Self.Presence.IsOn)
.MoveUpToN();
// If town/city remain, 1 fear.
if (ctx.Tokens.HasAny(Invader.Town, Invader.City))
{
ctx.AddFear(1);
}
}
static public async Task ActAsync(TargetSpaceCtx ctx)
{
// 6 fear
ctx.AddFear(6);
// 20 damage.
await ctx.DamageInvaders(20);
// Destroy all dahan and beast.
await DestroyDahanAndBeasts(ctx);
// Add 1 blight
await ctx.AddBlight(1);
// if you have 4 fire, 3 earth:
if (await ctx.YouHave("4 fire,3 earth"))
{
// Destroy all invaders.
await ctx.Invaders.DestroyAny(int.MaxValue, Invader.City, Invader.Town, Invader.Explorer);
// Add 1 wilds.
await ctx.Wilds.Add(1);
// In each adjacent land:
foreach (var adj in ctx.Adjacent.Select(ctx.Target))
{
await EffectAdjacentLand(adj);
}
}
}
static public Task ActAsync(TargetSpaceCtx ctx)
{
return(ctx.SelectActionOption(
new SpaceAction("Draw Major Power", DrawMajorOrGetEnergy).Matches(x => x.Dahan.Any), // if target land has dahan
new SpaceAction("2 fear", ctx => ctx.AddFear(2)).Matches(x => x.HasInvaders)
));
}
static public Task ActionAsync(TargetSpaceCtx ctx)
{
return(ctx.SelectActionOption(
new SpaceAction("Push 1 Explorer", ctx => ctx.Push(1, Invader.Explorer)),
new SpaceAction("2 fear", ctx => ctx.AddFear(2))
));
}
public static async Task ActAsync(TargetSpaceCtx ctx)
{
// 1 fear.
ctx.AddFear(1);
// 2 damamge.
await ctx.DamageInvaders(2);
// Isolate target land.
ctx.Isolate();
// After invaders / dahan are Moved into target land, Destroy them.
ctx.GameState.Tokens.TokenAdded.ForRound.Add(async(args) => {
if (args.Space == ctx.Space &&
args.Token.Class.IsOneOf(Invader.Explorer, Invader.Town, Invader.City, TokenType.Dahan)
)
{
await args.GameState.Tokens[args.Space].Destroy(args.Token, args.Count);
}
});
// if you have 2 moon, 4 water, 2 earth:
if (await ctx.YouHave("2 moon,4 water,2 earth"))
{
// +4 damamge,
await ctx.DamageInvaders(4);
// Add 1 badland.
await ctx.Badlands.Add(1);
// Add 1 wilds
await ctx.Wilds.Add(1);
}
}
static public async Task ActAsymc(TargetSpaceCtx ctx)
{
// 1 fear if invaders are present.
if (ctx.HasInvaders)
{
ctx.AddFear(1);
}
var beastSources = ctx.Adjacent.Where(s => ctx.Target(s).Beasts.Any).ToArray();
// If you can gather 1 beast,
if (beastSources.Length > 0)
{
// do so,
await ctx.Gather(1, TokenType.Beast);
// then push 1 explorer.
await ctx.Push(1, Invader.Explorer);
}
else
{
// othersie, add 1 beast
await ctx.Beasts.Add(1);
}
}
static public async Task Act(TargetSpaceCtx ctx)
{
// 1 fear
ctx.AddFear(1);
// Destroy 1 town
await ctx.Invaders.Destroy(1, Invader.Town);
}
static public async Task ActAsync(TargetSpaceCtx ctx)
{
// 4 damage.
await ctx.DamageInvaders(4);
// If any invaders remain, add 1 disease
if (ctx.Tokens.Invaders().Any())
{
await ctx.Disease.Add(1);
}
// if 3 air and 3 plant:
if (await ctx.YouHave("3 air,3 plant"))
{
// 3 fear.
ctx.AddFear(3);
// Add 1 disease to 2 adjacent lands with invaders.
for (int i = 0; i < 2; ++i)
{
var adjCtx = await ctx.SelectAdjacentLand($"Add disease to ({i+1} of 2)", x => x.Tokens.HasInvaders());
await adjCtx.Disease.Add(1);
}
}
}
static public Task ActAsync(TargetSpaceCtx ctx)
{
// 2 fear
ctx.AddFear(2);
return(ReplaceInvader.Downgrade(ctx, Invader.City, Invader.Town));
}
static public async Task ActAsync(TargetSpaceCtx ctx)
{
// 2 fear
ctx.AddFear(2);
// add 1 beast.
var beasts = ctx.Beasts;
await beasts.Add(1);
// Gather up to 1 beast.
await ctx.GatherUpTo(1, TokenType.Beast);
// 1 damage per beast.
await ctx.DamageInvaders(beasts.Count);
// Push up to 2 beast
await ctx.PushUpTo(2, TokenType.Beast);
// if you have 2 sun 2 moon 3 animal
if (await ctx.YouHave("2 sun,2 moon,3 animal"))
{
// 1 damage in adjacent land without blight,
// and +1 damage per beast there
var noBlight = await ctx.SelectAdjacentLand("1 Damage in land w/o blight", ctx => !ctx.HasBlight);
if (noBlight != null)
{
await noBlight.DamageInvaders(1 + noBlight.Beasts.Count);
}
}
}
static public async Task ActAsync(TargetSpaceCtx ctx)
{
// 3 fear
ctx.AddFear(3);
var landsWeCanApplyTheDamageTo = new List <Space> {
ctx.Space
};
// After each effect that destroys...
async Task DealVengenceDamage(ITokenRemovedArgs args)
{
if (!args.Reason.IsDestroy())
{
return;
}
// ...a town / city / dahan in target land
if (args.Space == ctx.Space && args.Token.Class.IsOneOf(Invader.Town, Invader.City, TokenType.Dahan))
{
// 1 damage per token destroyed
await DistributeDamageToLands(ctx, landsWeCanApplyTheDamageTo, 1);
}
}
ctx.GameState.Tokens.TokenRemoved.ForRound.Add(DealVengenceDamage);
// if you have 3 animal
if (await ctx.YouHave("3 animal"))
{
// damage may be dealt into adjacent lands
landsWeCanApplyTheDamageTo.AddRange(ctx.Adjacent);
}
}
static public Task ActAsync(TargetSpaceCtx ctx)
{
// 1 fear.
ctx.AddFear(1);
// Invaders skip Ravage Actions.
ctx.SkipRavage();
return(Task.CompletedTask);
}
static async Task Execute(TargetSpaceCtx ctx, int fear, int damage)
{
ctx.AddFear(fear);
await ctx.DamageInvaders(damage);
// remove 1 beast
await ctx.Beasts.Remove(1);
}
