Beispiel #1
0
    public GrinningTricksterStirsUpTrouble()
        : base(
            new SpiritPresence(
                new PresenceTrack(Track.Energy1, Track.MoonEnergy, Track.Energy2, Track.AnyEnergy, Track.FireEnergy, Track.Energy3),
                new PresenceTrack(Track.Card2, Track.Push1Dahan, Track.Card3, Track.Card3, Track.Card4, Track.AirEnergy, Track.Card5)
                )
            , PowerCard.For <ImpersonateAuthority>()
            , PowerCard.For <InciteTheMob>()
            , PowerCard.For <OverenthusiasticArson>()
            , PowerCard.For <UnexpectedTigers>()
            )
    {
        // Growth
        this.Growth = new Growth(2,
                                 new GrowthOption(new GainEnergy(-1), new ReclaimAll(), new MovePresence(1))
        {
            GainEnergy = -1
        },
                                 new GrowthOption(new PlacePresence(2)),
                                 new GrowthOption(new DrawPowerCard()),
                                 new GrowthOption(new GainEnergyEqualToCardPlays())
                                 );

        // Innates
        InnatePowers = new InnatePower[] {
            InnatePower.For <LetsSeeWhatHappens>(),
            InnatePower.For <WhyDontYouAndThemFight>()
        };
    }
Beispiel #2
0
    public LureOfTheDeepWilderness() : base(
            new SpiritPresence(
                new PresenceTrack(Track.Energy1, Track.Energy2, Track.MoonEnergy, Track.MkEnergy(3, Element.Plant), Track.MkEnergy(4, Element.Air), Track.Energy5Reclaim1),
                new PresenceTrack(Track.Card1, Track.Card2, Track.AnimalEnergy, Track.Card3, Track.Card4, Track.Card5Reclaim1)
                )
            , PowerCard.For <GiftOfTheUntamedWild>()
            , PowerCard.For <PerilsOfTheDeepestIsland>()
            , PowerCard.For <SoftlyBeckonEverInward>()
            , PowerCard.For <SwallowedByTheWilderness>()
            )
    {
        Growth = new Growth(
            new GrowthOption(new ReclaimAll(), new GainEnergy(1)),
            new GrowthOption(new PlacePresence(4, Target.Inland))
            ).Add(
            new GrowthOptionGroup(1,
                                  new GrowthOption(new Gain1Element(Element.Moon, Element.Air, Element.Plant), new GainEnergy(2)),
                                  new GrowthOption(new DrawPowerCard())
                                  )
            );

        Presence.IsValid = (s) => !s.IsOcean && !s.IsCoastal;

        InnatePowers = new InnatePower[] {
            InnatePower.For <ForsakeSocietyToChaseAfterDreams>(),
            InnatePower.For <NeverHeardFromAgain>()
        };
    }
Beispiel #3
0
    public ManyMindsMoveAsOne()
        : base(
            new ManyMindsPresence(
                new PresenceTrack(Track.Energy0, Track.Energy1, Track.MkEnergy(Element.Air), Track.Energy2, Track.MkEnergy(Element.Animal), Track.Energy3, Track.Energy4),
                new PresenceTrack(Track.Card1, Track.Card2, CardBoost, Track.Card3, Track.Card3, Track.Card4, Track.Card5)
                )
            , PowerCard.For <ADreadfulTideOfScurryingFlesh>()
            , PowerCard.For <BoonOfSwarmingBedevilment>()
            , PowerCard.For <EverMultiplyingSwarm>()
            , PowerCard.For <GuideTheWayOnFeatheredWings>()
            , PowerCard.For <PursueWithScratchesPecksAndStings>()
            )
    {
        // Growth
        Growth = new Growth(
            new GrowthOption(new ReclaimAll(), new DrawPowerCard()),
            new GrowthOption(new PlacePresence(1), new PlacePresence(0)),
            new GrowthOption(new PlacePresenceAndBeast(), new GainEnergy(1), new Gather1Beast())
            );

        // Innates
        InnatePowers = new InnatePower[] {
            InnatePower.For <TheTeemingHostArrives>(),
            InnatePower.For <BesetAndConfoundTheInvaders>()
        };
    }
