@gamepark/mythologies 0.1.0

package/dist/rules/effects/GarudaEffectRule.js

@@ -0,0 +1,84 @@
+"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.GarudaEffectRule = void 0;
+var Entity_1 = require("../../material/Entity");
+var SacrificeEffectRule_1 = require("../../material/entity/SacrificeEffectRule");
+var Pantheon_1 = require("../../material/Pantheon");
+var Memory_1 = require("../../Memory");
+var RuleId_1 = require("../RuleId");
+var GarudaEffectRule = (function (_super) {
+    __extends(GarudaEffectRule, _super);
+    function GarudaEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.GarudaEffect;
+        return _this;
+    }
+    GarudaEffectRule.prototype.onRuleStart = function () {
+        var count = this.getCardsToSacrifice().length;
+        if (!count)
+            return this.endEffect();
+        this.memorize(Memory_1.Memory.GarudaSacrificeCount, count);
+        var moves = [new Pantheon_1.Pantheon(this.game, this.player).gainGems(count)];
+        var playerMoves = this.getPlayerMoves();
+        if (playerMoves.length === count) {
+            moves.push.apply(moves, __spreadArray([], __read(playerMoves), false));
+        }
+        return moves;
+    };
+    GarudaEffectRule.prototype.getCardsToSacrifice = function () {
+        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
+        return pantheon.visibleEntities.id(function (id) { return (0, Entity_1.isCreature)(id.front); }).location(function (l) { return l.y === 1; });
+    };
+    GarudaEffectRule.prototype.onSacrifice = function () {
+        var sacrificeLeft = this.memorize(Memory_1.Memory.GarudaSacrificeCount, function (count) { return count - 1; });
+        if (sacrificeLeft) {
+            return [];
+        }
+        else {
+            this.forget(Memory_1.Memory.GarudaSacrificeCount);
+            return this.endEffect();
+        }
+    };
+    return GarudaEffectRule;
+}(SacrificeEffectRule_1.SacrificeEffectRule));
+exports.GarudaEffectRule = GarudaEffectRule;

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

@@ -0,0 +1,11 @@
+import { InvokeEffectRule } from '../../material/entity/PlaceCardEffectRule';
+import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
+import { RuleId } from '../RuleId';
+export declare class GorgonEffectRule extends SacrificeEffectRule {
+    ruleId: RuleId;
+    getCardsToSacrifice(): import("@gamepark/rules-api").Material<number, number, number>;
+    onSacrifice(): import("@gamepark/rules-api").MaterialMove<number, number, number, number>[];
+}
+export declare class CobraInvokeEffect extends InvokeEffectRule {
+    getCardsToPlace(): import("@gamepark/rules-api").Material<number, number, number>;
+}

package/dist/rules/effects/GorgonEffectRule.js

@@ -0,0 +1,78 @@
+"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.CobraInvokeEffect = exports.GorgonEffectRule = void 0;
+var PlaceCardEffectRule_1 = require("../../material/entity/PlaceCardEffectRule");
+var SacrificeEffectRule_1 = require("../../material/entity/SacrificeEffectRule");
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var Pantheon_1 = require("../../material/Pantheon");
+var RuleId_1 = require("../RuleId");
+var GorgonEffectRule = (function (_super) {
+    __extends(GorgonEffectRule, _super);
+    function GorgonEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.GorgonEffect;
+        return _this;
+    }
+    GorgonEffectRule.prototype.getCardsToSacrifice = function () {
+        var _a = this.card.location, x = _a.x, y = _a.y;
+        return _super.prototype.getCardsToSacrifice.call(this).location(function (l) { return l.x === x && l.y === y + 1; });
+    };
+    GorgonEffectRule.prototype.onSacrifice = function () {
+        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
+        return __spreadArray([pantheon.gainGems(2)], __read(this.endEffect()), false);
+    };
+    return GorgonEffectRule;
+}(SacrificeEffectRule_1.SacrificeEffectRule));
+exports.GorgonEffectRule = GorgonEffectRule;
+var CobraInvokeEffect = (function (_super) {
+    __extends(CobraInvokeEffect, _super);
+    function CobraInvokeEffect() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CobraInvokeEffect.prototype.getCardsToPlace = function () {
+        return this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.CreaturesDeck).rotation(true);
+    };
+    return CobraInvokeEffect;
+}(PlaceCardEffectRule_1.InvokeEffectRule));
+exports.CobraInvokeEffect = CobraInvokeEffect;

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

