Beispiel #1
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 #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>()
        };
    }
    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 #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>()
        };
    }
Beispiel #5
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 #6
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>()
        };
    }
Beispiel #7
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 #8
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()
                )
            );
    }
    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 #10
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 #11
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>()
        };
    }
    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 #13
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();
    }
Beispiel #15
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 #16
0
        void CalcWrappingString(
            List <TokenPosition> tokens,
            List <TextPosition> texts,
            string description,
            Font font,
            ref int x,
            ref int y,
            int left,
            int width,
            Graphics graphics
            )
        {
            var descriptionParts = InnatePower.Tokenize(description);

            foreach (var part in descriptionParts)
            {
                if (part[0] == '{' && part[^ 1] == '}')
                {
                    // token
                    tokens.Add(CalcTokenPosition(part[1..^ 1], ref x, ref y, x, width));
    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 #18
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))
                            );
    }
Beispiel #19
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>()
     };
 }
 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 #21
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>()
        };
    }
Beispiel #22
0
        public InnateLayout(InnatePower power, int x, int y, int width, float textHeightMultiplier, Graphics graphics)
        {
            textEmSize = width * textHeightMultiplier;

            iconDimension = (int)(textEmSize * 1.9f);
            elementHeight = (int)(textEmSize * 2.3f);
            rowHeight     = (int)(textEmSize * 2.5f);

            int margin       = (int)(width * .02f);       // 2% of width
            int workingWidth = width - margin * 2;

            // "All-Enveloping Green"
            TitleBounds = new Rectangle(x + margin, y + margin, workingWidth, (int)(workingWidth * .12f));               // Height is 10% of width;				// output - titleRect

            // brown box
            AttributeBounds     = new Rectangle(x + margin, TitleBounds.Bottom, workingWidth, (int)(workingWidth * .15f));
            AttributeRows       = AttributeBounds.SplitVerticallyAt(0.40f);
            AttributeLabelCells = AttributeRows[0].SplitHorizontally(3);
            AttributeValueCells = AttributeRows[1].SplitHorizontally(3);

            // Options
            var options = new List <WrappingText_InnateOptions>();
            int optionY = AttributeBounds.Bottom + (int)(rowHeight * 0.25f);

            // General instructions
            if (!string.IsNullOrEmpty(power.GeneralInstructions))
            {
                GeneralInstructions = CalcGeneralInstructionsLayout(power.GeneralInstructions, AttributeBounds.Left, optionY, workingWidth, graphics);
                optionY             = GeneralInstructions.Bounds.Bottom;
            }

            foreach (var innatePowerOption in power.DrawableOptions)
            {
                var wrapInfo = CalcInnateOptionLayout(innatePowerOption, AttributeBounds.Left, optionY, workingWidth, graphics);
                options.Add(wrapInfo);
                optionY = wrapInfo.Bounds.Bottom;
            }
            Options = options.ToArray();
            Bounds  = new Rectangle(x, y, width, optionY - y);
        }
    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 #24
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>()
        };
    }
Beispiel #26
0
 public InnatePainter(InnatePower power, InnateLayout layout)
 {
     this.power  = power;
     this.layout = layout;
 }
Beispiel #27
0
 public void Tokenize(string original, string parsedAndJoined)
 {
     InnatePower.Tokenize(original).Join("|").ShouldBe(parsedAndJoined);
 }