Beispiel #4
0
    public RiverSurges() : base(
            new RiverPresence(
                new PresenceTrack(Track.Energy1, Track.Energy2, Track.Energy2, Track.Energy3, Track.Energy4, Track.Energy4, Track.Energy5),
                new PresenceTrack(Track.Card1, Track.Card2, Track.Card2, Track.Card3, Track.CardReclaim1, Track.Card4, Track.Card5)
                ),
            PowerCard.For <BoonOfVigor>(),
            PowerCard.For <FlashFloods>(),
            PowerCard.For <RiversBounty>(),
            PowerCard.For <WashAway>()
            )
    {
        Growth = new(
            new GrowthOption(
                new ReclaimAll(),
                new DrawPowerCard(1),
                new GainEnergy(1)
                ),
            new GrowthOption(
                new PlacePresence(1),
                new PlacePresence(1)
                ),
            new GrowthOption(
                new DrawPowerCard(1),
                new PlacePresence(2)
                )
            );

        InnatePowers = new InnatePower[] {
            InnatePower.For <MassiveFlooding>()
        };
    }
    public StarlightSeeksItsForm() : base(
            new SpiritPresence(
                new CompoundPresenceTrack(
                    new PresenceTrack(Track.Energy1, Track.Energy2, Track_PickElement, Track.Energy4),
                    new PresenceTrack(0, NewGrowth1),
                    new PresenceTrack(0, Track_Gain1Energy, NewGrowth3)               // missing +1 energies
                    ),
                new CompoundPresenceTrack(
                    new PresenceTrack(Track.Card2, Track_PickElement, Track_PickElement, Track.Card3),
                    new PresenceTrack(0, NewGrowth2),
                    new PresenceTrack(0, Track_Gain1Energy, NewGrowth4)               // !!! missing +1 energies
                    )
                )
            , PowerCard.For <BoonOfReimagining>()
            , PowerCard.For <GatherTheScatteredLightOfStars>()
            , PowerCard.For <PeaceOfTheNighttimeSky>()
            , PowerCard.For <ShapeTheSelfAnew>()
            )
    {
        Growth = new Growth(3,
                            new GrowthOption(new ReclaimN()),
                            new GrowthOption(new PlacePresence(0)),
                            new GrowthOption(new GainEnergy(1)),
                            new GrowthOption(new MovePresence(3))
                            );

        InnatePowers = new InnatePower[] {
            InnatePower.For <AirMovesEarthEndures>(),
            InnatePower.For <FireBurnsWaterSoothes>(),
            InnatePower.For <SiderealGuidance>(),
            InnatePower.For <WoodSeeksGrowthHumansSeekFreedom>(),
            InnatePower.For <StarsBlazeInTheDaytimeSky>(),
        };
    }
Beispiel #6
0
    public HeartOfTheWildfire() : base(
            new BlazingPresence()
            , PowerCard.For <AsphyxiatingSmoke>()
            , PowerCard.For <FlashFires>()
            , PowerCard.For <ThreateningFlames>()
            , PowerCard.For <FlamesFury>()
            )
    {
        (Presence as BlazingPresence).spirit = this;
        InnatePowers = new InnatePower[] {
            InnatePower.For <FireStorm>(),
            InnatePower.For <TheBurnedLandRegrows>()
        };


        Growth = new(
            new GrowthOption(
                new ReclaimAll(),
                new DrawPowerCard(1),
                new GainEnergy(1)
                ),
            new GrowthOption(
                new DrawPowerCard(1),
                new PlacePresence(3)
                ),
            new GrowthOption(
                new PlacePresence(1),
                new GainEnergy(2),
                new EnergyForFire()
                )
            );
    }