@@ -0,0 +1,9 @@
+import { Material, MaterialMove } from '@gamepark/rules-api';
+import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
+import { RuleId } from '../RuleId';
+export declare class GriffinEffectRule extends MoveEffectRule {
+    ruleId: RuleId;
+    canPlayEffect(cardIndex: number): boolean;
+    onRuleStart(): MaterialMove[];
+    getMovingCards(effectCardIndex: number): Material;
+}

package/dist/rules/effects/GriffinEffectRule.js

@@ -0,0 +1,41 @@
+"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.GriffinEffectRule = void 0;
+var MoveEffectRule_1 = require("../../material/entity/MoveEffectRule");
+var Pantheon_1 = require("../../material/Pantheon");
+var RuleId_1 = require("../RuleId");
+var GriffinEffectRule = (function (_super) {
+    __extends(GriffinEffectRule, _super);
+    function GriffinEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.GriffinEffect;
+        return _this;
+    }
+    GriffinEffectRule.prototype.canPlayEffect = function (cardIndex) {
+        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
+        return pantheon.gems > 0 && _super.prototype.canPlayEffect.call(this, cardIndex);
+    };
+    GriffinEffectRule.prototype.onRuleStart = function () {
+        return [new Pantheon_1.Pantheon(this.game, this.player).spendGems(1)];
+    };
+    GriffinEffectRule.prototype.getMovingCards = function (effectCardIndex) {
+        return _super.prototype.getMovingCards.call(this, effectCardIndex).location(function (l) { return l.y === 0; });
+    };
+    return GriffinEffectRule;
+}(MoveEffectRule_1.MoveEffectRule));
+exports.GriffinEffectRule = GriffinEffectRule;

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

@@ -0,0 +1,5 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { SimultaneousMoveEffectRule } from '../../material/entity/SimultaneousMoveEffectRule';
+export declare class HadesEffectRule extends SimultaneousMoveEffectRule {
+    playEffect(): MaterialMove[];
+}

package/dist/rules/effects/HadesEffectRule.js

