@gamepark/skyrift 0.5.0 → 0.6.1

package/dist/CustomMoveType.d.ts

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

package/dist/CustomMoveType.js

@@ -8,4 +8,5 @@ export var CustomMoveType;
     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

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

package/dist/Deck.js

@@ -4,5 +4,6 @@ export var Deck;
     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/SkyriftRules.d.ts

@@ -7,7 +7,10 @@ import { BoardingPartyEffectRule } from './material/decks/highwave/BoardingParty
 import { EyeOfSkyEffectRule } from './material/decks/highwave/EyeOfSkyEffectRule';
 import { CaveInEffectRule } from './material/decks/blackhive/CaveInEffectRule';
 import { CycleKeeperEffectRule } from './material/decks/blackhive/CycleKeeperEffectRule';
-import { AbiSnakeCharmerEffectRule } from './material/decks/windsands/AbiSnakeCharmerEffectRule';
+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,6 +33,7 @@ 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;
@@ -49,15 +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;
         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;
     };
@@ -77,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

@@ -8,7 +8,10 @@ import { BoardingPartyEffectRule } from './material/decks/highwave/BoardingParty
 import { EyeOfSkyEffectRule } from './material/decks/highwave/EyeOfSkyEffectRule';
 import { CaveInEffectRule } from './material/decks/blackhive/CaveInEffectRule';
 import { CycleKeeperEffectRule } from './material/decks/blackhive/CycleKeeperEffectRule';