Beispiel #7
0
    public LightningsSwiftStrike() : base(
            new SpiritPresence(
                new PresenceTrack(Track.Energy1, Track.Energy1, Track.Energy2, Track.Energy2, Track.Energy3, Track.Energy4, Track.Energy4, Track.Energy5),
                new PresenceTrack(Track.Card2, Track.Card3, Track.Card4, Track.Card5, Track.Card6)
                ),
            PowerCard.For <HarbingersOfTheLightning>(),
            PowerCard.For <LightningsBoon>(),
            PowerCard.For <RagingStorm>(),
            PowerCard.For <ShatterHomesteads>()
            )
    {
        Growth = new(
            new GrowthOption(
                new ReclaimAll(),
                new DrawPowerCard(1),
                new GainEnergy(1)
                ),
            // +1 presence range 2, +1 presence range 0(
            new GrowthOption(
                new PlacePresence(2),
                new PlacePresence(0)
                ),
            // +1 presense range 1, +3 energy
            new GrowthOption(new GainEnergy(3), new PlacePresence(1))
            );

        this.InnatePowers = new InnatePower[] {
            InnatePower.For <ThunderingDestruction>()
        };
    }
Beispiel #8
0
    public ASpreadOfRampantGreen() : base(
            new RampantGreenPresence(),
            PowerCard.For <FieldsChokedWithGrowth>(),
            PowerCard.For <GiftOfProliferation>(),
            PowerCard.For <OvergrowInANight>(),
            PowerCard.For <StemTheFlowOfFreshWater>()
            )
    {
        // Special rules: steady regeneration

        Growth = new Growth(
            new GrowthOption(new PlacePresence(2, Target.JungleOrWetland))
            ).Add(new GrowthOptionGroup(1,
                                        // reclaim, +1 power card
                                        new GrowthOption(
                                            new ReclaimAll(),
                                            new DrawPowerCard(1)
                                            ),
                                        // +1 presense range 1, play +1 extra card this turn
                                        new GrowthOption(
                                            new PlacePresence(1),
                                            new PlayExtraCardThisTurn(1)
                                            ),
                                        // +1 power card, +3 energy
                                        new GrowthOption(
                                            new GainEnergy(3),
                                            new DrawPowerCard()
                                            )
                                        ));

        this.InnatePowers = new InnatePower[] {
            InnatePower.For <CreepersTearIntoMortar>(),
            InnatePower.For <AllEnvelopingGreen>(),
        };
    }
Beispiel #9
0
    public Bringer() : base(
            new SpiritPresence(
                new PresenceTrack(Track.Energy2, Track.AirEnergy, Track.Energy3, Track.MoonEnergy, Track.Energy4, Track.AnyEnergy, Track.Energy5),
                new PresenceTrack(Track.Card2, Track.Card2, Track.Card2, Track.Card3, Track.Card3, Track.AnyEnergy)
                ),
            PowerCard.For <CallOnMidnightsDream>(),
            PowerCard.For <DreadApparitions>(),
            PowerCard.For <DreamsOfTheDahan>(),
            PowerCard.For <PredatoryNightmares>()
            )
    {
        Growth = new(
            // reclaim, +1 power card
            new GrowthOption(new ReclaimAll(), new DrawPowerCard(1)),
            // reclaim 1, add presence range 0
            new GrowthOption(new ReclaimN(), new PlacePresence(0)),
            // +1 power card, +1 pressence range 1
            new GrowthOption(new DrawPowerCard(1), new PlacePresence(1)),
            // add presense range Dahan or Invadors, +2 energy
            new GrowthOption(new GainEnergy(2), new PlacePresence(4, Target.DahanOrInvaders))
            );

        this.InnatePowers = new InnatePower[] {
            InnatePower.For <SpiritsMayYetDream>(),
            InnatePower.For <NightTerrors>()
        };
    }
    public void Level2_2DamagePush3TownOrExplorers()       // 2-Sun, 3-Water
    {
        var fixture     = new ConfigurableTestFixture();
        var space       = fixture.Board[5];
        var tokens      = fixture.GameState.Tokens[space];
        var destination = space.Adjacent.Last();

        // Given: spirit has a sacred site adjacent to the target space (range-1)
        fixture.Spirit.Presence.Adjust(space.Adjacent.First(), 2);
        //   And: Spirit has enough elements to trigger Level-2 of Massive Flooding
        fixture.InitElements("3 water,2 sun");
        //   And: target has 1 city, 4 towns, 5 explorers - !!! collapse this to 1 line
        fixture.InitTokens(space, "1C@3,4T@2,5E@1");

        //  When: activate innate
        _ = InnatePower.For <MassiveFlooding>().ActivateAsync(fixture.SelfCtx);
        fixture.Choose(space);                            // target space
        fixture.Choose(Tokens.Town);                      // 1st damage
        fixture.Choose(Tokens.Town1);                     // 2nd damage

        fixture.ChoosePush(Tokens.Town, destination);     // push 1
        fixture.ChoosePush(Tokens.Town, destination);     // push 2
        fixture.ChoosePush(Tokens.Explorer, destination); // push 3

        // Then: target has remaining invaders
        tokens.Summary.ShouldBe("1C@3,4E@1,1T@2");

        //  And: destination had pushed invaders
        fixture.GameState.Tokens[destination].Summary.ShouldBe("1E@1,2T@2");
    }
