@gamepark/skyrift 0.4.3 → 0.6.0

package/dist/CustomMoveType.d.ts

@@ -5,5 +5,7 @@ export declare enum CustomMoveType {
     EndEffect = 4,
     Pass = 5,
     Challenge = 6,
-    ActivateCard = 7
+    ActivateCard = 7,
+    ChooseSuit = 8,
+    ChooseCard = 9
 }

package/dist/CustomMoveType.js

@@ -7,4 +7,6 @@ export var CustomMoveType;
     CustomMoveType[CustomMoveType["Pass"] = 5] = "Pass";
     CustomMoveType[CustomMoveType["Challenge"] = 6] = "Challenge";
     CustomMoveType[CustomMoveType["ActivateCard"] = 7] = "ActivateCard";
+    CustomMoveType[CustomMoveType["ChooseSuit"] = 8] = "ChooseSuit";
+    CustomMoveType[CustomMoveType["ChooseCard"] = 9] = "ChooseCard";
 })(CustomMoveType || (CustomMoveType = {}));

package/dist/Deck.d.ts

@@ -2,5 +2,7 @@ export declare enum Deck {
     HearthBlade = 1,
     WindSands = 2,
     GraveHurt = 3,
+    BlackHive = 4,
+    MoonDragon = 5,
     HighWave = 6
 }

package/dist/Deck.js

@@ -3,5 +3,7 @@ export var Deck;
     Deck[Deck["HearthBlade"] = 1] = "HearthBlade";
     Deck[Deck["WindSands"] = 2] = "WindSands";
     Deck[Deck["GraveHurt"] = 3] = "GraveHurt";
+    Deck[Deck["BlackHive"] = 4] = "BlackHive";
+    Deck[Deck["MoonDragon"] = 5] = "MoonDragon";
     Deck[Deck["HighWave"] = 6] = "HighWave";
 })(Deck || (Deck = {}));

package/dist/Memory.d.ts

@@ -1,12 +1,13 @@
 export declare enum Memory {
     CrystalsToWin = 1,
-    CardsPlayed = 2,
-    Suit = 3,
-    PendingEffects = 4,
-    ActivatedCards = 5,
-    CurrentPlayer = 6,
-    NextRoundStartPlayer = 7,
-    EffectCount = 8,
-    ChallengeConceded = 9,
-    OngoingEffects = 10
+    CurrentPlayer = 2,
+    CardsPlayed = 3,
+    Suit = 4,
+    PendingEffects = 5,
+    OngoingEffects = 6,
+    ActivatedCards = 7,
+    ChallengeConceded = 8,
+    EffectCount = 9,
+    EffectTargets = 10,
+    NextRoundStartPlayer = 11
 }

package/dist/Memory.js

@@ -1,13 +1,14 @@
 export var Memory;
 (function (Memory) {
     Memory[Memory["CrystalsToWin"] = 1] = "CrystalsToWin";
-    Memory[Memory["CardsPlayed"] = 2] = "CardsPlayed";
-    Memory[Memory["Suit"] = 3] = "Suit";
-    Memory[Memory["PendingEffects"] = 4] = "PendingEffects";
-    Memory[Memory["ActivatedCards"] = 5] = "ActivatedCards";
-    Memory[Memory["CurrentPlayer"] = 6] = "CurrentPlayer";
-    Memory[Memory["NextRoundStartPlayer"] = 7] = "NextRoundStartPlayer";
-    Memory[Memory["EffectCount"] = 8] = "EffectCount";
-    Memory[Memory["ChallengeConceded"] = 9] = "ChallengeConceded";
-    Memory[Memory["OngoingEffects"] = 10] = "OngoingEffects";
+    Memory[Memory["CurrentPlayer"] = 2] = "CurrentPlayer";
+    Memory[Memory["CardsPlayed"] = 3] = "CardsPlayed";
+    Memory[Memory["Suit"] = 4] = "Suit";
+    Memory[Memory["PendingEffects"] = 5] = "PendingEffects";
+    Memory[Memory["OngoingEffects"] = 6] = "OngoingEffects";
+    Memory[Memory["ActivatedCards"] = 7] = "ActivatedCards";
+    Memory[Memory["ChallengeConceded"] = 8] = "ChallengeConceded";
+    Memory[Memory["EffectCount"] = 9] = "EffectCount";
+    Memory[Memory["EffectTargets"] = 10] = "EffectTargets";
+    Memory[Memory["NextRoundStartPlayer"] = 11] = "NextRoundStartPlayer";
 })(Memory || (Memory = {}));

package/dist/SkyriftRules.d.ts

