@gamepark/mythologies 0.1.0

package/dist/rules/PlaceTokenRule.js

@@ -0,0 +1,139 @@
+"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.PlaceTokenRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Destiny_1 = require("../material/Destiny");
+var Entity_1 = require("../material/Entity");
+var LocationType_1 = require("../material/LocationType");
+var MaterialType_1 = require("../material/MaterialType");
+var Pantheon_1 = require("../material/Pantheon");
+var Memory_1 = require("../Memory");
+var RuleId_1 = require("./RuleId");
+var PlaceTokenRule = (function (_super) {
+    __extends(PlaceTokenRule, _super);
+    function PlaceTokenRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PlaceTokenRule.prototype.onRuleStart = function () {
+        var e_1, _a;
+        var moves = [];
+        try {
+            for (var _b = __values(this.activePlayers), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var player = _c.value;
+                var legalMoves = this.getActivePlayerLegalMoves(player);
+                if (legalMoves.length === 1) {
+                    moves.push(legalMoves[0]);
+                }
+            }
+        }
+        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; }
+        }
+        return moves;
+    };
+    PlaceTokenRule.prototype.getActivePlayerLegalMoves = function (player) {
+        var token = this.material(MaterialType_1.MaterialType.DraftToken)
+            .id(function (id) { return id.back === player; })
+            .location(LocationType_1.LocationType.PlayedTokenSpot);
+        if (!token.length)
+            return [];
+        return this.getAvailableCards(player).map(function (parent) { return token.moveItem({ type: LocationType_1.LocationType.OnEntityCard, parent: parent }); });
+    };
+    PlaceTokenRule.prototype.getAvailableCards = function (player) {
+        var destiny = new Destiny_1.Destiny(this.game);
+        var mythology = destiny.getMythology(player);
+        if (this.remind(Memory_1.Memory.OdinTargetMythology) === mythology && !new Pantheon_1.Pantheon(this.game, player).hasEntity(Entity_1.Entity.Odin)) {
+            return [this.getTopDeckCreature(mythology)];
+        }
+        var entities = destiny.getAvailableEntities(player);
+        if (!entities.getItems().some(function (item) { return (0, Entity_1.isCreature)(item.id.front); })) {
+            return entities.getIndexes().concat(this.getTopDeckCreature(mythology));
+        }
+        return entities.getIndexes();
+    };
+    PlaceTokenRule.prototype.getTopDeckCreature = function (mythology) {
+        return this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.CreaturesDeck).locationId(mythology).deck().getIndex();
+    };
+    PlaceTokenRule.prototype.afterItemMove = function (move) {
+        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.DraftToken)(move)) {
+            var player = this.material(MaterialType_1.MaterialType.DraftToken).getItem(move.itemIndex).id.back;
+            this.memorize(Memory_1.Memory.KeepTokenPlaceSecret, true, player);
+            return [this.endPlayerTurn(player)];
+        }
+        return [];
+    };
+    PlaceTokenRule.prototype.getMovesAfterPlayersDone = function () {
+        var tokensPlaced = this.material(MaterialType_1.MaterialType.DraftToken).location(LocationType_1.LocationType.OnEntityCard);
+        if (tokensPlaced.length < this.game.players.length * 2) {
+            return [this.startRule(RuleId_1.RuleId.DrawDestinyCard)];
+        }
+        else {
+            var cardsSelected = tokensPlaced.getItems().map(function (item) { return item.location.parent; });
+            var cardsToReveal = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.CreaturesDeck).index(cardsSelected);
+            return __spreadArray(__spreadArray([], __read(cardsToReveal.rotateItems(true)), false), [
+                this.startPlayerTurn(RuleId_1.RuleId.PlaceCards, this.material(MaterialType_1.MaterialType.FirstPlayerToken).getItem().location.player)
+            ], false);
+        }
+    };
+    PlaceTokenRule.prototype.onRuleEnd = function () {
+        this.forget(Memory_1.Memory.KeepTokenPlaceSecret);
+        return [];
+    };
+    return PlaceTokenRule;
+}(rules_api_1.SimultaneousRule));
+exports.PlaceTokenRule = PlaceTokenRule;

package/dist/rules/RuleId.d.ts