Beispiel #11
0
    public Thunderspeaker() : base(
            new SpiritPresence(
                new PresenceTrack(Track.Energy1, Track.AirEnergy, Track.Energy2, Track.FireEnergy, Track.SunEnergy, Track.Energy3),
                new PresenceTrack(Track.Card1, Track.Card2, Track.Card2, Track.Card3, Track.CardReclaim1, Track.Card3, Track.Card4)
                ),
            PowerCard.For <ManifestationOfPowerAndGlory>(),
            PowerCard.For <SuddenAmbush>(),
            PowerCard.For <VoiceOfThunder>(),
            PowerCard.For <WordsOfWarning>()
            )
    {
        Growth = new(
            new GrowthOption(
                new ReclaimAll(),
                new DrawPowerCard(1),
                new DrawPowerCard(1)
                ),
            new GrowthOption(
                new PlacePresence(2, Target.Dahan),
                new PlacePresence(1, Target.Dahan)
                ),
            new GrowthOption(
                new PlacePresence(1),
                new GainEnergy(4)
                )
            );

        this.InnatePowers = new InnatePower[] {
            InnatePower.For <GatherTheWarriors>(),
            InnatePower.For <LeadTheFuriousAssult>(),
        };
    }
Beispiel #12
0
    public SharpFangs() : base(
            new SpiritPresence(
                new PresenceTrack(Track.Energy1, Track.AnimalEnergy, Track.PlantEnergy, Track.Energy2, Track.AnimalEnergy, Track.Energy3, Track.Energy4),
                new PresenceTrack(Track.Card2, Track.Card2, Track.Card3, Track.CardReclaim1, Track.Card4, Track.Card5Reclaim1)
                ),
            PowerCard.For <PreyOnTheBuilders>(),
            PowerCard.For <TeethGleamFromDarkness>(),
            PowerCard.For <TerrifyingChase>(),
            PowerCard.For <TooNearTheJungle>()
            )
    {
        var beastOrJungleRange3 = new PlacePresence(3, Target.BeastOrJungle);

        Growth = new Growth(2,
                            new GrowthOption(new ReclaimAll(), new GainEnergy(-1), new DrawPowerCard(1))
        {
            GainEnergy = -1
        },
                            new GrowthOption(beastOrJungleRange3),
                            new GrowthOption(new DrawPowerCard(1), new GainEnergy(1))
        {
            GainEnergy = 1
        },
                            new GrowthOption(new GainEnergy(3))
        {
            GainEnergy = 3
        }
                            );

        this.InnatePowers = new InnatePower[] {
            InnatePower.For <FrenziedAssult>(),
            InnatePower.For <RagingHunt>(),
        };
    }
    public void Level1_Pushes1TownOrExplorer()       // 1-Sun, 2-Water
    {
        var fixture     = new ConfigurableTestFixture();
        var space       = fixture.Board[5];
        var tokens      = fixture.GameState.Tokens[space];
        var destination = space.Adjacent.Last();

        // Given: spirit has a sacred site adjacent to the target space (range-1)
        fixture.Spirit.Presence.Adjust(space.Adjacent.First(), 2);
        //   And: Spirit has enough elements to trigger Level-1 of Massive Flooding
        fixture.InitElements("1 sun,2 water");
        //   And: target has 1 city, 4 towns, 5 explorers
        fixture.InitTokens(space, "1C@3,5E@1,4T@2");

        //  When: activate innate
        _ = InnatePower.For <MassiveFlooding>().ActivateAsync(fixture.SelfCtx);
        fixture.Choose(space);                        // target space

        fixture.ChoosePush(Tokens.Town, destination); // push 1

        // Then: target has remaining invaders
        tokens.Summary.ShouldBe("1C@3,5E@1,3T@2");

        //  And: destination had pushed invaders
        fixture.GameState.Tokens[destination].Summary.ShouldBe("1T@2");
    }