@@ -2,11 +2,15 @@ import { CustomMove, ItemMove, MaterialGame, MaterialMove, MaterialMoveRandomize
 import { Deck } from './Deck';
 import { CavernSkulkerEffectRule } from './material/decks/gravehurt/CavernSkulkerEffectRule';
 import { DoomEffectRule } from './material/decks/gravehurt/DoomEffectRule';
-import { ArmadaEffectRule } from './material/decks/heathblade/ArmadaEffectRule';
 import { PrincessLithaEffectRule } from './material/decks/heathblade/PrincessLithaEffectRule';
 import { BoardingPartyEffectRule } from './material/decks/highwave/BoardingPartyEffectRule';
 import { EyeOfSkyEffectRule } from './material/decks/highwave/EyeOfSkyEffectRule';
-import { AbiSnakeCharmerEffectRule } from './material/decks/windsands/AbiSnakeCharmerEffectRule';
+import { CaveInEffectRule } from './material/decks/blackhive/CaveInEffectRule';
+import { CycleKeeperEffectRule } from './material/decks/blackhive/CycleKeeperEffectRule';
+import { CopyPlayEffectRule } from './material/decks/moondragon/CopyPlayEffectRule';
+import { EmpressSamaEffectRule } from './material/decks/moondragon/EmpressSamaEffectRule';
+import { LotusMuseEffectRule } from './material/decks/moondragon/LotusMuseEffectRule';
+import { AzureDragonsPeaceEffectRule } from './material/decks/moondragon/AzureDragonsPeaceEffectRule';
 import { WindWrathEffectRule } from './material/decks/windsands/WindWrathEffectRule';
 import { LocationType } from './material/LocationType';
 import { MaterialType } from './material/MaterialType';
@@ -27,7 +31,9 @@ import { StartPlayerTurnRule } from './rules/StartPlayerTurnRule';
 import { StartRoundRule } from './rules/StartRoundRule';
 import { StashPowerTokensEffectRule } from './rules/StashPowerTokensEffectRule';
 import { StealCrystalEffectRule } from './rules/StealCrystalEffectRule';
+import { MulliganEffectRule } from './rules/MulliganEffectRule';
 import { StunEffectRule } from './rules/StunEffectRule';
+import { SwitchSideEffectRule } from './rules/SwitchSideEffectRule';
 export declare class SkyriftRules extends SecretMaterialRules<Deck, MaterialType, LocationType> implements TimeLimit<MaterialGame<Deck, MaterialType, LocationType>, MaterialMove<Deck, MaterialType, LocationType>, Deck> {
     rules: {
         1: typeof StartRoundRule;
@@ -47,13 +53,19 @@ export declare class SkyriftRules extends SecretMaterialRules<Deck, MaterialType
         28: typeof StashPowerTokensEffectRule;
         29: typeof GainCrystalEffectRule;
         30: typeof StealCrystalEffectRule;
-        204: typeof AbiSnakeCharmerEffectRule;
         31: typeof PlayCardEffectRule;
-        110: typeof ArmadaEffectRule;
+        32: typeof MulliganEffectRule;
+        33: typeof SwitchSideEffectRule;
         103: typeof PrincessLithaEffectRule;
         215: typeof WindWrathEffectRule;
         302: typeof CavernSkulkerEffectRule;
         315: typeof DoomEffectRule;
+        409: typeof CycleKeeperEffectRule;
+        413: typeof CaveInEffectRule;
+        503: typeof CopyPlayEffectRule;
+        509: typeof EmpressSamaEffectRule;
+        510: typeof LotusMuseEffectRule;
+        513: typeof AzureDragonsPeaceEffectRule;
         603: typeof EyeOfSkyEffectRule;
         614: typeof BoardingPartyEffectRule;
     };
@@ -73,10 +85,10 @@ export declare class SkyriftRules extends SecretMaterialRules<Deck, MaterialType
             14: import("@gamepark/rules-api").HidingStrategy<number, number>;
         };
     };
-    play(move: MaterialMoveRandomized<Deck, MaterialType, LocationType> | MaterialMoveView<Deck, MaterialType, LocationType>, context?: PlayMoveContext): MaterialMove<Deck, MaterialType, LocationType, number>[];
-    protected beforeItemMove(move: ItemMove): MaterialMove<Deck, MaterialType, LocationType, number>[];
-    protected afterItemMove(move: ItemMove, context?: PlayMoveContext): MaterialMove<Deck, MaterialType, LocationType, number>[];
-    protected onCustomMove(move: CustomMove, context?: PlayMoveContext): MaterialMove<Deck, MaterialType, LocationType, number>[];
+    play(move: MaterialMoveRandomized<Deck, MaterialType, LocationType> | MaterialMoveView<Deck, MaterialType, LocationType>, context?: PlayMoveContext): MaterialMove<Deck, MaterialType, LocationType, number, number>[];
+    protected beforeItemMove(move: ItemMove): MaterialMove<Deck, MaterialType, LocationType, number, number>[];
+    protected afterItemMove(move: ItemMove, context?: PlayMoveContext): MaterialMove<Deck, MaterialType, LocationType, number, number>[];
+    protected onCustomMove(move: CustomMove, context?: PlayMoveContext): MaterialMove<Deck, MaterialType, LocationType, number, number>[];
     isUnpredictableMove(move: MaterialMove<Deck, MaterialType, LocationType>, player: Deck): boolean;
     giveTime(): number;
 }

