@gamepark/mythologies 0.1.0

package/dist/rules/effects/RakshasaEffectRule.js

@@ -0,0 +1,48 @@
+"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.RakshasaEffectRule = void 0;
+var Destiny_1 = require("../../material/Destiny");
+var PlaceCardEffectRule_1 = require("../../material/entity/PlaceCardEffectRule");
+var MaterialType_1 = require("../../material/MaterialType");
+var Pantheon_1 = require("../../material/Pantheon");
+var RuleId_1 = require("../RuleId");
+var RakshasaEffectRule = (function (_super) {
+    __extends(RakshasaEffectRule, _super);
+    function RakshasaEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.RakshasaEffect;
+        return _this;
+    }
+    RakshasaEffectRule.prototype.canPlayEffect = function (cardIndex) {
+        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
+        return pantheon.gems > 0 && _super.prototype.canPlayEffect.call(this, cardIndex);
+    };
+    RakshasaEffectRule.prototype.onRuleStart = function () {
+        return [new Pantheon_1.Pantheon(this.game, this.player).spendGems(1)];
+    };
+    RakshasaEffectRule.prototype.getCardsToPlace = function () {
+        return new Destiny_1.Destiny(this.game).getAvailableEntities(this.player);
+    };
+    RakshasaEffectRule.prototype.getAvailableDestinations = function (cardIndex) {
+        var location = this.material(MaterialType_1.MaterialType.EntityCard).getItem(cardIndex).location;
+        var pantheon = new Pantheon_1.Pantheon(this.game, location.player);
+        return pantheon.isLegalSpaceToInvoke(location) ? [location] : [];
+    };
+    return RakshasaEffectRule;
+}(PlaceCardEffectRule_1.PlaceCardEffectRule));
+exports.RakshasaEffectRule = RakshasaEffectRule;

package/dist/rules/effects/ResolveEffectsRule.d.ts

@@ -0,0 +1,6 @@
+import { CustomMove, PlayerTurnRule, RuleMove, RuleStep } from '@gamepark/rules-api';
+export declare class ResolveEffectsRule extends PlayerTurnRule {
+    onRuleStart(_move: RuleMove, previousRule: RuleStep): CustomMove<number>[];
+    getPlayerMoves(): CustomMove<number>[];
+    onCustomMove(move: CustomMove): import("@gamepark/rules-api").MaterialMove<number, number, number, number>[];
+}

package/dist/rules/effects/ResolveEffectsRule.js

@@ -0,0 +1,73 @@
+"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.ResolveEffectsRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var lodash_1 = require("lodash");
+var CustomMoveType_1 = require("../../CustomMoveType");
+var Effect_1 = require("../../material/entity/Effect");
+var EntityDescription_1 = require("../../material/entity/EntityDescription");
+var MaterialType_1 = require("../../material/MaterialType");
+var Memory_1 = require("../../Memory");
+var ResolveEffectsRule = (function (_super) {
+    __extends(ResolveEffectsRule, _super);
+    function ResolveEffectsRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ResolveEffectsRule.prototype.onRuleStart = function (_move, previousRule) {
+        if (!this.remind(Memory_1.Memory.PendingRule)) {
+            this.memorize(Memory_1.Memory.PendingRule, previousRule);
+        }
+        var moves = this.getPlayerMoves();
+        return moves.length === 1 ? moves : [];
+    };
+    ResolveEffectsRule.prototype.getPlayerMoves = function () {
+        var _this = this;
+        var _a;
+        var pendingEffects = (_a = this.remind(Memory_1.Memory.PendingEffects)[0]) !== null && _a !== void 0 ? _a : [];
+        return pendingEffects.map(function (effect) { return _this.customMove(CustomMoveType_1.CustomMoveType.PlayEffect, effect); });
+    };
+    ResolveEffectsRule.prototype.onCustomMove = function (move) {
+        if (move.type === CustomMoveType_1.CustomMoveType.PlayEffect) {
+            var pendingEffect_1 = move.data;
+            var pendingEffects = this.remind(Memory_1.Memory.PendingEffects);
+            if (pendingEffects.length) {
+                pendingEffects[0] = pendingEffects[0].filter(function (effect) { return !(0, lodash_1.isEqual)(effect, pendingEffect_1); });
+                if (pendingEffects[0].length === 0) {
+                    pendingEffects.splice(0, 1);
+                }
+            }
+            this.memorize(Memory_1.Memory.OngoingEffect, pendingEffect_1);
+            var card = this.material(MaterialType_1.MaterialType.EntityCard).getItem(pendingEffect_1.cardIndex);
+            var effect = (0, EntityDescription_1.getEffects)(card.id.front)[pendingEffect_1.effectIndex];
+            if (effect.trigger === Effect_1.oncePerTurn) {
+                this.memorize(Memory_1.Memory.OncePerTurn, function (indexes) {
+                    if (indexes === void 0) { indexes = []; }
+                    return indexes.concat(pendingEffect_1.cardIndex);
+                });
+            }
+            var moves = new effect.rule(this.game).playEffect();
+            if (!moves.some(function (move) { return move.kind === rules_api_1.MoveKind.RulesMove; })) {
+                moves.push(this.customMove(CustomMoveType_1.CustomMoveType.EndEffect));
+            }
+            return moves;
+        }
+        return [];
+    };
+    return ResolveEffectsRule;
+}(rules_api_1.PlayerTurnRule));
+exports.ResolveEffectsRule = ResolveEffectsRule;