-import { AbiSnakeCharmerEffectRule } from './material/decks/windsands/AbiSnakeCharmerEffectRule';
+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';
@@ -33,6 +36,7 @@ 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,
@@ -52,15 +56,19 @@ export class SkyriftRules extends SecretMaterialRules {
         [RuleId.StashPowerTokensEffect]: StashPowerTokensEffectRule,
         [RuleId.GainCrystalEffect]: GainCrystalEffectRule,
         [RuleId.StealCrystalEffect]: StealCrystalEffectRule,
-        [RuleId.AbiSnakeCharmerEffect]: AbiSnakeCharmerEffectRule,
         [RuleId.PlayCardEffect]: PlayCardEffectRule,
         [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

@@ -4,6 +4,7 @@ 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';
@@ -16,6 +17,7 @@ const deckConfigurations = {
     [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

@@ -64,6 +64,22 @@ export declare enum Card {
     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

@@ -64,6 +64,22 @@ export var Card;
     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,22 @@ 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';
@@ -144,6 +160,22 @@ export const cardProperties = {
     [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,22 @@ 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;
-    getFoePowerModifier(): 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[];
+    isAutomaticEffect(effect: Effect): boolean;
     getEffectPlayers(_effect: Effect): number[];
     canBePlayed(): boolean;
     canSuitBePlayed(): 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,17 +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;
     }
-    getFoePowerModifier() {
+    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)));
@@ -86,12 +103,38 @@ export class CardRule extends MaterialRulesPart {
         return this.game.players.find((p) => p !== this.player);
     }
     startEffect(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;
+        }
+    }
     getEffectPlayers(_effect) {
         return [this.player];
     }
@@ -104,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,10 +1,17 @@
 export declare enum OngoingEffectType {
-    PreventPlayCard = 1,
+    PlayCardCondition = 1,
     PreventEffects = 2,
     LockSuit = 3,
-    PassTurn = 4
+    PassTurn = 4,
+    SurvivesSkirmish = 5,
+    KeepActionCard = 6,
+    Neutralized = 7,
+    PowerModifier = 8
 }
 export type OngoingEffect = {
     type: OngoingEffectType;
     cardIndex: number;
+    targets?: number[];
+    value?: number;
+    turnsLeft?: number;
 };

package/dist/material/OngoingEffect.js

@@ -1,7 +1,11 @@
 export var OngoingEffectType;
 (function (OngoingEffectType) {
-    OngoingEffectType[OngoingEffectType["PreventPlayCard"] = 1] = "PreventPlayCard";
+    OngoingEffectType[OngoingEffectType["PlayCardCondition"] = 1] = "PlayCardCondition";
     OngoingEffectType[OngoingEffectType["PreventEffects"] = 2] = "PreventEffects";
     OngoingEffectType[OngoingEffectType["LockSuit"] = 3] = "LockSuit";
     OngoingEffectType[OngoingEffectType["PassTurn"] = 4] = "PassTurn";
+    OngoingEffectType[OngoingEffectType["SurvivesSkirmish"] = 5] = "SurvivesSkirmish";
+    OngoingEffectType[OngoingEffectType["KeepActionCard"] = 6] = "KeepActionCard";
+    OngoingEffectType[OngoingEffectType["Neutralized"] = 7] = "Neutralized";
+    OngoingEffectType[OngoingEffectType["PowerModifier"] = 8] = "PowerModifier";
 })(OngoingEffectType || (OngoingEffectType = {}));

package/dist/material/decks/MoonDragon.d.ts

@@ -0,0 +1,18 @@
+export declare const MoonDragon: {
+    501: number;
+    502: number;
+    503: number;
+    504: number;
+    505: number;
+    506: number;
+    507: number;
+    508: number;
+    509: number;
+    510: number;
+    511: number;
+    512: number;
+    513: number;
+    514: number;
+    515: number;
+    516: number;
+};

package/dist/material/decks/MoonDragon.js

@@ -0,0 +1,19 @@
+import { Card } from '../Card';
+export const MoonDragon = {
+    [Card.GardenProtector]: 2,
+    [Card.ImperialBlade]: 2,
+    [Card.AkiraClearink]: 1,
+    [Card.DartYusagi]: 1,
+    [Card.SteppesColossus]: 2,
+    [Card.ShardsAlchimist]: 2,
+    [Card.SpiritOracle]: 2,
+    [Card.YoruNightink]: 1,
+    [Card.EmpressSama]: 1,
+    [Card.LotusMuse]: 1,
+    [Card.RoosterDance]: 2,
+    [Card.RiteOfTastes]: 1,
+    [Card.AzureDragonsPeace]: 1,
+    [Card.Embush]: 1,
+    [Card.DuelOfHonor]: 2,
+    [Card.PortalOfTheAncestors]: 2
+};

package/dist/material/decks/blackhive/CarefulExcavation.d.ts

@@ -1,4 +1,5 @@
 import { Material } from '@gamepark/rules-api';
+import { Deck } from '../../../Deck';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
@@ -6,7 +7,7 @@ import { DestroyEffect, DrawEffect } from '../../EffectTraits';
 declare class CarefulExcavationRule extends CardRule implements DrawEffect, DestroyEffect {
     onEnters(): void;
     getDrawCount(): number;
-    getFoePowerModifier(): number;
+    getPlayerPowerModifier(player: Deck): 4 | 0;
     onFoeTurnStart(): void;
     getDestroyTargets(): Material;
     isAutoDestroy(): boolean;

package/dist/material/decks/blackhive/CarefulExcavation.js

@@ -10,8 +10,8 @@ class CarefulExcavationRule extends CardRule {
     getDrawCount() {
         return 2;
     }
-    getFoePowerModifier() {
-        return 4;
+    getPlayerPowerModifier(player) {
+        return player === this.foe ? 4 : 0;
     }
     onFoeTurnStart() {
         this.addPendingEffect(RuleId.DestroyEffect);

package/dist/material/decks/blackhive/CycleKeeperEffectRule.d.ts

@@ -1,6 +1,8 @@
 import { CustomMove } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../../CustomMoveType';
+import { CardSuit } from '../../CardSuit';
 import { EffectRule } from '../../../rules/EffectRule';
 export declare class CycleKeeperEffectRule extends EffectRule {
-    getPlayerMoves(): CustomMove[];
+    getPlayerMoves(): CustomMove<CustomMoveType.ChooseSuit, CardSuit>[];
     onCustomMove(move: CustomMove): import("@gamepark/rules-api").MaterialMove[];
 }

package/dist/material/decks/gravehurt/CavernSkulkerEffectRule.js

@@ -5,7 +5,7 @@ import { MaterialType } from '../../MaterialType';
 export class CavernSkulkerEffectRule extends EffectRule {
     onRuleStart() {
         const moves = this.endEffect();
-        const foeHand = this.material(MaterialType.Card).location(LocationType.PlayerHand).player(this.nextPlayer);
+        const foeHand = this.material(MaterialType.Card).location(LocationType.PlayerHand).player(this.cardRule.foe);
         if (foeHand.length > 0) {
             const randomIndex = sample(foeHand.getIndexes());
             moves.unshift(foeHand.index(randomIndex).moveItem({ type: LocationType.UnderCard, parent: this.effectCardIndex }));

package/dist/material/decks/gravehurt/Umbraboros.d.ts

@@ -7,10 +7,10 @@ import { CardType } from '../../CardType';
 import { DestroyEffect } from '../../EffectTraits';
 import { UndeadRule } from './UndeadRule';
 declare class UmbraborosRule extends UndeadRule implements DestroyEffect {
+    onEnters(): void;
     onCardEnters(card: Card, side: Deck): void;
     getDestroyTargets(): Material;
     isAutoDestroy(): boolean;
-    survivesSkirmish(): boolean;
 }
 export declare const Umbraboros: {
     power: number;

package/dist/material/decks/gravehurt/Umbraboros.js

@@ -4,8 +4,12 @@ import { CardSuit } from '../../CardSuit';
 import { CardTag } from '../../CardTag';
 import { CardType } from '../../CardType';
 import { MaterialType } from '../../MaterialType';
+import { OngoingEffectType } from '../../OngoingEffect';
 import { UndeadRule } from './UndeadRule';
 class UmbraborosRule extends UndeadRule {
+    onEnters() {
+        this.addOngoingEffect(OngoingEffectType.SurvivesSkirmish);
+    }
     onCardEnters(card, side) {
         if (side === this.player && cardProperties[card].suit === CardSuit.Day) {
             this.addPendingEffect(RuleId.DestroyEffect);
@@ -17,9 +21,6 @@ class UmbraborosRule extends UndeadRule {
     isAutoDestroy() {
         return true;
     }
-    survivesSkirmish() {
-        return true;
-    }
 }
 export const Umbraboros = {
     power: 3,

package/dist/material/decks/gravehurt/WitchingHour.d.ts

@@ -2,10 +2,10 @@ import { Card } from '../../Card';
 import { CardRule } from '../../CardRule';
 import { CardSuit } from '../../CardSuit';
 import { CardType } from '../../CardType';
-import { PreventPlayCardEffect } from '../../EffectTraits';
-declare class WitchingHourRule extends CardRule implements PreventPlayCardEffect {
+import { PlayCardConditionEffect } from '../../EffectTraits';
+declare class WitchingHourRule extends CardRule implements PlayCardConditionEffect {
     onEnters(): void;
-    preventPlayCard(card: Card): boolean;
+    canPlayCard(card: Card): boolean;
 }
 export declare const WitchingHour: {
     power: number;