@@ -0,0 +1,87 @@
+"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 __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.HadesEffectRule = void 0;
+var Entity_1 = require("../../material/Entity");
+var SimultaneousMoveEffectRule_1 = require("../../material/entity/SimultaneousMoveEffectRule");
+var Pantheon_1 = require("../../material/Pantheon");
+var HadesEffectRule = (function (_super) {
+    __extends(HadesEffectRule, _super);
+    function HadesEffectRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    HadesEffectRule.prototype.playEffect = function () {
+        var e_1, _a, e_2, _b;
+        var moves = [];
+        try {
+            for (var _c = __values(this.game.players), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var player = _d.value;
+                var pantheon = new Pantheon_1.Pantheon(this.game, player);
+                var entities = pantheon.visibleEntities;
+                try {
+                    for (var _e = (e_2 = void 0, __values(entities.getIndexes())), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var index = _f.value;
+                        var entity = entities.getItem(index);
+                        var _g = entity.location, x = _g.x, y = _g.y;
+                        if (y !== 2 && !(0, Entity_1.isGod)(entity.id.front) && pantheon.isFreeSpace({ x: x, y: y + 1 })) {
+                            moves.push(entities.index(index).moveItem(__assign(__assign({}, entity.location), { y: y + 1 })));
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return moves;
+    };
+    return HadesEffectRule;
+}(SimultaneousMoveEffectRule_1.SimultaneousMoveEffectRule));
+exports.HadesEffectRule = HadesEffectRule;

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

@@ -0,0 +1,12 @@
+import { ItemMove, MaterialMove } from '@gamepark/rules-api';
+import { PlayerEffectRule } from '../../material/entity/Effect';
+import { PlaceCardEffectRule } from '../../material/entity/PlaceCardEffectRule';
+import { RuleId } from '../RuleId';
+export declare class KinnaraEffectRule extends PlayerEffectRule {
+    ruleId: RuleId;
+    getPlayerMoves(): MaterialMove<number, number, number, number>[];
+    afterItemMove(move: ItemMove): import("@gamepark/rules-api").StartRule<RuleId.KinnaraPlaceEffect>[];
+}
+export declare class KinnaraPlaceEffectRule extends PlaceCardEffectRule {
+    getCardsToPlace(): import("@gamepark/rules-api").Material<number, number, number>;
+}

package/dist/rules/effects/KinnaraEffectRule.js

@@ -0,0 +1,84 @@
+"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.KinnaraPlaceEffectRule = exports.KinnaraEffectRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Effect_1 = require("../../material/entity/Effect");
+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 KinnaraEffectRule = (function (_super) {
+    __extends(KinnaraEffectRule, _super);
+    function KinnaraEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.KinnaraEffect;
+        return _this;
+    }
+    KinnaraEffectRule.prototype.getPlayerMoves = function () {
+        var e_1, _a;
+        var moves = [];
+        var mythologies = new Pantheon_1.Pantheon(this.game, this.player).missingMythologies;
+        var creaturesDecks = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.CreaturesDeck);
+        var godsDecks = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.GodsDeck);
+        try {
+            for (var mythologies_1 = __values(mythologies), mythologies_1_1 = mythologies_1.next(); !mythologies_1_1.done; mythologies_1_1 = mythologies_1.next()) {
+                var mythology = mythologies_1_1.value;
+                moves.push(creaturesDecks.locationId(mythology).deck().moveItem({ type: LocationType_1.LocationType.PlayerBufferArea, player: this.player }), godsDecks.locationId(mythology).deck().moveItem({ type: LocationType_1.LocationType.PlayerBufferArea, player: this.player }));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (mythologies_1_1 && !mythologies_1_1.done && (_a = mythologies_1.return)) _a.call(mythologies_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return moves;
+    };
+    KinnaraEffectRule.prototype.afterItemMove = function (move) {
+        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.EntityCard)(move) && move.location.type === LocationType_1.LocationType.PlayerBufferArea) {
+            return [this.startRule(RuleId_1.RuleId.KinnaraPlaceEffect)];
+        }
+        return [];
+    };
+    return KinnaraEffectRule;
+}(Effect_1.PlayerEffectRule));
+exports.KinnaraEffectRule = KinnaraEffectRule;
+var KinnaraPlaceEffectRule = (function (_super) {
+    __extends(KinnaraPlaceEffectRule, _super);
+    function KinnaraPlaceEffectRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    KinnaraPlaceEffectRule.prototype.getCardsToPlace = function () {
+        return this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.PlayerBufferArea).player(this.player);
+    };
+    return KinnaraPlaceEffectRule;
+}(PlaceCardEffectRule_1.PlaceCardEffectRule));
+exports.KinnaraPlaceEffectRule = KinnaraPlaceEffectRule;

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

@@ -0,0 +1,9 @@
+import { Location, XYCoordinates } from '@gamepark/rules-api';
+import { SimultaneousMoveEffectRule } from '../../material/entity/SimultaneousMoveEffectRule';
+import { PlayerColor } from '../../PlayerColor';
+import { RuleId } from '../RuleId';
+export declare class MinotaurEffectRule extends SimultaneousMoveEffectRule {
+    ruleId: RuleId;
+    getMovingCards(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
+    isLegalDestination(space: XYCoordinates, cardLocation: Location): boolean;
+}

package/dist/rules/effects/MinotaurEffectRule.js

@@ -0,0 +1,39 @@
+"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.MinotaurEffectRule = void 0;
+var Entity_1 = require("../../material/Entity");
+var SimultaneousMoveEffectRule_1 = require("../../material/entity/SimultaneousMoveEffectRule");
+var Pantheon_1 = require("../../material/Pantheon");
+var RuleId_1 = require("../RuleId");
+var MinotaurEffectRule = (function (_super) {
+    __extends(MinotaurEffectRule, _super);
+    function MinotaurEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.MinotaurEffect;
+        return _this;
+    }
+    MinotaurEffectRule.prototype.getMovingCards = function (player) {
+        var column = this.getEffect().triggerEvent.location.x;
+        return new Pantheon_1.Pantheon(this.game, player).visibleEntities.location(function (l) { return l.x === column; }).id(function (id) { return (0, Entity_1.isCreature)(id.front); });
+    };
+    MinotaurEffectRule.prototype.isLegalDestination = function (space, cardLocation) {
+        return space.y === cardLocation.y;
+    };
+    return MinotaurEffectRule;
+}(SimultaneousMoveEffectRule_1.SimultaneousMoveEffectRule));
+exports.MinotaurEffectRule = MinotaurEffectRule;

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

@@ -0,0 +1,11 @@
+import { CustomMove, MaterialItem, PlayerTurnRule } from '@gamepark/rules-api';
+import { EntityId } from '../../material/Entity';
+import { LocationType } from '../../material/LocationType';
+import { MaterialType } from '../../material/MaterialType';
+import { PlayerColor } from '../../PlayerColor';
+import { RuleId } from '../RuleId';
+export declare class OdinEffectRule extends PlayerTurnRule {
+    getPlayerMoves(): CustomMove<number>[];
+    onCustomMove(move: CustomMove): import("@gamepark/rules-api").StartRule<RuleId.DrawDestinyCard>[];
+    isCardRestricted(card: MaterialItem<MaterialType, LocationType, EntityId>, player?: PlayerColor): boolean;
+}

package/dist/rules/effects/OdinEffectRule.js

@@ -0,0 +1,52 @@
+"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.OdinEffectRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var CustomMoveType_1 = require("../../CustomMoveType");
+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 OdinEffectRule = (function (_super) {
+    __extends(OdinEffectRule, _super);
+    function OdinEffectRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    OdinEffectRule.prototype.getPlayerMoves = function () {
+        var _this = this;
+        return this.material(MaterialType_1.MaterialType.MythologyBoard)
+            .getItems()
+            .map(function (item) { return _this.customMove(CustomMoveType_1.CustomMoveType.ChooseMythology, item.id.mythology); });
+    };
+    OdinEffectRule.prototype.onCustomMove = function (move) {
+        if (move.type === CustomMoveType_1.CustomMoveType.ChooseMythology) {
+            this.memorize(Memory_1.Memory.OdinTargetMythology, move.data);
+            return [this.startRule(RuleId_1.RuleId.DrawDestinyCard)];
+        }
+        return [];
+    };
+    OdinEffectRule.prototype.isCardRestricted = function (card, player) {
+        return ((card.location.type === LocationType_1.LocationType.SanctuaryCreatureSpot || card.location.type === LocationType_1.LocationType.SanctuaryGodSpot) &&
+            (0, Entity_1.entityMythology)(card.id.front) === this.remind(Memory_1.Memory.OdinTargetMythology) &&
+            (!player || !new Pantheon_1.Pantheon(this.game, player).hasEntity(Entity_1.Entity.Odin)));
+    };
+    return OdinEffectRule;
+}(rules_api_1.PlayerTurnRule));
+exports.OdinEffectRule = OdinEffectRule;

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

@@ -0,0 +1,5 @@
+import { MaterialMove } from '@gamepark/rules-api';
+import { SimultaneousMoveEffectRule } from '../../material/entity/SimultaneousMoveEffectRule';
+export declare class RaEffectRule extends SimultaneousMoveEffectRule {
+    playEffect(): MaterialMove[];
+}

package/dist/rules/effects/RaEffectRule.js

@@ -0,0 +1,87 @@
+"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 __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.RaEffectRule = void 0;
+var Entity_1 = require("../../material/Entity");
+var SimultaneousMoveEffectRule_1 = require("../../material/entity/SimultaneousMoveEffectRule");
+var Pantheon_1 = require("../../material/Pantheon");
+var RaEffectRule = (function (_super) {
+    __extends(RaEffectRule, _super);
+    function RaEffectRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    RaEffectRule.prototype.playEffect = function () {
+        var e_1, _a, e_2, _b;
+        var moves = [];
+        try {
+            for (var _c = __values(this.game.players), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var player = _d.value;
+                var pantheon = new Pantheon_1.Pantheon(this.game, player);
+                var entities = pantheon.visibleEntities;
+                try {
+                    for (var _e = (e_2 = void 0, __values(entities.getIndexes())), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var index = _f.value;
+                        var entity = entities.getItem(index);
+                        var _g = entity.location, x = _g.x, y = _g.y;
+                        if (y !== 0 && !(0, Entity_1.isGod)(entity.id.front) && pantheon.isFreeSpace({ x: x, y: y - 1 })) {
+                            moves.push(entities.index(index).moveItem(__assign(__assign({}, entity.location), { y: y - 1 })));
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return moves;
+    };
+    return RaEffectRule;
+}(SimultaneousMoveEffectRule_1.SimultaneousMoveEffectRule));
+exports.RaEffectRule = RaEffectRule;

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

@@ -0,0 +1,13 @@
+import { MaterialMove, XYCoordinates } from '@gamepark/rules-api';
+import { PlaceCardEffectRule } from '../../material/entity/PlaceCardEffectRule';
+import { PlayerColor } from '../../PlayerColor';
+import { RuleId } from '../RuleId';
+export declare class RakshasaEffectRule extends PlaceCardEffectRule {
+    ruleId: RuleId;
+    canPlayEffect(cardIndex: number): boolean;
+    onRuleStart(): MaterialMove[];
+    getCardsToPlace(): import("@gamepark/rules-api").Material<number, number, number>;
+    getAvailableDestinations(cardIndex: number): (XYCoordinates & {
+        player: PlayerColor;
+    })[];
+}