package/dist/rules/effects/ShivaEffectRule.d.ts

@@ -0,0 +1,10 @@
+import { ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { PlayerEffectRule } from '../../material/entity/Effect';
+import { RuleId } from '../RuleId';
+export declare class ShivaEffectRule extends PlayerEffectRule {
+    ruleId: RuleId;
+    canPlayEffect(cardIndex: number): boolean;
+    onRuleStart(): MaterialMove[];
+    getPlayerMoves(): MaterialMove[];
+    afterItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];
+}

package/dist/rules/effects/ShivaEffectRule.js

@@ -0,0 +1,82 @@
+"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 __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShivaEffectRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Effect_1 = require("../../material/entity/Effect");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var Pantheon_1 = require("../../material/Pantheon");
+var RuleId_1 = require("../RuleId");
+var ShivaEffectRule = (function (_super) {
+    __extends(ShivaEffectRule, _super);
+    function ShivaEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.ShivaEffect;
+        return _this;
+    }
+    ShivaEffectRule.prototype.canPlayEffect = function (cardIndex) {
+        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
+        var cards = pantheon.allCards;
+        var location = cards.getItem(cardIndex).location;
+        return pantheon.gems > 0 && cards.location(function (l) { return (0, rules_api_1.areAdjacentSquares)(l, location); }).length > 0;
+    };
+    ShivaEffectRule.prototype.onRuleStart = function () {
+        return [new Pantheon_1.Pantheon(this.game, this.player).spendGems(1)];
+    };
+    ShivaEffectRule.prototype.getPlayerMoves = function () {
+        var _this = this;
+        var location = this.card.location;
+        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
+        var piles = pantheon.getPiles(function (space) { return (0, rules_api_1.areAdjacentSquares)(space, location); });
+        return piles.map(function (pile) { return pile.moveItemsAtOnce({ type: LocationType_1.LocationType.PlayerDiscard, player: _this.player }); });
+    };
+    ShivaEffectRule.prototype.afterItemMove = function (move) {
+        if ((0, rules_api_1.isMoveItemTypeAtOnce)(MaterialType_1.MaterialType.EntityCard)(move) && move.location.type === LocationType_1.LocationType.PlayerDiscard) {
+            var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
+            return __spreadArray([pantheon.gainFavor(move.indexes.length)], __read(this.endEffect()), false);
+        }
+        return [];
+    };
+    return ShivaEffectRule;
+}(Effect_1.PlayerEffectRule));
+exports.ShivaEffectRule = ShivaEffectRule;

package/dist/rules/effects/SphinxEffectRule.d.ts

@@ -0,0 +1,9 @@
+import { Location, Material, MaterialMove, MoveItem, XYCoordinates } from '@gamepark/rules-api';
+import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
+import { RuleId } from '../RuleId';
+export declare class SphinxEffectRule extends MoveEffectRule {
+    ruleId: RuleId;
+    getMovingCards(): Material;
+    isLegalDestination(space: XYCoordinates, cardLocation: Location): boolean;
+    onCardMoved(move: MoveItem): MaterialMove[];
+}

package/dist/rules/effects/SphinxEffectRule.js