Beispiel #14
0
    public Keeper() : base(
            new KeeperPresence(),
            // PowerCard.For<SkyStretchesToShore>(),
            PowerCard.For <BoonOfGrowingPower>(),
            PowerCard.For <RegrowFromRoots>(),
            PowerCard.For <SacrosanctWilderness>(),
            PowerCard.For <ToweringWrath>()
            )
    {
        (Presence as KeeperPresence).spirit = this;

        Growth = new Growth(2,
                            new GrowthOption(new ReclaimAll(), new GainEnergy(1))
        {
            GainEnergy = 1
        },
                            new GrowthOption(new DrawPowerCard(1)),
                            new GrowthOption(new GainEnergy(1), new PlacePresence(3, Target.PresenceOrWilds))
        {
            GainEnergy = 1
        },
                            new GrowthOption(new GainEnergy(-3), new DrawPowerCard(1), new PlacePresence(3, Target.NoBlight))
        {
            GainEnergy = -3
        }
                            );

        InnatePowers = new InnatePower[] {
            InnatePower.For <PunishThoseWhoTrespass>(),
            InnatePower.For <SpreadingWilds>(),
        };
    }
Beispiel #15
0
    public VolcanoLoomingHigh() : base(
            new VolcanoPresence(
                new PresenceTrack(Track.Energy1, Track.Energy2, Track.EarthEnergy, Track.Energy3, Track.Energy4, Track.Energy5),
                new PresenceTrack(Track.Card1, Track.MkCard(Element.Fire), Track.MkCard(Element.Earth), Track.Card2, Track.MkCard(Element.Air), Track.Card3, Track.MkCard(Element.Fire), Track.Card4)
                )
            , PowerCard.For <ExaltationOfMoltenStone>()
            , PowerCard.For <LavaFlows>()
            , PowerCard.For <PyroclasticBombardment>()
            , PowerCard.For <RainOfAsh>()
            )
    {
        Growth = new Growth(
            new GrowthOption(new ReclaimAll(), new DrawPowerCard(), new GainEnergy(3)),
            new GrowthOption(new PlacePresence(0, Target.Mountain), new PlacePresence(0, Target.Mountain)),
            new GrowthOption(new DrawPowerCard(), new PlacePresence(4, Target.Mountain), new PlayExtraCardThisTurn(1), new GainEnergy(2))
            );

        InnatePowers = new InnatePower[] {
            InnatePower.For <ExplosiveEruption>(),
            InnatePower.For <PoweredByTheFurnaceOfTheEarth>()
        };

        ((VolcanoPresence)(Presence)).SetSpirit(this);

        RangeCalc = new VolcanoTargetLandApi();
    }
