@gamepark/skyrift 0.4.3 → 0.6.0

package/dist/material/OngoingEffect.js

@@ -1,5 +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/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/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

@@ -0,0 +1,21 @@
+import { Material } from '@gamepark/rules-api';
+import { Deck } from '../../../Deck';
+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;
+    getPlayerPowerModifier(player: Deck): 4 | 0;
+    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;
+    }
+    getPlayerPowerModifier(player) {
+        return player === this.foe ? 4 : 0;
+    }
+    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
+};

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

@@ -0,0 +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<CustomMoveType.ChooseSuit, CardSuit>[];
+    onCustomMove(move: CustomMove): import("@gamepark/rules-api").MaterialMove[];
+}

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

@@ -0,0 +1,21 @@
+import { CustomMoveType } from '../../../CustomMoveType';
+import { Memory } from '../../../Memory';
+import { CardSuit } from '../../CardSuit';
+import { OngoingEffectType } from '../../OngoingEffect';
+import { EffectRule } from '../../../rules/EffectRule';
+export class CycleKeeperEffectRule extends EffectRule {
+    getPlayerMoves() {
+        return [
+            this.customMove(CustomMoveType.ChooseSuit, CardSuit.Day),
+            this.customMove(CustomMoveType.ChooseSuit, CardSuit.Night)
+        ];
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.ChooseSuit) {
+            this.memorize(Memory.Suit, move.data);
+            this.cardRule.addOngoingEffect(OngoingEffectType.LockSuit);
+            return this.endEffect();
+        }
+        return super.onCustomMove(move);
+    }
+}

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

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

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

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

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

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

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

@@ -0,0 +1,15 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { OngoingEffectType } from '../../OngoingEffect';
+class DarkSwarmRule extends CardRule {
+    onEnters() {
+        this.addOngoingEffect(OngoingEffectType.PassTurn);
+    }
+}
+export const DarkSwarm = {
+    power: 1,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: DarkSwarmRule
+};

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

@@ -0,0 +1,6 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { EffectRule } from '../../../rules/EffectRule';
+export declare class DarkSwarmEffectRule extends EffectRule {
+    onRuleStart(): MaterialMove[];
+    onEndEffect(): MaterialMove[];
+}

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

@@ -0,0 +1,18 @@
+import { Memory } from '../../../Memory';
+import { EffectRule } from '../../../rules/EffectRule';
+import { PlayerHelper } from '../../../rules/PlayerHelper';
+import { RuleId } from '../../../rules/RuleId';
+export class DarkSwarmEffectRule extends EffectRule {
+    onRuleStart() {
+        return this.endEffect();
+    }
+    onEndEffect() {
+        this.memorize(Memory.PendingEffects, (effects) => effects.slice(1));
+        const pendingEffects = this.remind(Memory.PendingEffects);
+        if (pendingEffects.length > 0) {
+            return new PlayerHelper(this.game, this.player).startEffect(pendingEffects[0]);
+        }
+        const currentPlayer = this.remind(Memory.CurrentPlayer);
+        return [this.startPlayerTurn(RuleId.EndPlayerTurn, currentPlayer)];
+    }
+}

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

@@ -0,0 +1,15 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { ReturnCardEffect } from '../../EffectTraits';
+declare class ElevatorOfTheAbyssRule extends CardRule implements ReturnCardEffect {
+    onEnters(): void;
+    getReturnTargets(): import("@gamepark/rules-api").Material<number, number, number>;
+}
+export declare const ElevatorOfTheAbyss: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof ElevatorOfTheAbyssRule;
+};
+export {};

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

@@ -0,0 +1,19 @@
+import { RuleId } from '../../../rules/RuleId';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class ElevatorOfTheAbyssRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.ReturnCardEffect);
+        this.addPendingEffect(RuleId.ChallengeEffect);
+    }
+    getReturnTargets() {
+        return this.creatures.player(this.player);
+    }
+}
+export const ElevatorOfTheAbyss = {
+    power: 1,
+    type: CardType.Action,
+    suit: CardSuit.Day,
+    rule: ElevatorOfTheAbyssRule
+};

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

@@ -0,0 +1,16 @@
+import { Material } from '@gamepark/rules-api';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { DestroyEffect } from '../../EffectTraits';
+declare class ExplosiveKittyRule extends CardRule implements DestroyEffect {
+    onEnters(): void;
+    getDestroyTargets(): Material;
+}
+export declare const ExplosiveKitty: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof ExplosiveKittyRule;
+};
+export {};

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

@@ -0,0 +1,19 @@
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+class ExplosiveKittyRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.DestroyEffect);
+    }
+    getDestroyTargets() {
+        return this.playArea.id((id) => cardProperties[id.front].type === CardType.Action);
+    }
+}
+export const ExplosiveKitty = {
+    power: 1,
+    type: CardType.Action,
+    suit: CardSuit.Twilight,
+    rule: ExplosiveKittyRule
+};

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

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

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

@@ -0,0 +1,18 @@
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { PlayerHelper } from '../../../rules/PlayerHelper';
+class GromIronspikeRule extends CardRule {
+    canBePlayed() {
+        if (!super.canBePlayed())
+            return false;
+        const foePower = new PlayerHelper(this.game, this.foe).getPower();
+        return foePower >= 12;
+    }
+}
+export const GromIronspike = {
+    power: 7,
+    type: CardType.Creature,
+    suit: CardSuit.Night,
+    rule: GromIronspikeRule
+};

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

@@ -0,0 +1,20 @@
+import { Material } from '@gamepark/rules-api';
+import { Deck } from '../../../Deck';
+import { Card } from '../../Card';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { DestroyEffect } from '../../EffectTraits';
+declare class GuntarRustypikeRule extends CardRule implements DestroyEffect {
+    onEnters(): void;
+    onCardEnters(card: Card, side: Deck): void;
+    getDestroyTargets(): Material;
+    isAutoDestroy(): boolean;
+}
+export declare const GuntarRustypike: {
+    power: number;
+    type: CardType;
+    suit: CardSuit;
+    rule: typeof GuntarRustypikeRule;
+};
+export {};

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

@@ -0,0 +1,28 @@
+import { RuleId } from '../../../rules/RuleId';
+import { cardProperties } from '../../CardProperties';
+import { CardRule } from '../../CardRule';
+import { CardSuit } from '../../CardSuit';
+import { CardType } from '../../CardType';
+import { MaterialType } from '../../MaterialType';
+class GuntarRustypikeRule extends CardRule {
+    onEnters() {
+        this.addPendingEffect(RuleId.DrawEffect);
+    }
+    onCardEnters(card, side) {
+        if (side === this.foe && cardProperties[card].type === CardType.Action) {
+            this.addPendingEffect(RuleId.DestroyEffect);
+        }
+    }
+    getDestroyTargets() {
+        return this.material(MaterialType.Card).index(this.index);
+    }
+    isAutoDestroy() {
+        return true;
+    }
+}
+export const GuntarRustypike = {
+    power: 5,
+    type: CardType.Creature,
+    suit: CardSuit.Day,
+    rule: GuntarRustypikeRule
+};