@gamepark/mythologies 0.10.0 → 0.12.0

package/dist/material/entity/PlaceCardEffectRule.d.ts

@@ -1,15 +1,17 @@
-import { ItemMove, Material, MaterialMove, MoveItem, XYCoordinates } from '@gamepark/rules-api';
-import { PlayerEffectRule } from './PlayerEffectRule';
-export declare abstract class PlaceCardEffectRule extends PlayerEffectRule {
-    canPlayEffect(cardIndex: number): boolean;
-    playEffect(): MaterialMove[];
-    getPlayerMoves(cardIndex?: number): MaterialMove[];
-    abstract getCardsToPlace(cardIndex: number): Material;
-    getAvailableDestinations(_cardIndex: number): XYCoordinates[];
-    beforeItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];
-    onCardPlaced(move: MoveItem): MaterialMove[];
-}
-export declare abstract class InvokeEffectRule extends PlaceCardEffectRule {
-    isInvoke: boolean;
-    getAvailableDestinations(): XYCoordinates[];
-}
+import { ItemMove, Material, MaterialMove, MoveItem, XYCoordinates } from '@gamepark/rules-api';
+import { PlayerEffectRule } from './PlayerEffectRule';
+export declare abstract class PlaceCardEffectRule extends PlayerEffectRule {
+    times: number;
+    canPlayEffect(cardIndex: number): boolean;
+    playEffect(): MaterialMove[];
+    onRuleStart(): MaterialMove[];
+    getPlayerMoves(cardIndex?: number): MaterialMove[];
+    abstract getCardsToPlace(cardIndex: number): Material;
+    getAvailableDestinations(_cardIndex: number): XYCoordinates[];
+    beforeItemMove(move: ItemMove): MaterialMove[];
+    onCardPlaced(move: MoveItem): MaterialMove[];
+}
+export declare abstract class InvokeEffectRule extends PlaceCardEffectRule {
+    isInvoke: boolean;
+    getAvailableDestinations(): XYCoordinates[];
+}

package/dist/material/entity/PlaceCardEffectRule.js