Beispiel #16
0
    public FracturedDaysSplitTheSky() : base(
            new SpiritPresence(
                new PresenceTrack(Track.Energy1, Track.Energy1, Track.Energy2, Track.Energy2, Track.Energy2, Track.Energy2),
                new PresenceTrack(Track.Card1, Track.Card1, Track.Card1, Track.Card2, Track.Card2, Track.Card3)
                )
            , PowerCard.For <AbsoluteStatis>()
            , PowerCard.For <BlurTheArcOfYears>()
            , PowerCard.For <PourTimeSideways>()
            , PowerCard.For <ThePastReturnsAgain>()
            )
    {
        var g2Repeater = new ActionRepeater(2);
        var g3Repeater = new ActionRepeater(3);

        Growth = new Growth(
            new GrowthOption(
                new Gain1Element(Element.Air),
                new ReclaimAll(),
                new GainTime(2)
                ),
            new GrowthOption(
                new Gain1Element(Element.Moon),
                new DrawPowerCard(),
                new PlacePresence(2),
                g2Repeater.Bind(new GainTime(1)),
                g2Repeater.Bind(new PlayExtraCardThisTurn(2))
                ),
            new GrowthOption(
                new Gain1Element(Element.Sun),
                new DrawPowerCardFromDaysThatNeverWere(),
                new MovePresence(4),
                g3Repeater.Bind(new GainTime(1)),
                g3Repeater.Bind(new GainEnergy(2))
                )
            );

        InnatePowers = new InnatePower[] {
            InnatePower.For <SlipTheFlowOfTime>(),
            InnatePower.For <VisionsOfAShiftingFuture>()
        };

        DtnwMinor = new List <PowerCard>();
        DtnwMajor = new List <PowerCard>();
        decks.Add(new SpiritDeck {
            Icon = Img.Deck_DaysThatNeverWere_Minor, PowerCards = DtnwMinor
        });
        decks.Add(new SpiritDeck {
            Icon = Img.Deck_DaysThatNeverWere_Major, PowerCards = DtnwMajor
        });
    }
    public void InsufficientElements()
    {
        var fixture     = new ConfigurableTestFixture();
        var innatePower = InnatePower.For <MassiveFlooding>();

        // Given: spirit does not have enough elements to trigger anything
        //   And: should not be activatable
        innatePower.CouldActivateDuring(Phase.Slow, fixture.Spirit).ShouldBeFalse();

        //  When: but if we try anyway
        var task = innatePower.ActivateAsync(fixture.SelfCtx);

        //  Then: it is complete and nothing happens.
        task.IsCompleted.ShouldBeTrue();
    }
    public void Level3_2DamageToEachInvader()       // 3 sun, 4 water, 1 earth
    {
        var fixture = new ConfigurableTestFixture();
        var space   = fixture.Board[5];
        var tokens  = fixture.GameState.Tokens[space];

        // Given: spirit has a sacred site adjacent to the target space (range-1)
        fixture.Spirit.Presence.Adjust(space.Adjacent.First(), 2);
        //   And: Spirit has enough elements to trigger Level-3 of Massive Flooding
        fixture.InitElements("3 sun,4 water,1 earth");
        //   And: target has 1 city, 4 towns, 5 explorers - !!! collapse this to 1 line
        fixture.InitTokens(space, "1C@3,4T@2,5E@1");

        //  When: activate innate
        _ = InnatePower.For <MassiveFlooding>().ActivateAsync(fixture.SelfCtx);
        fixture.Choose(space);           // target space

        // Then: target has remaining invaders
        tokens.Summary.ShouldBe("1C@1");
    }
Beispiel #19
0
 public Shadows() : base(
         new SpiritPresence(
             new PresenceTrack(Track.Energy0, Track.Energy1, Track.Energy3, Track.Energy4, Track.Energy5, Track.Energy6),
             new PresenceTrack(Track.Card1, Track.Card2, Track.Card3, Track.Card3, Track.Card4, Track.Card5)
             ),
         PowerCard.For <MantleOfDread>(),
         PowerCard.For <FavorsCalledDue>(),
         PowerCard.For <CropsWitherAndFade>(),
         PowerCard.For <ConcealingShadows>()
         )
 {
     Growth = new(
         new GrowthOption(new ReclaimAll(), new DrawPowerCard(1)),
         new GrowthOption(new DrawPowerCard(1), new PlacePresence(1)),
         new GrowthOption(new PlacePresence(3), new GainEnergy(3))
         );
     this.InnatePowers = new InnatePower[] {
         InnatePower.For <DarknessSwallowsTheUnwary>()
     };
 }
