@gamepark/skyrift 0.4.3 → 0.5.0

package/dist/CustomMoveType.d.ts

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

package/dist/CustomMoveType.js

@@ -7,4 +7,5 @@ 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 = {}));

package/dist/Deck.d.ts

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

package/dist/Deck.js

@@ -3,5 +3,6 @@ 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["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,10 +2,11 @@ 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 { CaveInEffectRule } from './material/decks/blackhive/CaveInEffectRule';
+import { CycleKeeperEffectRule } from './material/decks/blackhive/CycleKeeperEffectRule';
 import { AbiSnakeCharmerEffectRule } from './material/decks/windsands/AbiSnakeCharmerEffectRule';
 import { WindWrathEffectRule } from './material/decks/windsands/WindWrathEffectRule';
 import { LocationType } from './material/LocationType';
@@ -27,6 +28,7 @@ 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';
 export declare class SkyriftRules extends SecretMaterialRules<Deck, MaterialType, LocationType> implements TimeLimit<MaterialGame<Deck, MaterialType, LocationType>, MaterialMove<Deck, MaterialType, LocationType>, Deck> {
     rules: {
@@ -49,11 +51,13 @@ export declare class SkyriftRules extends SecretMaterialRules<Deck, MaterialType
         30: typeof StealCrystalEffectRule;
         204: typeof AbiSnakeCharmerEffectRule;
         31: typeof PlayCardEffectRule;
-        110: typeof ArmadaEffectRule;
+        32: typeof MulliganEffectRule;
         103: typeof PrincessLithaEffectRule;
         215: typeof WindWrathEffectRule;
         302: typeof CavernSkulkerEffectRule;
         315: typeof DoomEffectRule;
+        409: typeof CycleKeeperEffectRule;
+        413: typeof CaveInEffectRule;
         603: typeof EyeOfSkyEffectRule;
         614: typeof BoardingPartyEffectRule;
     };

package/dist/SkyriftRules.js

@@ -3,10 +3,11 @@ 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 { CaveInEffectRule } from './material/decks/blackhive/CaveInEffectRule';
+import { CycleKeeperEffectRule } from './material/decks/blackhive/CycleKeeperEffectRule';
 import { AbiSnakeCharmerEffectRule } from './material/decks/windsands/AbiSnakeCharmerEffectRule';
 import { WindWrathEffectRule } from './material/decks/windsands/WindWrathEffectRule';
 import { LocationType } from './material/LocationType';
@@ -30,6 +31,7 @@ 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';
 export class SkyriftRules extends SecretMaterialRules {
     rules = {
@@ -52,11 +54,13 @@ export class SkyriftRules extends SecretMaterialRules {
         [RuleId.StealCrystalEffect]: StealCrystalEffectRule,
         [RuleId.AbiSnakeCharmerEffect]: AbiSnakeCharmerEffectRule,
         [RuleId.PlayCardEffect]: PlayCardEffectRule,
-        [RuleId.ArmadaEffect]: ArmadaEffectRule,
+        [RuleId.MulliganEffect]: MulliganEffectRule,
         [RuleId.PrincessLithaEffect]: PrincessLithaEffectRule,
         [RuleId.WindWrathEffect]: WindWrathEffectRule,
         [RuleId.CavernSkulkerEffect]: CavernSkulkerEffectRule,
         [RuleId.DoomEffect]: DoomEffectRule,
+        [RuleId.CycleKeeperEffect]: CycleKeeperEffectRule,
+        [RuleId.CaveInEffect]: CaveInEffectRule,
         [RuleId.EyeOfSkyEffect]: EyeOfSkyEffectRule,
         [RuleId.BoardingPartyEffect]: BoardingPartyEffectRule
     };

package/dist/SkyriftSetup.js

@@ -1,6 +1,7 @@
 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 { HighWave } from './material/decks/HighWave';
@@ -14,6 +15,7 @@ const deckConfigurations = {
     [Deck.HearthBlade]: HearthBlade,
     [Deck.WindSands]: WindSands,
     [Deck.GraveHurt]: GraveHurt,
+    [Deck.BlackHive]: BlackHive,
     [Deck.HighWave]: HighWave
 };
 export class SkyriftSetup extends MaterialGameSetup {

package/dist/material/Card.d.ts

@@ -48,6 +48,22 @@ 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,
     SeaScorcher = 601,
     AeliaSteadyHand = 602,
     EyeOfSky = 603,

package/dist/material/Card.js

@@ -48,6 +48,22 @@ 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["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 { 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 +128,22 @@ 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.SeaScorcher]: SeaScorcher,
     [Card.AeliaSteadyHand]: AeliaSteadyHand,
     [Card.EyeOfSky]: EyeOfSky,

package/dist/material/CardRule.d.ts

@@ -28,13 +28,14 @@ export declare class CardRule extends MaterialRulesPart {
     isStunned(): boolean;
     getPower(): number;
     getPowerIfNotStunned(): number;
+    getFoePowerModifier(): number;
     addPendingEffect(ruleId: number): void;
     addOngoingEffect(type: OngoingEffectType): void;
     removeOngoingEffect(type: OngoingEffectType): void;
     get player(): number;
     get foe(): number;
     startEffect(effect: Effect): MaterialMove[];
-    getEffectPlayer(_effect: Effect): number;
+    getEffectPlayers(_effect: Effect): number[];
     canBePlayed(): boolean;
     canSuitBePlayed(): boolean;
     ongoingEffectPreventsPlayCard(): boolean;

package/dist/material/CardRule.js

@@ -67,6 +67,9 @@ export class CardRule extends MaterialRulesPart {
         const powerTokensCount = this.material(MaterialType.PowerToken).location(LocationType.CardPowerTokens).parent(this.index).getQuantity();
         return basePower + powerTokensCount;
     }
+    getFoePowerModifier() {
+        return 0;
+    }
     addPendingEffect(ruleId) {
         this.memorize(Memory.PendingEffects, (effects) => [...effects, { cardIndex: this.index, ruleId }]);
     }
@@ -83,10 +86,14 @@ export class CardRule extends MaterialRulesPart {
         return this.game.players.find((p) => p !== this.player);
     }
     startEffect(effect) {
-        return [this.startPlayerTurn(effect.ruleId, this.getEffectPlayer(effect))];
+        const players = this.getEffectPlayers(effect);
+        if (players.length > 1) {
+            return [this.startSimultaneousRule(effect.ruleId, players)];
+        }
+        return [this.startPlayerTurn(effect.ruleId, players[0])];
     }
-    getEffectPlayer(_effect) {
-        return this.player;
+    getEffectPlayers(_effect) {
+        return [this.player];
     }
     canBePlayed() {
         return this.canSuitBePlayed() && !this.ongoingEffectPreventsPlayCard();

package/dist/material/OngoingEffect.d.ts

@@ -1,6 +1,8 @@
 export declare enum OngoingEffectType {
     PreventPlayCard = 1,
-    PreventEffects = 2
+    PreventEffects = 2,
+    LockSuit = 3,
+    PassTurn = 4
 }
 export type OngoingEffect = {
     type: OngoingEffectType;

package/dist/material/OngoingEffect.js

@@ -2,4 +2,6 @@ export var OngoingEffectType;
 (function (OngoingEffectType) {
     OngoingEffectType[OngoingEffectType["PreventPlayCard"] = 1] = "PreventPlayCard";
     OngoingEffectType[OngoingEffectType["PreventEffects"] = 2] = "PreventEffects";
+    OngoingEffectType[OngoingEffectType["LockSuit"] = 3] = "LockSuit";
+    OngoingEffectType[OngoingEffectType["PassTurn"] = 4] = "PassTurn";
 })(OngoingEffectType || (OngoingEffectType = {}));

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

@@ -0,0 +1,18 @@
+export declare const BlackHive: {
+    401: number;
+    402: number;
+    403: number;
+    404: number;
+    405: number;
+    406: number;
+    407: number;
+    408: number;
+    409: number;
+    410: number;
+    411: number;
+    412: number;
+    413: number;
+    414: number;
+    415: number;
+    416: number;
+};

package/dist/material/decks/BlackHive.js

@@ -0,0 +1,19 @@
+import { Card } from '../Card';
+export const BlackHive = {
+    [Card.UndergroundScourge]: 2,
+    [Card.ShadowDealer]: 2,
+    [Card.DariusAstraSmith]: 1,
+    [Card.GuntarRustypike]: 1,
+    [Card.DarkSwarm]: 2,
+    [Card.HiveMother]: 2,
+    [Card.GromIronspike]: 1,
+    [Card.OlgaStonecrusher]: 1,
+    [Card.CycleKeeper]: 2,
+    [Card.LotharBlackclaw]: 1,
+    [Card.ElevatorOfTheAbyss]: 2,
+    [Card.CrystalMining]: 1,
+    [Card.CaveIn]: 2,
+    [Card.CrystalShaft]: 1,
+    [Card.ExplosiveKitty]: 2,
+    [Card.CarefulExcavation]: 1
+};

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

@@ -0,0 +1,20 @@
+import { Material } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { DestroyEffect, DrawEffect } from '../../EffectTraits';
+declare class CarefulExcavationRule extends CardRule implements DrawEffect, DestroyEffect {
+    onEnters(): void;
+    getDrawCount(): number;
+    getFoePowerModifier(): number;
+    onFoeTurnStart(): void;
+    getDestroyTargets(): Material;
+    isAutoDestroy(): boolean;
+}
+export declare const CarefulExcavation: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof CarefulExcavationRule;
+};
+export {};

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

@@ -0,0 +1,31 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { MaterialType } from '../../MaterialType';
+class CarefulExcavationRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
+    getDrawCount() {
+        return 2;
+    }
+    getFoePowerModifier() {
+        return 4;
+    }
+    onFoeTurnStart() {
+        this.addPendingEffect(RuleId.DestroyEffect);
+    }
+    getDestroyTargets() {
+        return this.material(MaterialType.Card).index(this.index);
+    }
+    isAutoDestroy() {
+        return true;
+    }
+}
+export const CarefulExcavation = {
+    power: 0,
+    type: CardType.Action,
+    suit: CardSuit.Twilight,
+    rule: CarefulExcavationRule
+};

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

@@ -0,0 +1,14 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class CaveInRule extends CardRule {
+    onEnters(): void;
+    getEffectPlayers(): number[];
+}
+export declare const CaveIn: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof CaveInRule;
+};
+export {};

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

@@ -0,0 +1,18 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { RuleId } from '../../../rules/RuleId';
+class CaveInRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.CaveInEffect);
+    }
+    getEffectPlayers() {
+        return [this.player, this.foe];
+    }
+}
+export const CaveIn = {
+    power: 1,
+    type: CardType.Action,
+    suit: CardSuit.Night,
+    rule: CaveInRule
+};

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

@@ -0,0 +1,10 @@
+import { ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { Deck } from '../../../Deck';
+import { SimultaneousEffectRule } from '../../../rules/SimultaneousEffectRule';
+export declare class CaveInEffectRule extends SimultaneousEffectRule {
+    onRuleStart(): MaterialMove[];
+    getTargets(player: Deck): import("@gamepark/rules-api").Material<number, number, number>;
+    getActivePlayerLegalMoves(player: Deck): MaterialMove[];
+    beforeItemMove(move: ItemMove): import("@gamepark/rules-api").EndPlayerTurn<Deck>[];
+    getMovesAfterPlayersDone(): MaterialMove[];
+}

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

@@ -0,0 +1,55 @@
+import { isMoveItemType } from '@gamepark/rules-api';
+import { Memory } from '../../../Memory';
+import { SimultaneousEffectRule } from '../../../rules/SimultaneousEffectRule';
+import { cardProperties } from '../../CardProperties';
+import { CardType } from '../../CardType';
+import { createCardRule } from '../../createCardRule';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+export class CaveInEffectRule extends SimultaneousEffectRule {
+    onRuleStart() {
+        const moves = [];
+        for (const player of this.game.players) {
+            const targets = this.material(MaterialType.Card)
+                .location(LocationType.PlayArea)
+                .player(player)
+                .id((id) => cardProperties[id.front].type === CardType.Creature)
+                .index((index) => createCardRule(this.game, index).getPower() <= 3)
+                .getIndexes();
+            if (!targets.length) {
+                moves.push(this.endPlayerTurn(player));
+            }
+            else {
+                this.memorize(Memory.EffectTargets, targets, player);
+                this.memorize(Memory.EffectCount, Math.min(2, targets.length), player);
+            }
+        }
+        return moves;
+    }
+    getTargets(player) {
+        const indexes = this.remind(Memory.EffectTargets, player);
+        return this.material(MaterialType.Card).index((index) => indexes.includes(index));
+    }
+    getActivePlayerLegalMoves(player) {
+        return this.getTargets(player).moveItems((item) => ({
+            type: LocationType.PlayerDiscard,
+            player: item.id.back
+        }));
+    }
+    beforeItemMove(move) {
+        if (isMoveItemType(MaterialType.Card)(move) && move.location.type === LocationType.PlayerDiscard) {
+            const player = this.material(MaterialType.Card).getItem(move.itemIndex).location.player;
+            this.memorize(Memory.EffectTargets, (targets) => targets.filter((i) => i !== move.itemIndex), player);
+            const remaining = this.memorize(Memory.EffectCount, (c) => c - 1, player);
+            if (remaining <= 0 || !this.getTargets(player).length) {
+                return [this.endPlayerTurn(player)];
+            }
+        }
+        return [];
+    }
+    getMovesAfterPlayersDone() {
+        this.forget(Memory.EffectTargets);
+        this.forget(Memory.EffectCount);
+        return super.getMovesAfterPlayersDone();
+    }
+}

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

@@ -0,0 +1,15 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { DrawEffect } from '../../EffectTraits';
+declare class CrystalMiningRule extends CardRule implements DrawEffect {
+    onEnters(): void;
+    getDrawCount(): 1 | 2;
+}
+export declare const CrystalMining: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof CrystalMiningRule;
+};
+export {};

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

@@ -0,0 +1,22 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+class CrystalMiningRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
+    getDrawCount() {
+        const myHand = this.material(MaterialType.Card).location(LocationType.PlayerHand).player(this.player).length;
+        const foeHand = this.material(MaterialType.Card).location(LocationType.PlayerHand).player(this.foe).length;
+        return myHand + 1 < foeHand ? 2 : 1;
+    }
+}
+export const CrystalMining = {
+    power: 3,
+    type: CardType.Action,
+    suit: CardSuit.Day,
+    rule: CrystalMiningRule
+};

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

@@ -0,0 +1,4 @@
+import { DrawEffectRule } from '../../../rules/DrawEffectRule';
+export declare class CrystalMiningBonusEffectRule extends DrawEffectRule {
+    get drawCount(): 1 | 0;
+}

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

@@ -0,0 +1,10 @@
+import { LocationType } from '../../LocationType';
+import { MaterialType } from '../../MaterialType';
+import { DrawEffectRule } from '../../../rules/DrawEffectRule';
+export class CrystalMiningBonusEffectRule extends DrawEffectRule {
+    get drawCount() {
+        const myHand = this.material(MaterialType.Card).location(LocationType.PlayerHand).player(this.player).length;
+        const foeHand = this.material(MaterialType.Card).location(LocationType.PlayerHand).player(this.nextPlayer).length;
+        return myHand < foeHand ? 1 : 0;
+    }
+}

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

@@ -0,0 +1,15 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { DrawEffect } from '../../EffectTraits';
+declare class CrystalShaftRule extends CardRule implements DrawEffect {
+    onSkirmishWin(): void;
+    getDrawCount(): number;
+}
+export declare const CrystalShaft: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof CrystalShaftRule;
+};
+export {};

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

@@ -0,0 +1,18 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class CrystalShaftRule extends CardRule {
+    onSkirmishWin() {
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
+    getDrawCount() {
+        return 3;
+    }
+}
+export const CrystalShaft = {
+    power: 4,
+    type: CardType.Action,
+    suit: CardSuit.Night,
+    rule: CrystalShaftRule
+};

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

@@ -0,0 +1,13 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+declare class CycleKeeperRule extends CardRule {
+    onEnters(): void;
+}
+export declare const CycleKeeper: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof CycleKeeperRule;
+};
+export {};

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

@@ -0,0 +1,15 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class CycleKeeperRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.CycleKeeperEffect);
+    }
+}
+export const CycleKeeper = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Twilight,
+    rule: CycleKeeperRule
+};