@@ -0,0 +1,47 @@
+"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.SphinxEffectRule = void 0;
+var MoveEffectRule_1 = require("../../material/entity/MoveEffectRule");
+var MaterialType_1 = require("../../material/MaterialType");
+var Pantheon_1 = require("../../material/Pantheon");
+var RuleId_1 = require("../RuleId");
+var SphinxEffectRule = (function (_super) {
+    __extends(SphinxEffectRule, _super);
+    function SphinxEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.SphinxEffect;
+        return _this;
+    }
+    SphinxEffectRule.prototype.getMovingCards = function () {
+        var cardIndex = this.getEffect().cardIndex;
+        var _a = this.card.location, x = _a.x, y = _a.y;
+        return new Pantheon_1.Pantheon(this.game, this.player).allCards
+            .location(function (l) { return l.x === x && l.y === y; })
+            .index(function (i) { return i !== cardIndex; })
+            .maxBy(function (item) { return item.location.z; });
+    };
+    SphinxEffectRule.prototype.isLegalDestination = function (space, cardLocation) {
+        return space.x === cardLocation.x;
+    };
+    SphinxEffectRule.prototype.onCardMoved = function (move) {
+        var entity = this.material(MaterialType_1.MaterialType.EntityCard).getItem(move.itemIndex).id.front;
+        return new Pantheon_1.Pantheon(this.game, this.player).getInvokeGains(entity, move.location.y).concat(this.endEffect());
+    };
+    return SphinxEffectRule;
+}(MoveEffectRule_1.MoveEffectRule));
+exports.SphinxEffectRule = SphinxEffectRule;

package/dist/rules/effects/ThorEffectRule.d.ts

@@ -0,0 +1,11 @@
+import { ItemMove, Material } from '@gamepark/rules-api';
+import { SimultaneousSacrificeEffectRule } from '../../material/entity/SimultaneousSacrificeEffectRule';
+import { PlayerColor } from '../../PlayerColor';
+import { RuleId } from '../RuleId';
+export declare class ThorEffectRule extends SimultaneousSacrificeEffectRule {
+    ruleId: RuleId;
+    getAffectedPlayers(): PlayerColor[];
+    getActivePlayerLegalMoves(player: PlayerColor): import("@gamepark/rules-api").MaterialMove<number, number, number, number>[];
+    getCardsToSacrifice(player: PlayerColor): Material;
+    beforeItemMove(move: ItemMove): import("@gamepark/rules-api").EndPlayerTurn<number>[];
+}

package/dist/rules/effects/ThorEffectRule.js

@@ -0,0 +1,56 @@
+"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.ThorEffectRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Entity_1 = require("../../material/Entity");
+var SimultaneousSacrificeEffectRule_1 = require("../../material/entity/SimultaneousSacrificeEffectRule");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var Pantheon_1 = require("../../material/Pantheon");
+var RuleId_1 = require("../RuleId");
+var ThorEffectRule = (function (_super) {
+    __extends(ThorEffectRule, _super);
+    function ThorEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.ThorEffect;
+        return _this;
+    }
+    ThorEffectRule.prototype.getAffectedPlayers = function () {
+        var _this = this;
+        return _super.prototype.getAffectedPlayers.call(this).filter(function (player) { return _this.isOpponent(player); });
+    };
+    ThorEffectRule.prototype.getActivePlayerLegalMoves = function (player) {
+        var moves = _super.prototype.getActivePlayerLegalMoves.call(this, player);
+        var favor = this.material(MaterialType_1.MaterialType.FavorToken).location(LocationType_1.LocationType.PlayerFavor).player(player);
+        if (favor.getQuantity() >= 2 || (favor.getQuantity() === 1 && moves.length === 0)) {
+            moves.push(favor.deleteItem(2));
+        }
+        return moves;
+    };
+    ThorEffectRule.prototype.getCardsToSacrifice = function (player) {
+        return new Pantheon_1.Pantheon(this.game, player).visibleEntities.id(function (id) { return (0, Entity_1.isGod)(id.front); });
+    };
+    ThorEffectRule.prototype.beforeItemMove = function (move) {
+        if ((0, rules_api_1.isDeleteItemType)(MaterialType_1.MaterialType.FavorToken)(move)) {
+            return [this.endPlayerTurn(this.material(MaterialType_1.MaterialType.FavorToken).getItem(move.itemIndex).location.player)];
+        }
+        return [];
+    };
+    return ThorEffectRule;
+}(SimultaneousSacrificeEffectRule_1.SimultaneousSacrificeEffectRule));
+exports.ThorEffectRule = ThorEffectRule;