package/dist/SkyriftRules.js

@@ -3,11 +3,15 @@ import { CustomMoveType } from './CustomMoveType';
 import { createCardRule } from './material/createCardRule';
 import { CavernSkulkerEffectRule } from './material/decks/gravehurt/CavernSkulkerEffectRule';
 import { DoomEffectRule } from './material/decks/gravehurt/DoomEffectRule';
-import { ArmadaEffectRule } from './material/decks/heathblade/ArmadaEffectRule';
 import { PrincessLithaEffectRule } from './material/decks/heathblade/PrincessLithaEffectRule';
 import { BoardingPartyEffectRule } from './material/decks/highwave/BoardingPartyEffectRule';
 import { EyeOfSkyEffectRule } from './material/decks/highwave/EyeOfSkyEffectRule';
-import { AbiSnakeCharmerEffectRule } from './material/decks/windsands/AbiSnakeCharmerEffectRule';
+import { CaveInEffectRule } from './material/decks/blackhive/CaveInEffectRule';
+import { CycleKeeperEffectRule } from './material/decks/blackhive/CycleKeeperEffectRule';
+import { CopyPlayEffectRule } from './material/decks/moondragon/CopyPlayEffectRule';
+import { EmpressSamaEffectRule } from './material/decks/moondragon/EmpressSamaEffectRule';
+import { LotusMuseEffectRule } from './material/decks/moondragon/LotusMuseEffectRule';
+import { AzureDragonsPeaceEffectRule } from './material/decks/moondragon/AzureDragonsPeaceEffectRule';
 import { WindWrathEffectRule } from './material/decks/windsands/WindWrathEffectRule';
 import { LocationType } from './material/LocationType';
 import { MaterialType } from './material/MaterialType';
@@ -30,7 +34,9 @@ import { StartPlayerTurnRule } from './rules/StartPlayerTurnRule';
 import { StartRoundRule } from './rules/StartRoundRule';
 import { StashPowerTokensEffectRule } from './rules/StashPowerTokensEffectRule';
 import { StealCrystalEffectRule } from './rules/StealCrystalEffectRule';
+import { MulliganEffectRule } from './rules/MulliganEffectRule';
 import { StunEffectRule } from './rules/StunEffectRule';