@@ -0,0 +1,36 @@
+export declare enum RuleId {
+    DrawDestinyCard = 1,
+    ChooseDraftToken = 2,
+    PlaceToken = 3,
+    PlaceCards = 4,
+    Upkeep = 5,
+    EndGame = 6,
+    ResolveEffects = 10,
+    AthenaEffect = 11,
+    HadesEffect = 12,
+    MinotaurEffect = 13,
+    CentaurEffect = 14,
+    CentaurEffectSacrifice = 15,
+    GorgonEffect = 16,
+    CyclopsEffect = 17,
+    GriffinEffect = 18,
+    ChimeraEffect = 19,
+    OdinEffect = 20,
+    ThorEffect = 21,
+    DraugrEffect = 22,
+    FenrirChoice = 23,
+    FenrirEffect = 24,
+    AlfEffect = 25,
+    AnubisEffect = 26,
+    SphinxEffect = 27,
+    CobraEffect = 28,
+    CobraInvokeEffect = 29,
+    BabaiEffect = 30,
+    BennuEffect = 31,
+    ShivaEffect = 32,
+    RakshasaEffect = 33,
+    GarudaEffect = 34,
+    VetalaEffect = 35,
+    KinnaraEffect = 36,
+    KinnaraPlaceEffect = 37
+}

package/dist/rules/RuleId.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleId = void 0;
+var RuleId;
+(function (RuleId) {
+    RuleId[RuleId["DrawDestinyCard"] = 1] = "DrawDestinyCard";
+    RuleId[RuleId["ChooseDraftToken"] = 2] = "ChooseDraftToken";
+    RuleId[RuleId["PlaceToken"] = 3] = "PlaceToken";
+    RuleId[RuleId["PlaceCards"] = 4] = "PlaceCards";
+    RuleId[RuleId["Upkeep"] = 5] = "Upkeep";
+    RuleId[RuleId["EndGame"] = 6] = "EndGame";
+    RuleId[RuleId["ResolveEffects"] = 10] = "ResolveEffects";
+    RuleId[RuleId["AthenaEffect"] = 11] = "AthenaEffect";
+    RuleId[RuleId["HadesEffect"] = 12] = "HadesEffect";
+    RuleId[RuleId["MinotaurEffect"] = 13] = "MinotaurEffect";
+    RuleId[RuleId["CentaurEffect"] = 14] = "CentaurEffect";
+    RuleId[RuleId["CentaurEffectSacrifice"] = 15] = "CentaurEffectSacrifice";
+    RuleId[RuleId["GorgonEffect"] = 16] = "GorgonEffect";
+    RuleId[RuleId["CyclopsEffect"] = 17] = "CyclopsEffect";
+    RuleId[RuleId["GriffinEffect"] = 18] = "GriffinEffect";
+    RuleId[RuleId["ChimeraEffect"] = 19] = "ChimeraEffect";
+    RuleId[RuleId["OdinEffect"] = 20] = "OdinEffect";
+    RuleId[RuleId["ThorEffect"] = 21] = "ThorEffect";
+    RuleId[RuleId["DraugrEffect"] = 22] = "DraugrEffect";
+    RuleId[RuleId["FenrirChoice"] = 23] = "FenrirChoice";
+    RuleId[RuleId["FenrirEffect"] = 24] = "FenrirEffect";
+    RuleId[RuleId["AlfEffect"] = 25] = "AlfEffect";
+    RuleId[RuleId["AnubisEffect"] = 26] = "AnubisEffect";
+    RuleId[RuleId["SphinxEffect"] = 27] = "SphinxEffect";
+    RuleId[RuleId["CobraEffect"] = 28] = "CobraEffect";
+    RuleId[RuleId["CobraInvokeEffect"] = 29] = "CobraInvokeEffect";
+    RuleId[RuleId["BabaiEffect"] = 30] = "BabaiEffect";
+    RuleId[RuleId["BennuEffect"] = 31] = "BennuEffect";
+    RuleId[RuleId["ShivaEffect"] = 32] = "ShivaEffect";
+    RuleId[RuleId["RakshasaEffect"] = 33] = "RakshasaEffect";
+    RuleId[RuleId["GarudaEffect"] = 34] = "GarudaEffect";
+    RuleId[RuleId["VetalaEffect"] = 35] = "VetalaEffect";
+    RuleId[RuleId["KinnaraEffect"] = 36] = "KinnaraEffect";
+    RuleId[RuleId["KinnaraPlaceEffect"] = 37] = "KinnaraPlaceEffect";
+})(RuleId = exports.RuleId || (exports.RuleId = {}));

package/dist/rules/UpkeepRule.d.ts