package/dist/rules/effects/TriggerEffectsRule.d.ts

@@ -0,0 +1,11 @@
+import { Material, MaterialRulesPart } from '@gamepark/rules-api';
+import { PendingEffect, TriggerEvent } from '../../material/entity/Effect';
+import { PlayerColor } from '../../PlayerColor';
+export declare class TriggerEffectsRule extends MaterialRulesPart {
+    triggerEffects(...triggerEvents: TriggerEvent[]): void;
+    triggerPlayerEffects(player: PlayerColor, ...triggerEvents: TriggerEvent[]): void;
+    getPlayerEffects(player: PlayerColor, ...triggerEvents: TriggerEvent[]): PendingEffect<TriggerEvent>[];
+    triggerCardEffect(card: Material, triggerEvent: TriggerEvent): void;
+    getCardEffect(card: Material, triggerEvent: TriggerEvent): PendingEffect[];
+    private getPlayersByEffectPriorityOrder;
+}

package/dist/rules/effects/TriggerEffectsRule.js

@@ -0,0 +1,159 @@
+"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 __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriggerEffectsRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var EntityDescription_1 = require("../../material/entity/EntityDescription");
+var MaterialType_1 = require("../../material/MaterialType");
+var Pantheon_1 = require("../../material/Pantheon");
+var Memory_1 = require("../../Memory");
+var TriggerEffectsRule = (function (_super) {
+    __extends(TriggerEffectsRule, _super);
+    function TriggerEffectsRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TriggerEffectsRule.prototype.triggerEffects = function () {
+        var e_1, _a;
+        var triggerEvents = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            triggerEvents[_i] = arguments[_i];
+        }
+        var players = this.getPlayersByEffectPriorityOrder();
+        try {
+            for (var _b = __values(players.reverse()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var player = _c.value;
+                this.triggerPlayerEffects.apply(this, __spreadArray([player], __read(triggerEvents), false));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    TriggerEffectsRule.prototype.triggerPlayerEffects = function (player) {
+        var triggerEvents = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            triggerEvents[_i - 1] = arguments[_i];
+        }
+        var pendingEffects = this.getPlayerEffects.apply(this, __spreadArray([player], __read(triggerEvents), false));
+        if (pendingEffects.length) {
+            this.remind(Memory_1.Memory.PendingEffects).unshift(pendingEffects);
+        }
+    };
+    TriggerEffectsRule.prototype.getPlayerEffects = function (player) {
+        var e_2, _a, e_3, _b;
+        var triggerEvents = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            triggerEvents[_i - 1] = arguments[_i];
+        }
+        var pendingEffects = [];
+        var pantheon = new Pantheon_1.Pantheon(this.game, player);
+        var cards = pantheon.visibleEntities;
+        try {
+            for (var triggerEvents_1 = __values(triggerEvents), triggerEvents_1_1 = triggerEvents_1.next(); !triggerEvents_1_1.done; triggerEvents_1_1 = triggerEvents_1.next()) {
+                var triggerEvent = triggerEvents_1_1.value;
+                try {
+                    for (var _c = (e_3 = void 0, __values(cards.getIndexes())), _d = _c.next(); !_d.done; _d = _c.next()) {
+                        var cardIndex = _d.value;
+                        pendingEffects.push.apply(pendingEffects, __spreadArray([], __read(this.getCardEffect(cards.index(cardIndex), triggerEvent)), false));
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (triggerEvents_1_1 && !triggerEvents_1_1.done && (_a = triggerEvents_1.return)) _a.call(triggerEvents_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return pendingEffects;
+    };
+    TriggerEffectsRule.prototype.triggerCardEffect = function (card, triggerEvent) {
+        var pendingEffects = this.getCardEffect(card, triggerEvent);
+        if (pendingEffects.length) {
+            this.remind(Memory_1.Memory.PendingEffects).unshift(pendingEffects);
+        }
+    };
+    TriggerEffectsRule.prototype.getCardEffect = function (card, triggerEvent) {
+        var pendingEffects = [];
+        var cardIndex = card.getIndex();
+        var cardItem = card.getItem();
+        var effects = cardItem.id.front ? (0, EntityDescription_1.getEffects)(cardItem.id.front) : [];
+        for (var effectIndex = 0; effectIndex < effects.length; effectIndex++) {
+            var effect = effects[effectIndex];
+            if (effect.trigger(triggerEvent, card, this.game)) {
+                pendingEffects.push({ cardIndex: cardIndex, effectIndex: effectIndex, triggerEvent: triggerEvent });
+            }
+        }
+        return pendingEffects;
+    };
+    TriggerEffectsRule.prototype.getPlayersByEffectPriorityOrder = function () {
+        var _a, _b;
+        var firstPlayer = (_b = (_a = this.game.rule) === null || _a === void 0 ? void 0 : _a.player) !== null && _b !== void 0 ? _b : this.material(MaterialType_1.MaterialType.FirstPlayerToken).getItem().location.player;
+        var index = this.game.players.indexOf(firstPlayer);
+        return this.game.players.slice(index).concat(this.game.players.slice(0, index));
+    };
+    return TriggerEffectsRule;
+}(rules_api_1.MaterialRulesPart));
+exports.TriggerEffectsRule = TriggerEffectsRule;

package/dist/rules/effects/VetalaEffectRule.d.ts

@@ -0,0 +1,11 @@
+import { MaterialItem, MaterialMove } from '@gamepark/rules-api';
+import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
+import { RuleId } from '../RuleId';
+export declare class VetalaEffectRule extends MoveEffectRule {
+    ruleId: RuleId;
+    onRuleStart(): MaterialMove[];
+    getPlayerMoves(): MaterialMove<number, number, number, number>[];
+    getAvailableDestinations(card: MaterialItem, cardIndex: number): import("@gamepark/rules-api").XYCoordinates[];
+    onCardMoved(): MaterialMove[];
+    onRuleEnd(): never[];
+}

package/dist/rules/effects/VetalaEffectRule.js

@@ -0,0 +1,59 @@
+"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.VetalaEffectRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var CustomMoveType_1 = require("../../CustomMoveType");
+var MoveEffectRule_1 = require("../../material/entity/MoveEffectRule");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var Memory_1 = require("../../Memory");
+var RuleId_1 = require("../RuleId");
+var VetalaEffectRule = (function (_super) {
+    __extends(VetalaEffectRule, _super);
+    function VetalaEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.VetalaEffect;
+        return _this;
+    }
+    VetalaEffectRule.prototype.onRuleStart = function () {
+        var entitiesSacrificed = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.PlayerDiscard).player(this.player).length;
+        if (entitiesSacrificed) {
+            this.memorize(Memory_1.Memory.VetalaCount, entitiesSacrificed);
+            return [];
+        }
+        else {
+            return this.endEffect();
+        }
+    };
+    VetalaEffectRule.prototype.getPlayerMoves = function () {
+        return _super.prototype.getPlayerMoves.call(this).concat(this.customMove(CustomMoveType_1.CustomMoveType.EndEffect));
+    };
+    VetalaEffectRule.prototype.getAvailableDestinations = function (card, cardIndex) {
+        return _super.prototype.getAvailableDestinations.call(this, card, cardIndex).filter(function (space) { return (0, rules_api_1.areAdjacentSquares)(card.location, space); });
+    };
+    VetalaEffectRule.prototype.onCardMoved = function () {
+        var count = this.memorize(Memory_1.Memory.VetalaCount, function (count) { return count - 1; });
+        return count > 0 ? [] : this.endEffect();
+    };
+    VetalaEffectRule.prototype.onRuleEnd = function () {
+        this.forget(Memory_1.Memory.VetalaCount);
+        return [];
+    };
+    return VetalaEffectRule;
+}(MoveEffectRule_1.MoveEffectRule));
+exports.VetalaEffectRule = VetalaEffectRule;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@gamepark/mythologies",
+  "version": "0.1.0",
+  "description": "The rules of Mythologies adapted for Game Park",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "author": "Romain Fromi <romain@game-park.com> (https://game-park.com/)",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "tsc",
+    "publish": "lerna publish",
+    "lint": "eslint --fix"
+  },
+  "peerDependencies": {
+    "@gamepark/rules-api": ">=6.36.7",
+    "lodash": ">=4.17"
+  },
+  "devDependencies": {
+    "@gamepark/rules-api": "~6.36.7",
+    "@types/lodash": "^4.17.7",
+    "i18next": "^22.0.3",
+    "lodash": "^4.17.21"
+  },
+  "gitHead": "58603385bd3898b027d4ad792b8740ad85575519"
+}