Beispiel #20
0
    public SerpentSlumbering() : base(
            new SerpentPresence()
            , PowerCard.For <ElementalAegis>()
            , PowerCard.For <AbsorbEssence>()
            , PowerCard.For <GiftOfFlowingPower>()
            , PowerCard.For <GiftOfThePrimordialDeeps>()
            )
    {
        InnatePowers = new InnatePower[] {
            InnatePower.For <SerpentWakesInPower>(),
            InnatePower.For <SerpentRousesInAnger>()
        };

        Growth = new Growth(2,
                            new GrowthOption(new ReclaimAll(), new MovePresence(1)),
                            new GrowthOption(new DrawPowerCard(), new GainEnergy(1)),
                            new GrowthOption(new GainEnergy(4)),
                            new GrowthOption(new PlacePresence(3, Target.NoBlight))
                            );
    }
 public StonesUnyieldingDefiance() : base(
         new SpiritPresence(
             new PresenceTrack(Track.Energy2, Track.Energy3, AddCardPlay, Track.Energy4, AddCardPlay, Track.Energy6, AddCardPlay),
             new PresenceTrack(Track.Card1, Track.MkCard(Element.Earth), Track.MkCard(Element.Earth), EarthReclaim, EarthAndAny, Card2Earth)
             )
         , PowerCard.For <JaggedShardsPushFromTheEarth>()
         , PowerCard.For <PlowsShatterOnRockyGround>()
         , PowerCard.For <ScarredAndStonyLand>()
         , PowerCard.For <StubbornSolidity>()
         )
 {
     this.Growth = new Growth(
         new GrowthOption(new ReclaimAll(), new PlacePresence(3, Target.MountainOrPresence), new GainElements(Element.Earth, Element.Earth)),
         new GrowthOption(new PlacePresence(2), new GainEnergy(3)),
         new GrowthOption(new DrawPowerCard(), new PlacePresence(1))
         );
     InnatePowers = new InnatePower[] {
         InnatePower.For <HoldTheIslandFastWithABulwarkOfWill>(),
         InnatePower.For <LetThemBreakThemselvesAgainstTheStone>()
     };
 }
Beispiel #22
0
 public VengeanceAsABurningPlague() : base(
         new VengeancePresence(
             new PresenceTrack(Track.Energy1, Track.Energy2, Track.AnimalEnergy, Track.Energy3, Track.Energy4),
             new PresenceTrack(Track.Card1, Track.Card2, Track.FireEnergy, Track.Card2, Track.Card3, Track.Card3, Track.Card4)
             )
         , PowerCard.For <FetidBreathSpreadsInfection>()
         , PowerCard.For <FieryVengeance>()
         , PowerCard.For <Plaguebearers>()
         , PowerCard.For <StrikeLowWithSuddenFevers>()
         )
 {
     Growth = new Growth(
         new GrowthOption(new ReclaimAll(), new DrawPowerCard(), new GainEnergy(1)),
         new GrowthOption(new PlacePresence(2, Target.TownCityOrBlight), new PlacePresence(2, Target.TownCityOrBlight)),
         new GrowthOption(new DrawPowerCard(), new PlacePresenceOrDisease(), new GainEnergy(1))
         );
     InnatePowers = new InnatePower[] {
         InnatePower.For <EpidemicsRunRampant>(),
         InnatePower.For <SavageRevenge>()
     };
 }