@@ -0,0 +1,9 @@
+import { ItemMove, MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
+import { PlayerColor } from '../PlayerColor';
+import { RuleId } from './RuleId';
+export declare class UpkeepRule extends PlayerTurnRule {
+    onRuleStart(): MaterialMove<number, number, number, number>[];
+    completeSanctuary(loki?: PlayerColor): MaterialMove<number, number, number, number>[];
+    afterItemMove(move: ItemMove): import("@gamepark/rules-api").Shuffle<number>[];
+    get nextRule(): import("@gamepark/rules-api").StartPlayerTurn<number, RuleId.OdinEffect> | import("@gamepark/rules-api").StartRule<RuleId.DrawDestinyCard>;
+}

package/dist/rules/UpkeepRule.js

@@ -0,0 +1,140 @@
+"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 __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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));
+};
+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.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpkeepRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Entity_1 = require("../material/Entity");
+var LocationType_1 = require("../material/LocationType");
+var MaterialType_1 = require("../material/MaterialType");
+var Pantheon_1 = require("../material/Pantheon");
+var Memory_1 = require("../Memory");
+var RuleId_1 = require("./RuleId");
+var UpkeepRule = (function (_super) {
+    __extends(UpkeepRule, _super);
+    function UpkeepRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UpkeepRule.prototype.onRuleStart = function () {
+        this.forget(Memory_1.Memory.OncePerTurn);
+        var moves = [
+            this.material(MaterialType_1.MaterialType.RoundToken).moveItem(function (item) { return (__assign(__assign({}, item.location), { id: item.location.id + 1 })); }),
+            this.material(MaterialType_1.MaterialType.FirstPlayerToken).moveItem({ type: LocationType_1.LocationType.FirstPlayerTokenSpot, player: this.nextPlayer })
+        ];
+        moves.push.apply(moves, __spreadArray([], __read(this.completeSanctuary()), false));
+        moves.push(this.material(MaterialType_1.MaterialType.DestinyCard).location(LocationType_1.LocationType.CurrentDestiny).moveItemsAtOnce({ type: LocationType_1.LocationType.DestinyDeck }));
+        moves.push(this.nextRule);
+        return moves;
+    };
+    UpkeepRule.prototype.completeSanctuary = function (loki) {
+        var e_1, _a;
+        var moves = [];
+        var mythologyBoards = this.material(MaterialType_1.MaterialType.MythologyBoard);
+        try {
+            for (var _b = __values(mythologyBoards.getIndexes()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var index = _c.value;
+                var mythology = mythologyBoards.getItem(index).id.mythology;
+                var godOnBoard = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.SanctuaryGodSpot).parent(index).length;
+                if (!godOnBoard) {
+                    var deck = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.GodsDeck).locationId(mythology).deck();
+                    moves.push(deck.dealOne({ type: LocationType_1.LocationType.SanctuaryGodSpot, parent: index, rotation: loki }));
+                }
+                var creaturesOnBoard = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.SanctuaryCreatureSpot).parent(index).length;
+                if (creaturesOnBoard < 3) {
+                    var deck = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.CreaturesDeck).locationId(mythology).deck();
+                    moves.push.apply(moves, __spreadArray([], __read(deck.deal({ type: LocationType_1.LocationType.SanctuaryCreatureSpot, parent: index, rotation: loki }, 3 - creaturesOnBoard)), 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; }
+        }
+        return moves;
+    };
+    UpkeepRule.prototype.afterItemMove = function (move) {
+        if ((0, rules_api_1.isMoveItemTypeAtOnce)(MaterialType_1.MaterialType.DestinyCard)(move)) {
+            return [this.material(MaterialType_1.MaterialType.DestinyCard).shuffle()];
+        }
+        return [];
+    };
+    Object.defineProperty(UpkeepRule.prototype, "nextRule", {
+        get: function () {
+            var _this = this;
+            var odinOwner = this.game.players.find(function (player) { return new Pantheon_1.Pantheon(_this.game, player).hasEntity(Entity_1.Entity.Odin); });
+            if (odinOwner) {
+                return this.startPlayerTurn(RuleId_1.RuleId.OdinEffect, odinOwner);
+            }
+            else {
+                return this.startRule(RuleId_1.RuleId.DrawDestinyCard);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return UpkeepRule;
+}(rules_api_1.PlayerTurnRule));
+exports.UpkeepRule = UpkeepRule;

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

@@ -0,0 +1,10 @@
+import { Material, XYCoordinates } from '@gamepark/rules-api';
+import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
+import { RuleId } from '../RuleId';
+export declare class AlfEffectRule extends MoveEffectRule {
+    ruleId: RuleId;
+    canPlayEffect(cardIndex: number): boolean;
+    getMovingCards(alfIndex?: number): Material;
+    getAvailableDestinations(): XYCoordinates[];
+    getFreeDiagonals(alfIndex?: number): XYCoordinates[];
+}

package/dist/rules/effects/AlfEffectRule.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.AlfEffectRule = void 0;
+var Entity_1 = require("../../material/Entity");
+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 AlfEffectRule = (function (_super) {
+    __extends(AlfEffectRule, _super);
+    function AlfEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.AlfEffect;
+        return _this;
+    }
+    AlfEffectRule.prototype.canPlayEffect = function (cardIndex) {
+        return this.getCardsAbleToMove(cardIndex).length > 0 && this.getFreeDiagonals(cardIndex).length > 0;
+    };
+    AlfEffectRule.prototype.getMovingCards = function (alfIndex) {
+        if (alfIndex === void 0) { alfIndex = this.getEffect().cardIndex; }
+        return _super.prototype.getMovingCards.call(this, alfIndex)
+            .id(function (id) { return (0, Entity_1.isCreature)(id.front); })
+            .index(function (index) { return index !== alfIndex; });
+    };
+    AlfEffectRule.prototype.getAvailableDestinations = function () {
+        return this.getFreeDiagonals();
+    };
+    AlfEffectRule.prototype.getFreeDiagonals = function (alfIndex) {
+        if (alfIndex === void 0) { alfIndex = this.getEffect().cardIndex; }
+        var freeDiagonals = [];
+        var grid = new Pantheon_1.Pantheon(this.game, this.player).grid;
+        var alf = this.material(MaterialType_1.MaterialType.EntityCard).getItem(alfIndex).location;
+        for (var y = 0; y < 3; y++) {
+            for (var x = 0; x < 3; x++) {
+                if (!grid[y][x] && Math.abs(alf.x - x) === 1 && Math.abs(alf.y - y) === 1) {
+                    freeDiagonals.push({ x: x, y: y });
+                }
+            }
+        }
+        return freeDiagonals;
+    };
+    return AlfEffectRule;
+}(MoveEffectRule_1.MoveEffectRule));
+exports.AlfEffectRule = AlfEffectRule;

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

@@ -0,0 +1,9 @@
+import { Material } from '@gamepark/rules-api';
+import { InvokeEffectRule } from '../../material/entity/PlaceCardEffectRule';
+import { RuleId } from '../RuleId';
+export declare class AnubisEffectRule extends InvokeEffectRule {
+    ruleId: RuleId;
+    onRuleStart(): import("@gamepark/rules-api").MaterialMove<number, number, number, number>[];
+    getCardsToPlace(): Material;
+    getAvailableDestinations(): import("@gamepark/rules-api").XYCoordinates[];
+}

package/dist/rules/effects/AnubisEffectRule.js

@@ -0,0 +1,49 @@
+"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.AnubisEffectRule = void 0;
+var PlaceCardEffectRule_1 = require("../../material/entity/PlaceCardEffectRule");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var Memory_1 = require("../../Memory");
+var RuleId_1 = require("../RuleId");
+var AnubisEffectRule = (function (_super) {
+    __extends(AnubisEffectRule, _super);
+    function AnubisEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.AnubisEffect;
+        return _this;
+    }
+    AnubisEffectRule.prototype.onRuleStart = function () {
+        if (!this.remind(Memory_1.Memory.AnubisInvoke1)) {
+            this.remind(Memory_1.Memory.PendingEffects).unshift([this.getEffect()]);
+            this.memorize(Memory_1.Memory.AnubisInvoke1, true);
+        }
+        else {
+            this.forget(Memory_1.Memory.AnubisInvoke1);
+        }
+        return _super.prototype.onRuleStart.call(this);
+    };
+    AnubisEffectRule.prototype.getCardsToPlace = function () {
+        return this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.PlayerDiscard);
+    };
+    AnubisEffectRule.prototype.getAvailableDestinations = function () {
+        return _super.prototype.getAvailableDestinations.call(this).filter(function (space) { return space.y === 2; });
+    };
+    return AnubisEffectRule;
+}(PlaceCardEffectRule_1.InvokeEffectRule));
+exports.AnubisEffectRule = AnubisEffectRule;

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

@@ -0,0 +1,9 @@
+import { CustomMove, Material, MaterialMove } from '@gamepark/rules-api';
+import { PlayerEffectRule } from '../../material/entity/Effect';
+import { RuleId } from '../RuleId';
+export declare class AthenaEffectRule extends PlayerEffectRule {
+    ruleId: RuleId;
+    getPlayerMoves(): MaterialMove[];
+    getPiles(): Material<number, number, number>[];
+    onCustomMove(move: CustomMove): MaterialMove<number, number, number, number>[];
+}

package/dist/rules/effects/AthenaEffectRule.js

@@ -0,0 +1,104 @@
+"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.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AthenaEffectRule = void 0;
+var CustomMoveType_1 = require("../../CustomMoveType");
+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 AthenaEffectRule = (function (_super) {
+    __extends(AthenaEffectRule, _super);
+    function AthenaEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.AthenaEffect;
+        return _this;
+    }
+    AthenaEffectRule.prototype.getPlayerMoves = function () {
+        var e_1, _a, e_2, _b;
+        var moves = [];
+        var legalSpaces = new Pantheon_1.Pantheon(this.game, this.player).legalSpaces;
+        var piles = this.getPiles();
+        try {
+            for (var piles_1 = __values(piles), piles_1_1 = piles_1.next(); !piles_1_1.done; piles_1_1 = piles_1.next()) {
+                var pile = piles_1_1.value;
+                var location = pile.getItem().location;
+                try {
+                    for (var legalSpaces_1 = (e_2 = void 0, __values(legalSpaces)), legalSpaces_1_1 = legalSpaces_1.next(); !legalSpaces_1_1.done; legalSpaces_1_1 = legalSpaces_1.next()) {
+                        var _c = legalSpaces_1_1.value, x = _c.x, y = _c.y;
+                        if (x !== location.x || y !== location.y) {
+                            moves.push(pile.moveItemsAtOnce({ type: LocationType_1.LocationType.Pantheon, player: this.player, x: x, y: y }));
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (legalSpaces_1_1 && !legalSpaces_1_1.done && (_b = legalSpaces_1.return)) _b.call(legalSpaces_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                if (location.type !== LocationType_1.LocationType.PlayerBufferArea) {
+                    moves.push(pile.moveItemsAtOnce({ type: LocationType_1.LocationType.PlayerBufferArea, player: this.player }));
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (piles_1_1 && !piles_1_1.done && (_a = piles_1.return)) _a.call(piles_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        if (!piles.some(function (pile) { var _a; return ((_a = pile.getItem()) === null || _a === void 0 ? void 0 : _a.location.type) === LocationType_1.LocationType.PlayerBufferArea; })) {
+            moves.push(this.customMove(CustomMoveType_1.CustomMoveType.EndEffect));
+        }
+        return moves;
+    };
+    AthenaEffectRule.prototype.getPiles = function () {
+        var piles = new Pantheon_1.Pantheon(this.game, this.player).getPiles();
+        var bufferAreaPile = this.material(MaterialType_1.MaterialType.EntityCard)
+            .player(this.player)
+            .location(LocationType_1.LocationType.PlayerBufferArea)
+            .sort(function (item) { return item.location.z; });
+        if (bufferAreaPile.length > 0) {
+            piles.push(bufferAreaPile);
+        }
+        return piles;
+    };
+    AthenaEffectRule.prototype.onCustomMove = function (move) {
+        if (move.type === CustomMoveType_1.CustomMoveType.EndEffect) {
+            var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
+            return pantheon.gainBonus();
+        }
+        return [];
+    };
+    return AthenaEffectRule;
+}(Effect_1.PlayerEffectRule));
+exports.AthenaEffectRule = AthenaEffectRule;

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

@@ -0,0 +1,6 @@
+import { InvokeEffectRule } from '../../material/entity/PlaceCardEffectRule';
+import { RuleId } from '../RuleId';
+export declare class BabaiEffectRule extends InvokeEffectRule {
+    ruleId: RuleId;
+    getCardsToPlace(): import("@gamepark/rules-api").Material<number, number, number>;
+}

package/dist/rules/effects/BabaiEffectRule.js

@@ -0,0 +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.BabaiEffectRule = void 0;
+var Entity_1 = require("../../material/Entity");
+var PlaceCardEffectRule_1 = require("../../material/entity/PlaceCardEffectRule");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var Pantheon_1 = require("../../material/Pantheon");
+var RuleId_1 = require("../RuleId");
+var BabaiEffectRule = (function (_super) {
+    __extends(BabaiEffectRule, _super);
+    function BabaiEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.BabaiEffect;
+        return _this;
+    }
+    BabaiEffectRule.prototype.getCardsToPlace = function () {
+        var mythologies = new Pantheon_1.Pantheon(this.game, this.player).missingMythologies;
+        return this.material(MaterialType_1.MaterialType.EntityCard)
+            .location(LocationType_1.LocationType.PlayerDiscard)
+            .id(function (id) { return mythologies.includes((0, Entity_1.entityMythology)(id.front)); });
+    };
+    return BabaiEffectRule;
+}(PlaceCardEffectRule_1.InvokeEffectRule));
+exports.BabaiEffectRule = BabaiEffectRule;