@@ -1,78 +1,58 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvokeEffectRule = exports.PlaceCardEffectRule = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var CustomMoveType_1 = require("../../CustomMoveType");
-var Entity_1 = require("../Entity");
-var LocationType_1 = require("../LocationType");
-var MaterialType_1 = require("../MaterialType");
-var Pantheon_1 = require("../Pantheon");
-var PlayerEffectRule_1 = require("./PlayerEffectRule");
-var PlaceCardEffectRule = (function (_super) {
-    __extends(PlaceCardEffectRule, _super);
-    function PlaceCardEffectRule() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    PlaceCardEffectRule.prototype.canPlayEffect = function (cardIndex) {
-        return this.getPlayerMoves(cardIndex).length > 0;
-    };
-    PlaceCardEffectRule.prototype.playEffect = function () {
-        if (!this.getPlayerMoves().length)
-            return [];
-        return _super.prototype.playEffect.call(this);
-    };
-    PlaceCardEffectRule.prototype.getPlayerMoves = function (cardIndex) {
-        if (cardIndex === void 0) { cardIndex = this.getEffect().cardIndex; }
-        var player = this.material(MaterialType_1.MaterialType.EntityCard).getItem(cardIndex).location.player;
-        var cards = this.getCardsToPlace(cardIndex);
-        var cardsICanPlace = new Pantheon_1.Pantheon(this.game, player).gems < 4 ? cards.id(function (id) { return !(0, Entity_1.isGod)(id.front); }) : cards;
-        return this.getAvailableDestinations(cardIndex).flatMap(function (_a) {
-            var x = _a.x, y = _a.y;
-            return cardsICanPlace.moveItems({ type: LocationType_1.LocationType.Pantheon, player: player, x: x, y: y });
-        });
-    };
-    PlaceCardEffectRule.prototype.getAvailableDestinations = function (_cardIndex) {
-        return new Pantheon_1.Pantheon(this.game, this.player).legalSpaces;
-    };
-    PlaceCardEffectRule.prototype.beforeItemMove = function (move) {
-        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.EntityCard)(move) && move.location.type === LocationType_1.LocationType.Pantheon) {
-            return this.onCardPlaced(move);
-        }
-        return [];
-    };
-    PlaceCardEffectRule.prototype.onCardPlaced = function (move) {
-        var moves = new Pantheon_1.Pantheon(this.game, this.player).onCardPlaced(move);
-        moves.push(this.customMove(CustomMoveType_1.CustomMoveType.EndEffect));
-        return moves;
-    };
-    return PlaceCardEffectRule;
-}(PlayerEffectRule_1.PlayerEffectRule));
-exports.PlaceCardEffectRule = PlaceCardEffectRule;
-var InvokeEffectRule = (function (_super) {
-    __extends(InvokeEffectRule, _super);
-    function InvokeEffectRule() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.isInvoke = true;
-        return _this;
-    }
-    InvokeEffectRule.prototype.getAvailableDestinations = function () {
-        return new Pantheon_1.Pantheon(this.game, this.player).legalSpacesToInvoke;
-    };
-    return InvokeEffectRule;
-}(PlaceCardEffectRule));
-exports.InvokeEffectRule = InvokeEffectRule;
+import { isMoveItemType } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
+import { Memory } from '../../Memory';
+import { isGod } from '../Entity';
+import { LocationType } from '../LocationType';
+import { MaterialType } from '../MaterialType';
+import { Pantheon } from '../Pantheon';
+import { PendingEffectsType } from './Effect';
+import { PlayerEffectRule } from './PlayerEffectRule';
+export class PlaceCardEffectRule extends PlayerEffectRule {
+    times = 1;
+    canPlayEffect(cardIndex) {
+        return this.getPlayerMoves(cardIndex).length > 0;
+    }
+    playEffect() {
+        if (!this.getPlayerMoves().length)
+            return [];
+        return super.playEffect();
+    }
+    onRuleStart() {
+        const count = this.getEffect().count ?? 1;
+        if (count < this.times) {
+            const repeatEffect = {
+                type: PendingEffectsType.CardsEffects,
+                player: this.player,
+                effects: [{ ...this.getEffect(), count: count + 1 }]
+            };
+            this.memorize(Memory.PendingEffects, (effects) => [repeatEffect, ...effects]);
+        }
+        return super.onRuleStart();
+    }
+    getPlayerMoves(cardIndex = this.getEffect().cardIndex) {
+        const player = this.material(MaterialType.EntityCard).getItem(cardIndex).location.player;
+        const cards = this.getCardsToPlace(cardIndex);
+        const cardsICanPlace = new Pantheon(this.game, player).gems < 4 ? cards.id((id) => !isGod(id.front)) : cards;
+        return this.getAvailableDestinations(cardIndex).flatMap(({ x, y }) => cardsICanPlace.moveItems({ type: LocationType.Pantheon, player, x, y }));
+    }
+    getAvailableDestinations(_cardIndex) {
+        return new Pantheon(this.game, this.player).legalSpaces;
+    }
+    beforeItemMove(move) {
+        if (isMoveItemType(MaterialType.EntityCard)(move) && move.location.type === LocationType.Pantheon) {
+            return this.onCardPlaced(move);
+        }
+        return [];
+    }
+    onCardPlaced(move) {
+        const moves = new Pantheon(this.game, this.player).onCardPlaced(move);
+        moves.push(this.customMove(CustomMoveType.EndEffect));
+        return moves;
+    }
+}
+export class InvokeEffectRule extends PlaceCardEffectRule {
+    isInvoke = true;
+    getAvailableDestinations() {
+        return new Pantheon(this.game, this.player).legalSpacesToInvoke;
+    }
+}

package/dist/material/entity/PlayerEffectRule.d.ts