Beispiel #23
0
    public VitalStrength() : base(
            new SpiritPresence(
                new PresenceTrack(Track.Energy2, Track.Energy3, Track.Energy4, Track.Energy6, Track.Energy7, Track.Energy8),
                new PresenceTrack(Track.Card1, Track.Card1, Track.Card2, Track.Card2, Track.Card3, Track.Card4)
                ),
            PowerCard.For <GuardTheHealingLand>(),
            PowerCard.For <AYearOfPerfectStillness>(),
            PowerCard.For <RitualsOfDestruction>(),
            PowerCard.For <DrawOfTheFruitfulEarth>()
            )
    {
        Growth = new(
            new GrowthOption(new ReclaimAll(), new PlacePresence(2)),
            new GrowthOption(new DrawPowerCard(), new PlacePresence(0)),
            new GrowthOption(new GainEnergy(2), new PlacePresence(1))
            );

        this.InnatePowers = new InnatePower[] {
            InnatePower.For <GiftOfStrength>()
        };
    }
    public ShroudOfSilentMist() : base(new SpiritPresence(
                                           new PresenceTrack(1, Track.Energy0, Track.Energy1, Track.WaterEnergy, Track.Energy2, Track.AirEnergy),
                                           new PresenceTrack(1, Track.Card1, Track.Card2, MovePresence, Track.MoonEnergy, Track.Card3, Track.Card4, Track.CardReclaim1, Track.Card5)
                                           )
                                       , PowerCard.For <FlowingAndSilentFormsDartBy>()
                                       , PowerCard.For <UnnervingPall>()
                                       , PowerCard.For <DissolvingVapors>()
                                       , PowerCard.For <TheFogClosesIn>()
                                       )
    {
        this.Growth = new Growth(
            new GrowthOption(new ReclaimAll(), new DrawPowerCard()),
            new GrowthOption(new PlacePresence(0), new PlacePresence(0)),
            new GrowthOption(new DrawPowerCard(), new PlacePresence(3, Target.MountainOrWetland))
            );


        this.InnatePowers = new InnatePower[] {
            InnatePower.For <SuffocatingShroud>(),
            InnatePower.For <LostInTheSwirlingHaze>()
        };
    }
Beispiel #25
0
    public Ocean() : base(
            new OceanPresence(
                new PresenceTrack(Track.Energy0, Track.MoonEnergy, Track.WaterEnergy, Track.Energy1, Track.EarthEnergy, Track.WaterEnergy, Track.Energy2),
                new PresenceTrack(Track.Card1, Track.Card2, Track.Card2, Track.Card3, Track.Card4, Track.Card5)
                ),
            PowerCard.For <CallOfTheDeeps>(),
            PowerCard.For <GraspingTide>(),
            PowerCard.For <SwallowTheLandDwellers>(),
            PowerCard.For <TidalBoon>()
            )
    {
        Growth = new(
            // Option 1 - reclaim, +1 power, gather 1 presense into EACH ocean, +2 energy
            new GrowthOption(
                new GatherPresenceIntoOcean(),
                new ReclaimAll(),
                new DrawPowerCard(),
                new GainEnergy(2)
                ),
            // Option 2 - +1 presence range any ocean, +1 presense in any ociean, +1 energy
            new GrowthOption(
                new GainEnergy(1),
                new PlaceInOcean(),
                new PlaceInOcean()
                ),
            // Option 3 - gain power card, push 1 presense from each ocean,  add presense on costal land range 1
            new GrowthOption(
                new PushPresenceFromOcean(),
                new DrawPowerCard(),
                new PlacePresence(1, Target.Coastal)
                )
            );

        InnatePowers = new InnatePower[] {
            InnatePower.For <OceanBreaksTheShore>(),
            InnatePower.For <PoundShipsToSplinters>()
        };
    }
    public ShiftingMemoryOfAges()
        : base(
            new SpiritPresence(
                new PresenceTrack(Track.Energy0, Track.Energy1, Track.Energy2, Prepare(3), Track.Energy4, Track.Reclaim1Energy, Track.Energy5, Prepare(6)),
                new PresenceTrack(Track.Card1, Track.Card2, Track.Card2, DiscardElementsForCardPlay, Track.Card3)
                ),
            PowerCard.For <BoonOfAncientMemories>(),
            PowerCard.For <ElementalTeachings>(),
            PowerCard.For <ShareSecretsOfSurvival>(),
            PowerCard.For <StudyTheInvadersFears>()
            )
    {
        Growth = new Growth(
            new GrowthOption(new ReclaimAll(), new PlacePresence(0)),
            new GrowthOption(new DrawPowerCard(), new PlacePresence(2)),
            new GrowthOption(new PlacePresence(1), new GainEnergy(2)),
            new GrowthOption(new GainEnergy(9))
            );

        InnatePowers = new InnatePower[] {
            InnatePower.For <LearnTheInvadersActions>(),
            InnatePower.For <ObserveTheEverChangingWorld>()
        };
    }