+import { SwitchSideEffectRule } from './rules/SwitchSideEffectRule';
 export class SkyriftRules extends SecretMaterialRules {
     rules = {
         [RuleId.StartRound]: StartRoundRule,
@@ -50,13 +56,19 @@ export class SkyriftRules extends SecretMaterialRules {
         [RuleId.StashPowerTokensEffect]: StashPowerTokensEffectRule,
         [RuleId.GainCrystalEffect]: GainCrystalEffectRule,
         [RuleId.StealCrystalEffect]: StealCrystalEffectRule,
-        [RuleId.AbiSnakeCharmerEffect]: AbiSnakeCharmerEffectRule,
         [RuleId.PlayCardEffect]: PlayCardEffectRule,
-        [RuleId.ArmadaEffect]: ArmadaEffectRule,
+        [RuleId.MulliganEffect]: MulliganEffectRule,
+        [RuleId.SwitchSideEffect]: SwitchSideEffectRule,
         [RuleId.PrincessLithaEffect]: PrincessLithaEffectRule,
         [RuleId.WindWrathEffect]: WindWrathEffectRule,
         [RuleId.CavernSkulkerEffect]: CavernSkulkerEffectRule,
         [RuleId.DoomEffect]: DoomEffectRule,
+        [RuleId.CycleKeeperEffect]: CycleKeeperEffectRule,
+        [RuleId.CaveInEffect]: CaveInEffectRule,
+        [RuleId.CopyPlayEffect]: CopyPlayEffectRule,
+        [RuleId.EmpressSamaEffect]: EmpressSamaEffectRule,
+        [RuleId.LotusMuseEffect]: LotusMuseEffectRule,
+        [RuleId.AzureDragonsPeaceEffect]: AzureDragonsPeaceEffectRule,
         [RuleId.EyeOfSkyEffect]: EyeOfSkyEffectRule,
         [RuleId.BoardingPartyEffect]: BoardingPartyEffectRule
     };

package/dist/SkyriftSetup.js

@@ -1,8 +1,10 @@
 import { listingToList, MaterialGameSetup } from '@gamepark/rules-api';
 import { shuffle } from 'es-toolkit';
 import { Deck } from './Deck';
+import { BlackHive } from './material/decks/BlackHive';
 import { GraveHurt } from './material/decks/GraveHurt';
 import { HearthBlade } from './material/decks/HearthBlade';
+import { MoonDragon } from './material/decks/MoonDragon';
 import { HighWave } from './material/decks/HighWave';
 import { WindSands } from './material/decks/WindSands';
 import { LocationType } from './material/LocationType';
@@ -14,6 +16,8 @@ const deckConfigurations = {
     [Deck.HearthBlade]: HearthBlade,
     [Deck.WindSands]: WindSands,
     [Deck.GraveHurt]: GraveHurt,
+    [Deck.BlackHive]: BlackHive,
+    [Deck.MoonDragon]: MoonDragon,
     [Deck.HighWave]: HighWave
 };
 export class SkyriftSetup extends MaterialGameSetup {

package/dist/material/Card.d.ts

@@ -48,6 +48,38 @@ export declare enum Card {
     WitchingHour = 314,
     Doom = 315,
     AstralHammer = 316,
+    UndergroundScourge = 401,
+    ShadowDealer = 402,
+    DariusAstraSmith = 403,
+    GuntarRustypike = 404,
+    DarkSwarm = 405,
+    HiveMother = 406,
+    GromIronspike = 407,
+    OlgaStonecrusher = 408,
+    CycleKeeper = 409,
+    LotharBlackclaw = 410,
+    ElevatorOfTheAbyss = 411,
+    CrystalMining = 412,
+    CaveIn = 413,
+    CrystalShaft = 414,
+    ExplosiveKitty = 415,
+    CarefulExcavation = 416,
+    GardenProtector = 501,
+    ImperialBlade = 502,
+    AkiraClearink = 503,
+    DartYusagi = 504,
+    SteppesColossus = 505,
+    ShardsAlchimist = 506,
+    SpiritOracle = 507,
+    YoruNightink = 508,
+    EmpressSama = 509,
+    LotusMuse = 510,
+    RoosterDance = 511,
+    RiteOfTastes = 512,
+    AzureDragonsPeace = 513,
+    Embush = 514,
+    DuelOfHonor = 515,
+    PortalOfTheAncestors = 516,
     SeaScorcher = 601,
     AeliaSteadyHand = 602,
     EyeOfSky = 603,

package/dist/material/Card.js

@@ -48,6 +48,38 @@ export var Card;
     Card[Card["WitchingHour"] = 314] = "WitchingHour";
     Card[Card["Doom"] = 315] = "Doom";
     Card[Card["AstralHammer"] = 316] = "AstralHammer";
+    Card[Card["UndergroundScourge"] = 401] = "UndergroundScourge";
+    Card[Card["ShadowDealer"] = 402] = "ShadowDealer";
+    Card[Card["DariusAstraSmith"] = 403] = "DariusAstraSmith";
+    Card[Card["GuntarRustypike"] = 404] = "GuntarRustypike";
+    Card[Card["DarkSwarm"] = 405] = "DarkSwarm";
+    Card[Card["HiveMother"] = 406] = "HiveMother";
+    Card[Card["GromIronspike"] = 407] = "GromIronspike";
+    Card[Card["OlgaStonecrusher"] = 408] = "OlgaStonecrusher";
+    Card[Card["CycleKeeper"] = 409] = "CycleKeeper";
+    Card[Card["LotharBlackclaw"] = 410] = "LotharBlackclaw";
+    Card[Card["ElevatorOfTheAbyss"] = 411] = "ElevatorOfTheAbyss";
+    Card[Card["CrystalMining"] = 412] = "CrystalMining";
+    Card[Card["CaveIn"] = 413] = "CaveIn";
+    Card[Card["CrystalShaft"] = 414] = "CrystalShaft";
+    Card[Card["ExplosiveKitty"] = 415] = "ExplosiveKitty";
+    Card[Card["CarefulExcavation"] = 416] = "CarefulExcavation";
+    Card[Card["GardenProtector"] = 501] = "GardenProtector";
+    Card[Card["ImperialBlade"] = 502] = "ImperialBlade";
+    Card[Card["AkiraClearink"] = 503] = "AkiraClearink";
+    Card[Card["DartYusagi"] = 504] = "DartYusagi";
+    Card[Card["SteppesColossus"] = 505] = "SteppesColossus";
+    Card[Card["ShardsAlchimist"] = 506] = "ShardsAlchimist";
+    Card[Card["SpiritOracle"] = 507] = "SpiritOracle";
+    Card[Card["YoruNightink"] = 508] = "YoruNightink";
+    Card[Card["EmpressSama"] = 509] = "EmpressSama";
+    Card[Card["LotusMuse"] = 510] = "LotusMuse";
+    Card[Card["RoosterDance"] = 511] = "RoosterDance";
+    Card[Card["RiteOfTastes"] = 512] = "RiteOfTastes";
+    Card[Card["AzureDragonsPeace"] = 513] = "AzureDragonsPeace";
+    Card[Card["Embush"] = 514] = "Embush";
+    Card[Card["DuelOfHonor"] = 515] = "DuelOfHonor";
+    Card[Card["PortalOfTheAncestors"] = 516] = "PortalOfTheAncestors";
     Card[Card["SeaScorcher"] = 601] = "SeaScorcher";
     Card[Card["AeliaSteadyHand"] = 602] = "AeliaSteadyHand";
     Card[Card["EyeOfSky"] = 603] = "EyeOfSky";

package/dist/material/CardProperties.js

@@ -63,6 +63,38 @@ import { Shadowbolt } from './decks/heathblade/Shadowbolt';
 import { SoulBlade } from './decks/heathblade/SoulBlade';
 import { WatchTower } from './decks/heathblade/WatchTower';
 import { WoodSlinger } from './decks/heathblade/WoodSlinger';
+import { GardenProtector } from './decks/moondragon/GardenProtector';
+import { ImperialBlade } from './decks/moondragon/ImperialBlade';
+import { AkiraClearink } from './decks/moondragon/AkiraClearink';
+import { DartYusagi } from './decks/moondragon/DartYusagi';
+import { SteppesColossus } from './decks/moondragon/SteppesColossus';
+import { ShardsAlchimist } from './decks/moondragon/ShardsAlchimist';
+import { SpiritOracle } from './decks/moondragon/SpiritOracle';
+import { YoruNightink } from './decks/moondragon/YoruNightink';
+import { EmpressSama } from './decks/moondragon/EmpressSama';
+import { LotusMuse } from './decks/moondragon/LotusMuse';
+import { RoosterDance } from './decks/moondragon/RoosterDance';
+import { RiteOfTastes } from './decks/moondragon/RiteOfTastes';
+import { AzureDragonsPeace } from './decks/moondragon/AzureDragonsPeace';
+import { Embush } from './decks/moondragon/Embush';
+import { DuelOfHonor } from './decks/moondragon/DuelOfHonor';
+import { PortalOfTheAncestors } from './decks/moondragon/PortalOfTheAncestors';
+import { UndergroundScourge } from './decks/blackhive/UndergroundScourge';
+import { ShadowDealer } from './decks/blackhive/ShadowDealer';
+import { DariusAstraSmith } from './decks/blackhive/DariusAstraSmith';
+import { GuntarRustypike } from './decks/blackhive/GuntarRustypike';
+import { DarkSwarm } from './decks/blackhive/DarkSwarm';
+import { HiveMother } from './decks/blackhive/HiveMother';
+import { GromIronspike } from './decks/blackhive/GromIronspike';
+import { OlgaStonecrusher } from './decks/blackhive/OlgaStonecrusher';
+import { CycleKeeper } from './decks/blackhive/CycleKeeper';
+import { LotharBlackclaw } from './decks/blackhive/LotharBlackclaw';
+import { ElevatorOfTheAbyss } from './decks/blackhive/ElevatorOfTheAbyss';
+import { CrystalMining } from './decks/blackhive/CrystalMining';
+import { CaveIn } from './decks/blackhive/CaveIn';
+import { CrystalShaft } from './decks/blackhive/CrystalShaft';
+import { ExplosiveKitty } from './decks/blackhive/ExplosiveKitty';
+import { CarefulExcavation } from './decks/blackhive/CarefulExcavation';
 export const cardProperties = {
     [Card.HedgeKnight]: HedgeKnight,
     [Card.LoyalSquire]: LoyalSquire,
@@ -112,6 +144,38 @@ export const cardProperties = {
     [Card.WitchingHour]: WitchingHour,
     [Card.Doom]: Doom,
     [Card.AstralHammer]: AstralHammer,
+    [Card.UndergroundScourge]: UndergroundScourge,
+    [Card.ShadowDealer]: ShadowDealer,
+    [Card.DariusAstraSmith]: DariusAstraSmith,
+    [Card.GuntarRustypike]: GuntarRustypike,
+    [Card.DarkSwarm]: DarkSwarm,
+    [Card.HiveMother]: HiveMother,
+    [Card.GromIronspike]: GromIronspike,
+    [Card.OlgaStonecrusher]: OlgaStonecrusher,
+    [Card.CycleKeeper]: CycleKeeper,
+    [Card.LotharBlackclaw]: LotharBlackclaw,
+    [Card.ElevatorOfTheAbyss]: ElevatorOfTheAbyss,
+    [Card.CrystalMining]: CrystalMining,
+    [Card.CaveIn]: CaveIn,
+    [Card.CrystalShaft]: CrystalShaft,
+    [Card.ExplosiveKitty]: ExplosiveKitty,
+    [Card.CarefulExcavation]: CarefulExcavation,
+    [Card.GardenProtector]: GardenProtector,
+    [Card.ImperialBlade]: ImperialBlade,
+    [Card.AkiraClearink]: AkiraClearink,
+    [Card.DartYusagi]: DartYusagi,
+    [Card.SteppesColossus]: SteppesColossus,
+    [Card.ShardsAlchimist]: ShardsAlchimist,
+    [Card.SpiritOracle]: SpiritOracle,
+    [Card.YoruNightink]: YoruNightink,
+    [Card.EmpressSama]: EmpressSama,
+    [Card.LotusMuse]: LotusMuse,
+    [Card.RoosterDance]: RoosterDance,
+    [Card.RiteOfTastes]: RiteOfTastes,
+    [Card.AzureDragonsPeace]: AzureDragonsPeace,
+    [Card.Embush]: Embush,
+    [Card.DuelOfHonor]: DuelOfHonor,
+    [Card.PortalOfTheAncestors]: PortalOfTheAncestors,
     [Card.SeaScorcher]: SeaScorcher,
     [Card.AeliaSteadyHand]: AeliaSteadyHand,
     [Card.EyeOfSky]: EyeOfSky,

package/dist/material/CardRule.d.ts

@@ -2,7 +2,7 @@ import { MaterialGame, MaterialMove, MaterialRulesPart } from '@gamepark/rules-a
 import { Deck } from '../Deck';
 import { Card, CardId } from './Card';
 import { Effect } from './Effect';
-import { OngoingEffectType } from './OngoingEffect';
+import { OngoingEffect, OngoingEffectType } from './OngoingEffect';
 export declare class CardRule extends MaterialRulesPart {
     index: number;
     constructor(game: MaterialGame, index: number);
@@ -14,7 +14,7 @@ export declare class CardRule extends MaterialRulesPart {
     onSkirmishEnd?(): void;
     onSkirmishWin?(): void;
     onSkirmishLost?(): void;
-    survivesSkirmish?(): boolean;
+    isNeutralized(): boolean;
     canActivate(): boolean;
     onLeaves(): MaterialMove[];
     removePowerTokens(): MaterialMove[];
@@ -23,18 +23,23 @@ export declare class CardRule extends MaterialRulesPart {
     get item(): import("@gamepark/rules-api").MaterialItem<number, number, CardId>;
     get card(): Card;
     get properties(): import("./CardProperties").CardProperties;
+    get powerTokens(): import("@gamepark/rules-api").Material<number, number, number>;
+    get stunTokens(): import("@gamepark/rules-api").Material<number, number, number>;
+    get specialTokens(): import("@gamepark/rules-api").Material<number, number, number>;
     get playArea(): import("@gamepark/rules-api").Material<number, number, number>;
     get creatures(): import("@gamepark/rules-api").Material<number, number, number>;
     isStunned(): boolean;
     getPower(): number;
     getPowerIfNotStunned(): number;
+    getPlayerPowerModifier(_player: Deck): number;
     addPendingEffect(ruleId: number): void;
-    addOngoingEffect(type: OngoingEffectType): void;
+    addOngoingEffect(type: OngoingEffectType, options?: Omit<OngoingEffect, 'type' | 'cardIndex'>): void;
     removeOngoingEffect(type: OngoingEffectType): void;
     get player(): number;
     get foe(): number;
     startEffect(effect: Effect): MaterialMove[];
-    getEffectPlayer(_effect: Effect): number;
+    isAutomaticEffect(effect: Effect): boolean;
+    getEffectPlayers(_effect: Effect): number[];
     canBePlayed(): boolean;
     canSuitBePlayed(): boolean;
     ongoingEffectPreventsPlayCard(): boolean;

package/dist/material/CardRule.js

@@ -1,5 +1,7 @@
 import { MaterialRulesPart } from '@gamepark/rules-api';
 import { Memory } from '../Memory';
+import { EffectsHelper } from '../rules/EffectsHelper';
+import { RuleId } from '../rules/RuleId';
 import { cardProperties } from './CardProperties';
 import { CardSuit } from './CardSuit';
 import { CardType } from './CardType';
@@ -13,11 +15,16 @@ export class CardRule extends MaterialRulesPart {
         super(game);
         this.index = index;
     }
+    isNeutralized() {
+        return this.remind(Memory.OngoingEffects).some((e) => e.type === OngoingEffectType.Neutralized && e.targets?.includes(this.index));
+    }
     canActivate() {
         if (!this.activate)
             return false;
         if (this.isStunned())
             return false;
+        if (this.isNeutralized())
+            return false;
         const activatedCards = this.remind(Memory.ActivatedCards);
         return !activatedCards.includes(this.index);
     }
@@ -25,16 +32,13 @@ export class CardRule extends MaterialRulesPart {
         return [...this.removePowerTokens(), ...this.removeStunTokens(), ...this.removeSpecialTokens()];
     }
     removePowerTokens() {
-        const tokens = this.material(MaterialType.PowerToken).location(LocationType.CardPowerTokens).parent(this.index);
-        return tokens.getQuantity() > 0 ? [tokens.deleteItem(tokens.getQuantity())] : [];
+        return this.powerTokens.getQuantity() > 0 ? [this.powerTokens.deleteItem(this.powerTokens.getQuantity())] : [];
     }
     removeStunTokens() {
-        const tokens = this.material(MaterialType.StunToken).location(LocationType.CardStunTokens).parent(this.index);
-        return tokens.getQuantity() > 0 ? [tokens.deleteItem(tokens.getQuantity())] : [];
+        return this.stunTokens.getQuantity() > 0 ? [this.stunTokens.deleteItem(this.stunTokens.getQuantity())] : [];
     }
     removeSpecialTokens() {
-        const tokens = this.material(MaterialType.SpecialToken).location(LocationType.CardSpecialTokens).parent(this.index);
-        return tokens.getQuantity() > 0 ? [tokens.deleteItem(tokens.getQuantity())] : [];
+        return this.specialTokens.getQuantity() > 0 ? [this.specialTokens.deleteItem(this.specialTokens.getQuantity())] : [];
     }
     get item() {
         return this.material(MaterialType.Card).getItem(this.index);
@@ -45,6 +49,15 @@ export class CardRule extends MaterialRulesPart {
     get properties() {
         return cardProperties[this.card];
     }
+    get powerTokens() {
+        return this.material(MaterialType.PowerToken).location(LocationType.CardPowerTokens).parent(this.index);
+    }
+    get stunTokens() {
+        return this.material(MaterialType.StunToken).location(LocationType.CardStunTokens).parent(this.index);
+    }
+    get specialTokens() {
+        return this.material(MaterialType.SpecialToken).location(LocationType.CardSpecialTokens).parent(this.index);
+    }
     get playArea() {
         return this.material(MaterialType.Card).location(LocationType.PlayArea);
     }
@@ -52,10 +65,10 @@ export class CardRule extends MaterialRulesPart {
         return this.playArea.id((id) => cardProperties[id.front].type === CardType.Creature);
     }
     isStunned() {
-        return this.material(MaterialType.StunToken).location(LocationType.CardStunTokens).parent(this.index).getQuantity() > 0;
+        return this.stunTokens.getQuantity() > 0;
     }
     getPower() {
-        if (this.isStunned()) {
+        if (this.isStunned() || this.isNeutralized()) {
             return 0;
         }
         else {
@@ -64,14 +77,21 @@ export class CardRule extends MaterialRulesPart {
     }
     getPowerIfNotStunned() {
         const basePower = this.properties.power;
-        const powerTokensCount = this.material(MaterialType.PowerToken).location(LocationType.CardPowerTokens).parent(this.index).getQuantity();
-        return basePower + powerTokensCount;
+        const powerModifier = this.remind(Memory.OngoingEffects)
+            .filter((e) => e.type === OngoingEffectType.PowerModifier && e.cardIndex === this.index)
+            .reduce((sum, e) => sum + (e.value ?? 0), 0);
+        return basePower + this.powerTokens.getQuantity() + powerModifier;
+    }
+    getPlayerPowerModifier(_player) {
+        return 0;
     }
     addPendingEffect(ruleId) {
+        if (this.isNeutralized())
+            return;
         this.memorize(Memory.PendingEffects, (effects) => [...effects, { cardIndex: this.index, ruleId }]);
     }
-    addOngoingEffect(type) {
-        this.memorize(Memory.OngoingEffects, (effects) => [...effects, { type, cardIndex: this.index }]);
+    addOngoingEffect(type, options) {
+        this.memorize(Memory.OngoingEffects, (effects) => [...effects, { type, cardIndex: this.index, ...options }]);
     }
     removeOngoingEffect(type) {
         this.memorize(Memory.OngoingEffects, (effects) => effects.filter((e) => !(e.type === type && e.cardIndex === this.index)));
@@ -83,10 +103,40 @@ export class CardRule extends MaterialRulesPart {
         return this.game.players.find((p) => p !== this.player);
     }
     startEffect(effect) {
-        return [this.startPlayerTurn(effect.ruleId, this.getEffectPlayer(effect))];
+        if (this.isAutomaticEffect(effect)) {
+            return [this.startRule(effect.ruleId)];
+        }
+        const players = this.getEffectPlayers(effect);
+        if (players.length > 1) {
+            return [this.startSimultaneousRule(effect.ruleId, players)];
+        }
+        return [this.startPlayerTurn(effect.ruleId, players[0])];
+    }
+    isAutomaticEffect(effect) {
+        switch (effect.ruleId) {
+            case RuleId.DrawEffect:
+            case RuleId.GainCrystalEffect:
+            case RuleId.StashPowerTokensEffect:
+            case RuleId.StealCrystalEffect:
+            case RuleId.WindWrathEffect:
+            case RuleId.CavernSkulkerEffect:
+                return true;
+            case RuleId.StunEffect:
+                return !!this.isAutoStun?.();
+            case RuleId.DestroyEffect:
+                return !!this.isAutoDestroy?.();
+            case RuleId.DiscardEffect:
+                return !!this.isAutoDiscard?.();
+            case RuleId.ReturnCardEffect:
+                return !!this.isAutoReturn?.();
+            case RuleId.PutPowerTokensEffect:
+                return !!this.isAutoPutPowerToken?.();
+            default:
+                return false;
+        }
     }
-    getEffectPlayer(_effect) {
-        return this.player;
+    getEffectPlayers(_effect) {
+        return [this.player];
     }
     canBePlayed() {
         return this.canSuitBePlayed() && !this.ongoingEffectPreventsPlayCard();
@@ -97,13 +147,11 @@ export class CardRule extends MaterialRulesPart {
         return !currentSuit || cardSuit === CardSuit.Twilight || cardSuit === currentSuit;
     }
     ongoingEffectPreventsPlayCard() {
-        const ongoingEffects = this.remind(Memory.OngoingEffects);
-        for (const effect of ongoingEffects) {
-            if (effect.type === OngoingEffectType.PreventPlayCard) {
-                const sourceCardRule = createCardRule(this.game, effect.cardIndex);
-                if (sourceCardRule.preventPlayCard(this.card, this.player)) {
-                    return true;
-                }
+        const effectsHelper = new EffectsHelper(this.game);
+        for (const effect of effectsHelper.getActiveOngoingEffects(OngoingEffectType.PlayCardCondition)) {
+            const sourceCardRule = createCardRule(this.game, effect.cardIndex);
+            if (!sourceCardRule.canPlayCard(this.card, this.player)) {
+                return true;
             }
         }
         return false;

package/dist/material/Effect.d.ts

@@ -1,4 +1,6 @@
+import { Card } from './Card';
 export type Effect = {
     cardIndex: number;
     ruleId: number;
+    sourceCard?: Card;
 };

package/dist/material/EffectTraits.d.ts

@@ -32,6 +32,7 @@ export interface StashPowerTokenEffect {
 export interface PlayCardEffect {
     getPlayCardTargets?(): Material;
     isPlayCardOptional?(): boolean;
+    ignorePlayCardConditions?(): boolean;
 }
 export interface ChallengeEffect {
     onChallengeAccepted?(): void;
@@ -43,8 +44,12 @@ export interface StunEffect {
     getStunTargetsCount?(): number;
     isAutoStun?(): boolean;
 }
-export interface PreventPlayCardEffect {
-    preventPlayCard(card: Card, player: Deck): boolean;
+export interface PlayCardConditionEffect {
+    canPlayCard(card: Card, player: Deck): boolean;
+    onPlayCardCondition?(card: Card, player: Deck): void;
+}
+export interface SwitchSideEffect {
+    getSwitchSideTargets?(): Material;
 }
 export interface PreventEffectsEffect {
     preventEnterEffects(cardIndex: number): boolean;

package/dist/material/OngoingEffect.d.ts

@@ -1,8 +1,17 @@
 export declare enum OngoingEffectType {
-    PreventPlayCard = 1,
-    PreventEffects = 2
+    PlayCardCondition = 1,
+    PreventEffects = 2,
+    LockSuit = 3,
+    PassTurn = 4,
+    SurvivesSkirmish = 5,
+    KeepActionCard = 6,
+    Neutralized = 7,
+    PowerModifier = 8
 }
 export type OngoingEffect = {
     type: OngoingEffectType;
     cardIndex: number;
+    targets?: number[];
+    value?: number;
+    turnsLeft?: number;
 };