@@ -1,14 +1,14 @@
-import { CustomMove, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
-import { RuleId } from '../../rules/RuleId';
-import { EntityId } from '../Entity';
-import { EffectRule, PendingEffect, TriggerEvent } from './Effect';
-export declare abstract class PlayerEffectRule extends PlayerTurnRule implements EffectRule {
-    canPlayEffect(_cardIndex: number): boolean;
-    ruleId?: RuleId;
-    playEffect(): MaterialMove[];
-    onRuleStart(): MaterialMove[];
-    get card(): import("@gamepark/rules-api").MaterialItem<number, number, EntityId>;
-    getEffect<Event extends TriggerEvent>(): PendingEffect<Event>;
-    onCustomMove(move: CustomMove): MaterialMove<number, number, number, number>[];
-    onEndEffect(): MaterialMove<number, number, number, number>[];
-}
+import { CustomMove, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
+import { RuleId } from '../../rules/RuleId';
+import { EntityId } from '../Entity';
+import { CardEffect, EffectRule, TriggerEvent } from './Effect';
+export declare abstract class PlayerEffectRule extends PlayerTurnRule implements EffectRule {
+    canPlayEffect(_cardIndex: number): boolean;
+    ruleId?: RuleId;
+    playEffect(): MaterialMove[];
+    onRuleStart(): MaterialMove[];
+    get card(): import("@gamepark/rules-api").MaterialItem<number, number, EntityId>;
+    getEffect<Event extends TriggerEvent>(): CardEffect<Event>;
+    onCustomMove(move: CustomMove): MaterialMove[];
+    onEndEffect(): MaterialMove[];
+}

package/dist/material/entity/PlayerEffectRule.js

@@ -1,63 +1,36 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PlayerEffectRule = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var CustomMoveType_1 = require("../../CustomMoveType");
-var Memory_1 = require("../../Memory");
-var ResolveEffectsRule_1 = require("../../rules/effects/ResolveEffectsRule");
-var MaterialType_1 = require("../MaterialType");
-var PlayerEffectRule = (function (_super) {
-    __extends(PlayerEffectRule, _super);
-    function PlayerEffectRule() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    PlayerEffectRule.prototype.canPlayEffect = function (_cardIndex) {
-        return true;
-    };
-    PlayerEffectRule.prototype.playEffect = function () {
-        return this.ruleId ? [this.startRule(this.ruleId)] : [];
-    };
-    PlayerEffectRule.prototype.onRuleStart = function () {
-        if (!this.getPlayerMoves().length) {
-            return [this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
-        }
-        return [];
-    };
-    Object.defineProperty(PlayerEffectRule.prototype, "card", {
-        get: function () {
-            var index = this.getEffect().cardIndex;
-            return this.material(MaterialType_1.MaterialType.EntityCard).getItem(index);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    PlayerEffectRule.prototype.getEffect = function () {
-        return this.remind(Memory_1.Memory.OngoingEffect);
-    };
-    PlayerEffectRule.prototype.onCustomMove = function (move) {
-        if (move.type === CustomMoveType_1.CustomMoveType.EndEffect) {
-            return this.onEndEffect();
-        }
-        return [];
-    };
-    PlayerEffectRule.prototype.onEndEffect = function () {
-        return new ResolveEffectsRule_1.ResolveEffectsRule(this.game).onEndEffect();
-    };
-    return PlayerEffectRule;
-}(rules_api_1.PlayerTurnRule));
-exports.PlayerEffectRule = PlayerEffectRule;
+import { PlayerTurnRule } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
+import { Memory } from '../../Memory';
+import { ResolveEffectsRule } from '../../rules/effects/ResolveEffectsRule';
+import { MaterialType } from '../MaterialType';
+export class PlayerEffectRule extends PlayerTurnRule {
+    canPlayEffect(_cardIndex) {
+        return true;
+    }
+    ruleId;
+    playEffect() {
+        return this.ruleId ? [this.startRule(this.ruleId)] : [];
+    }
+    onRuleStart() {
+        if (!this.getPlayerMoves().length) {
+            return [this.customMove(CustomMoveType.EndEffect)];
+        }
+        return [];
+    }
+    get card() {
+        const index = this.getEffect().cardIndex;
+        return this.material(MaterialType.EntityCard).getItem(index);
+    }
+    getEffect() {
+        return this.remind(Memory.OngoingEffect);
+    }
+    onCustomMove(move) {
+        if (move.type === CustomMoveType.EndEffect) {
+            return this.onEndEffect();
+        }
+        return [];
+    }
+    onEndEffect() {
+        return new ResolveEffectsRule(this.game).onEndEffect();
+    }
+}

package/dist/material/entity/SacrificeEffectRule.d.ts

@@ -1,11 +1,11 @@
-import { ItemMove, Material, MaterialMove, MoveItem } from '@gamepark/rules-api';
-import { PlayerEffectRule } from './PlayerEffectRule';
-export declare abstract class SacrificeEffectRule extends PlayerEffectRule {
-    canPlayEffect(_cardIndex: number): boolean;
-    playEffect(): MaterialMove[];
-    getPlayerMoves(): MoveItem<number, number, number>[];
-    private getCardsAbleToSacrifice;
-    getCardsToSacrifice(): Material;
-    beforeItemMove(move: ItemMove): MaterialMove[];
-    onSacrifice(_move: MoveItem): MaterialMove[];
-}
+import { ItemMove, Material, MaterialMove, MoveItem } from '@gamepark/rules-api';
+import { PlayerEffectRule } from './PlayerEffectRule';
+export declare abstract class SacrificeEffectRule extends PlayerEffectRule {
+    canPlayEffect(_cardIndex: number): boolean;
+    playEffect(): MaterialMove[];
+    getPlayerMoves(): MoveItem<number, number, number>[];
+    private getCardsAbleToSacrifice;
+    getCardsToSacrifice(): Material;
+    beforeItemMove(move: ItemMove): MaterialMove[];
+    onSacrifice(_move: MoveItem): MaterialMove[];
+}

package/dist/material/entity/SacrificeEffectRule.js

@@ -1,64 +1,40 @@
-"use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SacrificeEffectRule = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var CustomMoveType_1 = require("../../CustomMoveType");
-var PermanentEffectsRule_1 = require("../../rules/effects/PermanentEffectsRule");
-var LocationType_1 = require("../LocationType");
-var MaterialType_1 = require("../MaterialType");
-var Pantheon_1 = require("../Pantheon");
-var PlayerEffectRule_1 = require("./PlayerEffectRule");
-var SacrificeEffectRule = (function (_super) {
-    __extends(SacrificeEffectRule, _super);
-    function SacrificeEffectRule() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    SacrificeEffectRule.prototype.canPlayEffect = function (_cardIndex) {
-        return this.getCardsToSacrifice().length > 0;
-    };
-    SacrificeEffectRule.prototype.playEffect = function () {
-        if (!this.getCardsAbleToSacrifice().length)
-            return [];
-        return _super.prototype.playEffect.call(this);
-    };
-    SacrificeEffectRule.prototype.getPlayerMoves = function () {
-        var cards = this.getCardsAbleToSacrifice();
-        var moves = cards.moveItems({ type: LocationType_1.LocationType.PlayerDiscard, player: this.player });
-        var indexes = cards.getIndexes();
-        var replaceSacrifice = new Pantheon_1.Pantheon(this.game, this.player).replaceSacrifice(cards.getItems()).index(function (index) { return !indexes.includes(index); });
-        return moves.concat(replaceSacrifice.moveItems({ type: LocationType_1.LocationType.PlayerDiscard, player: this.player }));
-    };
-    SacrificeEffectRule.prototype.getCardsAbleToSacrifice = function () {
-        var rule = new PermanentEffectsRule_1.PermanentEffectsRule(this.game);
-        return this.getCardsToSacrifice().filter(function (card) { return rule.canSacrifice(card); });
-    };
-    SacrificeEffectRule.prototype.getCardsToSacrifice = function () {
-        return new Pantheon_1.Pantheon(this.game, this.player).visibleEntities;
-    };
-    SacrificeEffectRule.prototype.beforeItemMove = function (move) {
-        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.EntityCard)(move) && move.location.type === LocationType_1.LocationType.PlayerDiscard) {
-            return this.onSacrifice(move);
-        }
-        return [];
-    };
-    SacrificeEffectRule.prototype.onSacrifice = function (_move) {
-        return [this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
-    };
-    return SacrificeEffectRule;
-}(PlayerEffectRule_1.PlayerEffectRule));
-exports.SacrificeEffectRule = SacrificeEffectRule;
+import { isMoveItemType } from '@gamepark/rules-api';
+import { CustomMoveType } from '../../CustomMoveType';
+import { PermanentEffectsRule } from '../../rules/effects/PermanentEffectsRule';
+import { LocationType } from '../LocationType';
+import { MaterialType } from '../MaterialType';
+import { Pantheon } from '../Pantheon';
+import { PlayerEffectRule } from './PlayerEffectRule';
+export class SacrificeEffectRule extends PlayerEffectRule {
+    canPlayEffect(_cardIndex) {
+        return this.getCardsToSacrifice().length > 0;
+    }
+    playEffect() {
+        if (!this.getCardsAbleToSacrifice().length)
+            return [];
+        return super.playEffect();
+    }
+    getPlayerMoves() {
+        const cards = this.getCardsAbleToSacrifice();
+        const moves = cards.moveItems({ type: LocationType.PlayerDiscard, player: this.player });
+        const indexes = cards.getIndexes();
+        const replaceSacrifice = new Pantheon(this.game, this.player).replaceSacrifice(cards.getItems()).index((index) => !indexes.includes(index));
+        return moves.concat(replaceSacrifice.moveItems({ type: LocationType.PlayerDiscard, player: this.player }));
+    }
+    getCardsAbleToSacrifice() {
+        const rule = new PermanentEffectsRule(this.game);
+        return this.getCardsToSacrifice().filter((card) => rule.canSacrifice(card));
+    }
+    getCardsToSacrifice() {
+        return new Pantheon(this.game, this.player).visibleEntities;
+    }
+    beforeItemMove(move) {
+        if (isMoveItemType(MaterialType.EntityCard)(move) && move.location.type === LocationType.PlayerDiscard) {
+            return this.onSacrifice(move);
+        }
+        return [];
+    }
+    onSacrifice(_move) {
+        return [this.customMove(CustomMoveType.EndEffect)];
+    }
+}

package/dist/material/entity/SimultaneousEffectRule.d.ts

@@ -1,18 +1,18 @@
-import { CustomMove, MaterialMove, SimultaneousRule } from '@gamepark/rules-api';
-import { PlayerColor } from '../../PlayerColor';
-import { RuleId } from '../../rules/RuleId';
-import { EntityId } from '../Entity';
-import { EffectRule, PendingEffect, TriggerEvent } from './Effect';
-export declare abstract class SimultaneousEffectRule extends SimultaneousRule implements EffectRule {
-    canPlayEffect(_cardIndex: number): boolean;
-    ruleId?: RuleId;
-    playEffect(): MaterialMove[];
-    onRuleStart(): MaterialMove<number, number, number, number>[];
-    getAffectedPlayers(): PlayerColor[];
-    isOpponent(player: PlayerColor): boolean;
-    get card(): import("@gamepark/rules-api").MaterialItem<number, number, EntityId>;
-    getEffect<Event extends TriggerEvent>(): PendingEffect<Event>;
-    getMovesAfterPlayersDone(): MaterialMove[];
-    onCustomMove(move: CustomMove): MaterialMove<number, number, number, number>[];
-    onEndEffect(): MaterialMove<number, number, number, number>[];
-}
+import { CustomMove, MaterialMove, SimultaneousRule } from '@gamepark/rules-api';
+import { PlayerColor } from '../../PlayerColor';
+import { RuleId } from '../../rules/RuleId';
+import { EntityId } from '../Entity';
+import { CardEffect, EffectRule, TriggerEvent } from './Effect';
+export declare abstract class SimultaneousEffectRule extends SimultaneousRule implements EffectRule {
+    canPlayEffect(_cardIndex: number): boolean;
+    ruleId?: RuleId;
+    playEffect(): MaterialMove[];
+    onRuleStart(): MaterialMove[];
+    getAffectedPlayers(): PlayerColor[];
+    isOpponent(player: PlayerColor): boolean;
+    get card(): import("@gamepark/rules-api").MaterialItem<number, number, EntityId>;
+    getEffect<Event extends TriggerEvent>(): CardEffect<Event>;
+    getMovesAfterPlayersDone(): MaterialMove[];
+    onCustomMove(move: CustomMove): MaterialMove[];
+    onEndEffect(): MaterialMove[];
+}