Exemplo n.º 1
0
    static public async Task ActAsync(TargetSpaceCtx ctx)
    {
        // destroys all explorers and towns
        await ctx.Invaders.Destroy(int.MaxValue, Invader.Explorer);

        await ctx.Invaders.Destroy(int.MaxValue, Invader.Town);

        // Destroy all dahan
        bool destroyAllDahan = true;

        // if you have 2 moon, 3 plant
        if (await ctx.YouHave("2 moon,3 plant"))
        {
            // Destroy 1 city
            await ctx.Invaders.Destroy(1, Invader.City);

            // do not destroy dahan
            destroyAllDahan = false;
        }

        if (destroyAllDahan)
        {
            await ctx.DestroyDahan(ctx.Dahan.Count);
        }
    }
Exemplo n.º 2
0
    static public async Task Act(TargetSpaceCtx ctx)
    {
        // "Drown 1 explorer, 1 town, 1 dahan"

        // find Ocean's Hungry Grasp spirit
        var ocean = ctx.Self as Ocean ?? ctx.GameState.Spirits.Single(x => x is Ocean);

        // find place to drown then
        var drowningOcean = ocean.Presence
                            .Spaces.First() // find any space the ocean has presnece
                            .Board.Ocean;   // find the Ocean space on that board

        // drown 1 explorer, 1 town, and 1 dahan

        // drown 1 explorer ( drop 1 explorer in the ocean to drown )
        var explorerToDrown = ctx.Tokens.OfType(Invader.Explorer).Cast <HealthToken>().OrderBy(x => x.StrifeCount).FirstOrDefault();

        if (explorerToDrown != null)
        {
            await ctx.Move(explorerToDrown, ctx.Space, drowningOcean);
        }

        // drop town in the ocean to drown
        var townToDrown = ctx.Tokens.OfType(Invader.Town).Cast <HealthToken>()
                          .OrderByDescending(x => x.FullHealth) // items with most health - usually are all the same
                          .ThenBy(x => x.Damage)                // pick least damaged
                          .FirstOrDefault();

        if (townToDrown != null)
        {
            await ctx.Move(townToDrown, ctx.Space, drowningOcean);
        }

        await ctx.DestroyDahan(1);         // destroying dahan is the same as drowning them
    }
Exemplo n.º 3
0
    static async Task ActAsync(TargetSpaceCtx ctx, int damage)
    {
        // Destroy 1 dahan
        await ctx.DestroyDahan(1);

        // 4 plant  split this power's damage however desired between target land and another 1 of your lands
        int damageToTarget = ctx.Self.Elements[Element.Plant] < 4 && ctx.Self.Presence.Spaces.Count() > 1
                        ? damage
                        : await ctx.Self.SelectNumber("Damage to apply to " + ctx.Space.Label, damage);

        await ctx.DamageInvaders(damage);

        int remainingDamage = damage - damageToTarget;

        if (remainingDamage > 0)
        {
            var secondaryTarget = await ctx.Decision(new Select.Space(
                                                         $"Apply {remainingDamage} reamaining damage"
                                                         , ctx.Self.Presence.Spaces
                                                         , Present.Always
                                                         ));

            await ctx.Target(secondaryTarget).DamageInvaders(remainingDamage);
        }
    }
Exemplo n.º 4
0
    static public async Task ActAsync(TargetSpaceCtx ctx)
    {
        // 2 fear
        ctx.AddFear(2);

        // for each of your SS in / adjacent to target land, 2 damage
        int sacredSiteCount = ctx.Range(1).Intersect(ctx.Self.Presence.SacredSites).Count();
        await ctx.DamageInvaders(2 *sacredSiteCount);

        // destroy all dahan
        await ctx.DestroyDahan(int.MaxValue);
    }
Exemplo n.º 5
0
    static async Task DamageOtherCoast(TargetSpaceCtx otherCtx)
    {
        // 1 fear
        otherCtx.AddFear(1);
        // 4 damage
        await otherCtx.DamageInvaders(4);

        // destroy 1 dahan
        if (otherCtx.Dahan.Any)
        {
            await otherCtx.DestroyDahan(1);
        }
    }
    static public async Task ActAsync(TargetSpaceCtx ctx)
    {
        // destroy 1 explorer
        await ctx.Invaders.Destroy(1, Invader.Explorer);

        // and 1 dahan
        await ctx.DestroyDahan(1);

        // add 1 wilds
        await ctx.Wilds.Add(1);

        // defend 2
        ctx.Defend(2);
    }
Exemplo n.º 7
0
    static public async Task ActAsync(TargetSpaceCtx ctx)
    {
        // 1 fear
        ctx.AddFear(1);

        //  1 damage
        int damage = 1;

        // destroy 1 dahan
        if (ctx.Dahan.Any)
        {
            await ctx.DestroyDahan(1);
        }

        // if target is J / S, +1 damage
        if (ctx.IsOneOf(Terrain.Jungle, Terrain.Sand))
        {
            ++damage;
        }

        await ctx.DamageInvaders(damage);
    }
Exemplo n.º 8
0
    static public async Task ActAsync(TargetSpaceCtx ctx)
    {
        // 2 fear
        ctx.AddFear(2);

        // +8 damage
        await ctx.DamageInvaders(8);

        // destroy 2 dahan
        await ctx.DestroyDahan(2);

        if (await ctx.YouHave("3 water,2 earth"))
        {
            var otherCoastalsOnSameBoard = ctx.Space.Board
                                           .Spaces.Where(s => s != ctx.Space && ctx.Target(s).IsCoastal)
                                           .ToArray();

            foreach (var otherCoast in otherCoastalsOnSameBoard)
            {
                await DamageOtherCoast(ctx.Target(otherCoast));
            }
        }
    }
Exemplo n.º 9
0
    static public async Task ActAsync(TargetSpaceCtx ctx)
    {
        // 1 fear
        ctx.AddFear(1);

        // 7 damage
        int damage = 7;

        // add 1 blight
        await ctx.AddBlight(1);

        // destroy all dahan
        await ctx.DestroyDahan(ctx.Dahan.Count);

        if (await ctx.YouHave("3 earth,2 plant,2 animal"))
        {
            int blightCount = ctx.BlightOnSpace;
            ctx.AddFear(blightCount);
            damage += 4 * blightCount;
        }

        await ctx.DamageInvaders(damage);
    }
Exemplo n.º 10
0
    static public async Task Option3b(TargetSpaceCtx ctx)
    {
        var invaders = ctx.Tokens.Invaders().ToArray();

        if (invaders.Length == 0 || !ctx.Dahan.Any)
        {
            return;
        }
        var invader = (HealthToken)await ctx.Decision(new Select.TokenFrom1Space("Select invader to fight 1 dahan", ctx.Space, invaders, Present.Always));

        // Calc Invader Damage
        var(damageFromInvader, newInvaderToken) = GetDamageFromInvader(ctx.Tokens, invader);
        // Calc Dahan Damage
        int damageFromDahan = 2;

        // Damage invader
        await ctx.Invaders.ApplyDamageTo1(damageFromDahan, newInvaderToken);

        // damage dahan
        if (damageFromInvader >= 2)
        {
            await ctx.DestroyDahan(1);
        }
    }
Exemplo n.º 11
0
    static async Task DestroyDahanAndBeasts(TargetSpaceCtx ctx)
    {
        await ctx.DestroyDahan(int.MaxValue);

        await ctx.Beasts.Destroy(ctx.Beasts.Count);
    }