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 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 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>()
};
}
public async Task Repeat_BadlandsWorksOnSameTargetTwice()
{
var fix = new ConfigurableTestFixture();
var space1 = fix.Board[3];
// Given: 2 sun, 3 fire, 3 earth
fix.InitElements("2 sun,3 fire,3 earth");
// And: target land has 1 presence, 2 Cities
fix.Spirit.Presence.Adjust(space1, 1);
fix.InitTokens(space1, "3C@3");
// When: play card
var task = PowerCard.For <ForestsOfLivingObsidian>().ActivateAsync(fix.SelfCtx);
// And: targeting space 1
fix.Choose(space1);
fix.Choose("C@2"); // 3C@2 - Damage 1 of them (1 of 1)
fix.GameState.Tokens[space1].Summary.ShouldBe("1C@1,2C@2,1M");
// And: targeting space 1 a 2nd time
fix.Choose(space1); // Should Kill the 1C@1, and reduce the 2C@2 to 2C@1
fix.Choose("C@1"); // Kill 1st City
fix.Choose("C@1"); // Kill 2nd City
fix.GameState.Tokens[space1].Summary.ShouldBe("2M");
task.IsCompletedSuccessfully.ShouldBeTrue();
}
static async Task PlayCardByPayingHalfCostOrForgetting(PowerCard card, SelfCtx ctx)
{
// target spirit may now play the major power they keep by:
// * paying half its cost (round up) OR
int cost = (card.Cost + card.Cost % 2) / 2;
var payingHalfCostOption = new SelfAction(
$"paying {cost}",
ctx => ctx.Self.PlayCard(card, cost)
).Matches(x => cost <= x.Self.Energy);
// * forgetting it at the end of turn.
var forgettingCardOption = new SelfAction(
$"forgetting at end of turn",
ctx => {
ctx.Self.PlayCard(card, 0);
ctx.GameState.TimePasses_ThisRound.Push((gs) => {
ctx.Self.Forget(card); return(Task.CompletedTask); // this must run befire cards are moved to discard, or it will be forgotten for Shifting Memories
});
}
);
// !!! It gains all elmemental thresholds. - implement!
await ctx.SelectAction_Optional($"Play {card.Name} now by:",
payingHalfCostOption,
forgettingCardOption
);
}
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>(),
};
}
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>(),
};
}
public void BuildAndRavage_BecomesTwoBuilds()
{
List <string> invaderLog = new List <string>();
// Given: Going to Ravage / Build in Jungle
var(user, ctx) = TestSpirit.SetupGame(PowerCard.For <CallToTrade>(), (gs) => {
var jungleCard = new InvaderCard(Terrain.Jungle);
gs.InvaderDeck = InvaderDeck.BuildTestDeck(jungleCard, jungleCard, jungleCard, jungleCard);
gs.NewLogEntry += (s) => invaderLog.Add(s.Msg());
});
// Given: advance to 2nd round where we have a ravage
user.DoesNothingForARound();
invaderLog.Clear();
// Given: a space that IS-RAVAGE AND BUILD
var spaceCtx = ctx.AllSpaces
.Select(ctx.Target)
.Last(s => s.MatchesRavageCard && s.MatchesBuildCard); // last stays away from city and ocean
invaderLog.Add("Selected target:" + spaceCtx.Space.Label);
// And: it has 3 explorers (in case dahan attacks during ravage, would still 1 left over
Given_HasOnly3Explorers(spaceCtx);
Given_Has2Dahan(spaceCtx);
Given_NoSuroundingTowns(spaceCtx);
Given_NoSuroundingDahan(spaceCtx);
When_GrowsBuysAndActivatesCard(user, spaceCtx);
spaceCtx.Tokens.InvaderSummary().ShouldBe("1C@3,1T@2,4E@1");
}
public override async Task ActivateAsync(SelfCtx ctx)
{
if (ctx.Self is not FracturedDaysSplitTheSky fracturedDays)
{
return;
}
var minor = fracturedDays.DtnwMinor;
var major = fracturedDays.DtnwMajor;
PowerCard card = await ctx.Self.SelectPowerCard("Gain Power Card from Days That Never Were", minor.Union(major), CardUse.AddToHand, Present.Always);
if (card == null)
{
return; // in case both hands are empty.
}
fracturedDays.AddCardToHand(card);
if (minor.Contains(card))
{
minor.Remove(card);
}
else
{
major.Remove(card);
await fracturedDays.ForgetPowerCard_UserChoice(Present.Always);
}
}
public void OneRavage_ReplacedWithBuild()
{
var(user, ctx) = TestSpirit.SetupGame(PowerCard.For <CallToTrade>());
// Given: advance to 2nd round where we have a ravage
user.DoesNothingForARound();
// Given: a space that IS-RAVAGE but NOT-BUILD
var spaceCtx = ctx.AllSpaces
.Select(ctx.Target)
.Last(s => s.MatchesRavageCard && !s.MatchesBuildCard); // last stays away from city and ocean
// And: it has 3 explorers (in case dahan attacks during ravage, would still 1 left over
Given_HasOnly3Explorers(spaceCtx);
Given_Has2Dahan(spaceCtx);
Given_NoSuroundingTowns(spaceCtx);
Given_NoSuroundingDahan(spaceCtx);
string info = $"{spaceCtx.Space.Label} {ctx.GameState.InvaderDeck.Build.Single()} ";
When_GrowsBuysAndActivatesCard(user, spaceCtx);
// Then: Card converted ravage to a build
spaceCtx.Tokens.InvaderSummary().ShouldBe("1T@2,3E@1");
}
public void TerrorLevel3_RavageRemainsRavage()
{
var(user, ctx) = TestSpirit.SetupGame(PowerCard.For <CallToTrade>());
// Elevate to Terror Level 3
Given_TerrorLevelIs3(ctx);
// Given: advance to 2nd round where we have a ravage
user.DoesNothingForARound();
// Given: a space that IS-RAVAGE but NOT-BUILD
var spaceCtx = ctx.AllSpaces
.Select(ctx.Target)
.Last(s => s.MatchesRavageCard && !s.MatchesBuildCard); // last stays away from city and ocean
// And: it has 3 explorers (in case dahan attacks during ravage, would still 1 left over
Given_HasOnly3Explorers(spaceCtx);
Given_Has2Dahan(spaceCtx);
Given_NoSuroundingTowns(spaceCtx);
Given_NoSuroundingDahan(spaceCtx);
When_GrowsBuysAndActivatesCard(user, spaceCtx);
// Then: Ravage remains - 3 explorers kill 1 dahan, remaining dahan kills 2 explorers
spaceCtx.Tokens.InvaderSummary().ShouldBe("1E@1");
}
public void MementoRestoresDeck()
{
PowerCardDeck deck = new PowerCardDeck(new PowerCard[] {
PowerCard.For <Drought>(),
PowerCard.For <DevouringAnts>(),
PowerCard.For <DriftDownIntoSlumber>(),
PowerCard.For <EnticingSplendor>(),
PowerCard.For <LureOfTheUnknown>(),
PowerCard.For <NaturesResilience>(),
PowerCard.For <PullBeneathTheHungryEarth>(),
PowerCard.For <QuickenTheEarthsStruggles>(),
PowerCard.For <RainOfBlood>(),
PowerCard.For <SapTheStrengthOfMultitudes>(),
PowerCard.For <SongOfSanctity>(),
PowerCard.For <SteamVents>(),
PowerCard.For <UncannyMelting>(),
}, new Random());
// Given: saving state
var memento = deck.SaveToMemento();
// And: draw first 4 cards
string originalFirstFourCards = deck.Flip(4).Select(c => c.Name).Join(",");
// And: draw some more we don't care about
deck.Flip(4);
// When: restore state using memento
deck.RestoreFrom(memento);
// Then: first 4 cards should be the same
deck.Flip(4).Select(c => c.Name).Join(",").ShouldBe(originalFirstFourCards);
}
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()
)
);
}
static public (VirtualTestUser, SelfCtx) SetupGame(
PowerCard powerCard,
Action <GameState> modGameState = null
)
{
var spirit = new TestSpirit(powerCard);
var gs = new GameState(spirit, Board.BuildBoardA())
{
InvaderDeck = new InvaderDeck(null) // Same order every time
};
modGameState?.Invoke(gs);
_ = new SinglePlayer.SinglePlayerGame(gs);
var user = new VirtualTestUser(spirit);
var starterCtx = spirit.Bind(gs);
// Disable destroying presence
// starterCtx.GameState.AddBlightSideEffect = (gs,space) => new AddBlightEffect { Cascade=false,DestroyPresence=false };
starterCtx.GameState.ModifyBlightAddedEffect.ForGame.Add(x => { x.Cascade = false; x.DestroyPresence = false; });
return(user, starterCtx);
}
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();
}
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>(),
};
}
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 void SingleBuild(bool playsCard, string result)
{
var(user, ctx) = TestSpirit.SetupGame(PowerCard.For <RitesOfTheLandsRejection>());
// Given: find a space with 1 explorer
var spaceCtx = ctx.AllSpaces
.Select(ctx.Target)
.First(sc => sc.Tokens.InvaderSummary() == "1E@1");
// And: add Dahan (because card requires it)
spaceCtx.Dahan.Init(1);
// When: growing
user.Grows();
// And: purchase test card
user.PlaysCard(RitesOfTheLandsRejection.Name);
if (playsCard)
{
user.SelectsFastAction(RitesOfTheLandsRejection.Name);
user.TargetsLand_IgnoreOptions(spaceCtx.Space.Label);
user.AssertDecisionX("Select Power Option", "{Stop build - 1 fear / (Dahan or T/C)},Push up to 3 dahan", "{}");
}
else
{
// And: done with fast (no more cards..)
user.IsDoneWith(Phase.Fast);
}
// Then: space should have a building
System.Threading.Thread.Sleep(10);
spaceCtx.Tokens.InvaderSummary().ShouldBe(result);
}
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 void ReturningKeeperPresence_PushesDahan()
{
var fix = new ConfigurableTestFixture {
Spirit = new Keeper()
};
var space = fix.Board[5];
var dahanDestination = space.Adjacent.First();
// Given: Keeper has a destroyed presence
fix.Spirit.Presence.Destroyed = 1;
// And: a presence on target space.
fix.Spirit.Presence.Adjust(space, 1);
// And: Dahan on space
fix.InitTokens(space, "1D@2");
// When: play the card
var task = PowerCard.For <SkiesHeraldTheSeasonOfReturn>().ActivateAsync(fix.SelfCtx);
// target space
fix.Choose(space);
// Then: Should Push Dahan (per keeper's Sacred Site)
fix.Choose("D@2");
fix.Choose(dahanDestination);
// And: May Gather up to 2 dahan (per the card)
fix.Choose("D@2 on " + dahanDestination.Text); // "Gather up to 2 Dahan"
// And: May push 1 blight
// no blight to push
task.IsCompletedSuccessfully.ShouldBeTrue();
}
/// <summary>
/// If in hand, allows discarding instead of forgetting.
/// </summary>
public override void Forget(PowerCard card)
{
// (Source-1) Purchased / Active
if (InPlay.Contains(card))
{
foreach (var el in card.Elements)
{
Elements[el.Key] -= el.Value; // lose elements from forgotten card
}
InPlay.Remove(card);
DiscardPile.Add(card);
return;
}
if (Hand.Contains(card))
{
Hand.Remove(card);
DiscardPile.Add(card);
return;
}
if (DiscardPile.Contains(card))
{
base.Forget(card);
return;
}
throw new System.Exception("Can't find card to forget:" + card.Name);
}
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>(),
};
}
public async Task Repeat_BadlandsWorksOnBothTargets()
{
var fix = new ConfigurableTestFixture();
var space1 = fix.Board[3];
var space2 = fix.Board[8];
// Given: 2 sun, 3 fire, 3 earth
fix.InitElements("2 sun,3 fire,3 earth");
// And: target land #1 has 1 presence, 3 explorers and 1 town
fix.InitPresence(space1, 1);
fix.InitTokens(space1, "3E@1,1T@2");
// And: target land #2 has the same (1 presence, 3 explorers and 1 town)
fix.InitPresence(space2, 1);
fix.InitTokens(space2, "3E@1,1T@2");
// When: play card
var task = PowerCard.For <ForestsOfLivingObsidian>().ActivateAsync(fix.SelfCtx);
// And: targeting space 1
fix.Choose(space1);
fix.Choose("T@1"); // Damage (1 remaining)
// And: targeting space 2
fix.Choose(space2);
fix.Choose("T@1"); // Damage (1 remaining)
task.IsCompletedSuccessfully.ShouldBeTrue();
}
public void IsFastAndCost1()
{
var suddenAmbush = PowerCard.For <SuddenAmbush>();
suddenAmbush.DisplaySpeed.ShouldBe(Phase.Fast);
suddenAmbush.Cost.ShouldBe(2);
}
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 Replaying_FastCards()
{
// Given: Earth has enough elements to trigger GOS
User.SelectsGrowthA_Reclaim_PP2();
spirit.Elements[Element.Sun] = 1;
spirit.Elements[Element.Earth] = 2;
spirit.Elements[Element.Plant] = 2;
// And: Earth has 4 cards
var cards = new PowerCard[] {
MakePowerCard(Slow0), // not played
MakePowerCard(Fast0), // not played
MakePowerCard(Fast1), // played - should appear
MakePowerCard(Fast2) // played - no - too expensive
};
spirit.tempCardPlayBoost = cards.Length;
spirit.Hand.AddRange(cards);
PlayCards(cards);
User.IsDoneBuyingCards();
// And: already played 2 fast cards (cost 1 & 2)
User.SelectsFastAction("Fast-0,(Fast-1),Fast-2,Gift of Strength");
User.SelectsFastAction("Fast-0,(Fast-2),Gift of Strength");
User_PlaysGiftOfStrengthOnSelf();
// Then: user can replay ONLY the played: Fast-1 card.
User.SelectsFastAction("Fast-0,(Replay Card [max cost:1])");
User.AssertDecision("Select card to replay", "Fast-1 $1 (Fast)", "Fast-1 $1 (Fast)"); // !!! should there be a ,Done here?
}
public void ShowAllChoosePoints(Pawn _owner, PowerCard _powerCard)
{
m_closeButton.onClick.RemoveAllListeners();
m_closeButton.onClick.AddListener(() => {
gameObject.SetActive(false);
});
gameObject.SetActive(true);
if (_powerCard.m_powerType == PowerTypes.LongitudeMaster || _powerCard.m_powerType == PowerTypes.PosX_NegX || _powerCard.m_powerType == PowerTypes.ThreePoints)
{
return;
}
m_chooseText.text = "";
if (_powerCard.m_powerType == PowerTypes.GMTMaster)
{
m_chooseText.text = "Choose GMT time as strategy";
}
else if (_powerCard.m_powerType == PowerTypes.Master)
{
m_chooseText.text = "Choose GMT Point where you want to jump";
}
foreach (var _value in m_values)
{
DestroyImmediate(_value.gameObject);
}
m_values.Clear();
for (int i = 1; i <= GameplayManager.r_TotalLongitude; i++)
{
Value _value = Instantiate(m_choosePointPrefab, m_choosePointContainer);
_value.UpdateValue(_owner, _powerCard, i);
m_values.Add(_value);
}
}
public void OnPowerCardPlayed(Pawn _owner, PowerCard _playedPowerCard, int _value)
{
m_powerCardGMTOrLongValue = _value;
m_pickCardView.ObscurePickCardView(false);
m_pickCardView.UpdatePickCardView(_owner, _playedPowerCard);
GameplayCanvasManager.m_Instance.ShowGameplayCanvasMenu(GameplayCanvasMenu.PickCardPanel);
}
public void purchaseCard(PowerCard card)
{
Energy e = player.GetComponent <Energy>();
if (card.getCost() > e.getEnergy())
{
Debug.Log("You do not have enough Energy to purchase this card.");
}
else
{
e.removeEnergy(card.getCost());
playerHand.Add(card);
stock.Remove(card);
if (card.getType().Equals("Discard"))
{
card.executeCard();
playerHand.Remove(card);
}
if (deck.Count >= 1)
{
stock.Add(deck[0]);
}
else
{
Debug.Log("The deck is empty!");
}
}
}
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>()
};
}
private static void LoadOverlordCards(Game game)
{
StreamReader reader = new StreamReader(TitleContainer.OpenStream("overlordcards.txt"));
overlordCards = new List<OverlordCard>();
int n = int.Parse(reader.ReadLine());
for (int i = 0; i < n; i++)
{
string line = reader.ReadLine();
if (line.StartsWith("//")) continue;
OverlordCard card = null;
string[] data = line.Split(new char[] { ',' }, 9);
int id = int.Parse(data[0]);
string type = data[1];
string name = data[2];
int amount = int.Parse(data[3]);
int cost = int.Parse(data[4]);
int sell = int.Parse(data[5]);
string description = data[7];
switch (type)
{
case "Spawn":
List<Monster> monsters = new List<Monster>();
string[] creaturesToSpawn = data[6].Split('/');
for (int j = 0; j < creaturesToSpawn.Length; j++)
{
for (int k = 0; k < int.Parse(creaturesToSpawn[j].Split(' ')[1]); k++)
{
monsters.Add(GetMonster(int.Parse(creaturesToSpawn[j].Split(' ')[0])));
}
}
card = new SpawnCard(id, name, description, cost, sell, monsters.ToArray());
break;
case "Power":
card = new PowerCard(id, name, description, cost, sell);
break;
case "Trap":
card = new TrapCard(id, name, description, cost, sell);
break;
case "Event":
card = new EventCard(id, name, description, cost, sell);
break;
}
if (card != null)
overlordCards.Add(card);
}
}
