@gamepark/mythologies 0.1.0 → 0.2.1

package/dist/rules/effects/IllapaEffectRule.js

@@ -0,0 +1,71 @@
+"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.IllapaSacrificeRule = exports.IllapaEffectRule = void 0;
+var lodash_1 = require("lodash");
+var CustomMoveType_1 = require("../../CustomMoveType");
+var Entity_1 = require("../../material/Entity");
+var Effect_1 = require("../../material/entity/Effect");
+var SimultaneousSacrificeEffectRule_1 = require("../../material/entity/SimultaneousSacrificeEffectRule");
+var Pantheon_1 = require("../../material/Pantheon");
+var Memory_1 = require("../../Memory");
+var RuleId_1 = require("../RuleId");
+var IllapaEffectRule = (function (_super) {
+    __extends(IllapaEffectRule, _super);
+    function IllapaEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.IllapaEffect;
+        return _this;
+    }
+    IllapaEffectRule.prototype.getPlayerMoves = function () {
+        var _this = this;
+        return (0, lodash_1.range)(0, 3).map(function (line) { return _this.customMove(CustomMoveType_1.CustomMoveType.ChooseLine, line); });
+    };
+    IllapaEffectRule.prototype.onCustomMove = function (move) {
+        if (move.type === CustomMoveType_1.CustomMoveType.ChooseLine) {
+            this.memorize(Memory_1.Memory.IllapaLine, move.data);
+            var players = this.getPlayersHavingToSacrifice(move.data);
+            if (players.length) {
+                return [this.startSimultaneousRule(RuleId_1.RuleId.IllapaSacrifice, players)];
+            }
+            else {
+                return _super.prototype.endEffect.call(this);
+            }
+        }
+        return [];
+    };
+    IllapaEffectRule.prototype.getPlayersHavingToSacrifice = function (line) {
+        var _this = this;
+        return this.game.players.filter(function (player) { return player !== _this.player && new Pantheon_1.Pantheon(_this.game, player).grid[line].filter(Entity_1.isCreature).length > 0; });
+    };
+    return IllapaEffectRule;
+}(Effect_1.PlayerEffectRule));
+exports.IllapaEffectRule = IllapaEffectRule;
+var IllapaSacrificeRule = (function (_super) {
+    __extends(IllapaSacrificeRule, _super);
+    function IllapaSacrificeRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    IllapaSacrificeRule.prototype.getCardsToSacrifice = function (player) {
+        var line = this.remind(Memory_1.Memory.IllapaLine);
+        return _super.prototype.getCardsToSacrifice.call(this, player)
+            .id(function (id) { return (0, Entity_1.isCreature)(id.front); })
+            .location(function (l) { return l.y === line; });
+    };
+    return IllapaSacrificeRule;
+}(SimultaneousSacrificeEffectRule_1.SimultaneousSacrificeEffectRule));
+exports.IllapaSacrificeRule = IllapaSacrificeRule;

package/dist/rules/effects/RaEffectRule.js

@@ -14,17 +14,6 @@ var __extends = (this && this.__extends) || (function () {
         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);
@@ -40,6 +29,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RaEffectRule = void 0;
 var Entity_1 = require("../../material/Entity");
 var SimultaneousMoveEffectRule_1 = require("../../material/entity/SimultaneousMoveEffectRule");
+var LocationType_1 = require("../../material/LocationType");
 var Pantheon_1 = require("../../material/Pantheon");
 var RaEffectRule = (function (_super) {
     __extends(RaEffectRule, _super);
@@ -60,7 +50,7 @@ var RaEffectRule = (function (_super) {
                         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 })));
+                            moves.push(entities.index(index).moveItem({ type: LocationType_1.LocationType.Pantheon, player: player, x: x, y: y - 1 }));
                         }
                     }
                 }

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

@@ -0,0 +1,19 @@
+import { ItemMove, Material, MaterialMove } from '@gamepark/rules-api';
+import { PlayerEffectRule } from '../../material/entity/Effect';
+import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
+import { SacrificeEffectRule } from '../../material/entity/SacrificeEffectRule';
+import { RuleId } from '../RuleId';
+export declare class SupayEffectRule extends PlayerEffectRule {
+    ruleId: RuleId;
+    playEffect(): MaterialMove[];
+    getCreaturesInLine(): Material<number, number, number>;
+    getRules(): (SupayMoveRule | SupaySacrificeRule)[];
+    getPlayerMoves(): MaterialMove[];
+    afterItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];
+}
+export declare class SupaySacrificeRule extends SacrificeEffectRule {
+    getCardsToSacrifice(): Material;
+}
+export declare class SupayMoveRule extends MoveEffectRule {
+    getMovingCards(): Material;
+}

package/dist/rules/effects/SupayEffectRule.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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupayMoveRule = exports.SupaySacrificeRule = exports.SupayEffectRule = void 0;
+var Entity_1 = require("../../material/Entity");
+var Effect_1 = require("../../material/entity/Effect");
+var MoveEffectRule_1 = require("../../material/entity/MoveEffectRule");
+var SacrificeEffectRule_1 = require("../../material/entity/SacrificeEffectRule");
+var MaterialType_1 = require("../../material/MaterialType");
+var Pantheon_1 = require("../../material/Pantheon");
+var RuleId_1 = require("../RuleId");
+var SupayEffectRule = (function (_super) {
+    __extends(SupayEffectRule, _super);
+    function SupayEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.SupayEffect;
+        return _this;
+    }
+    SupayEffectRule.prototype.playEffect = function () {
+        return this.getCreaturesInLine().length ? _super.prototype.playEffect.call(this) : [];
+    };
+    SupayEffectRule.prototype.getCreaturesInLine = function () {
+        var supayIndex = this.getEffect().cardIndex;
+        var card = this.material(MaterialType_1.MaterialType.EntityCard).getItem(supayIndex);
+        var player = card.location.player;
+        return new Pantheon_1.Pantheon(this.game, player).visibleEntities
+            .location(function (l) { return l.y === card.location.y; })
+            .index(function (index) { return index !== supayIndex; })
+            .id(function (id) { return (0, Entity_1.isCreature)(id.front); });
+    };
+    SupayEffectRule.prototype.getRules = function () {
+        return [new SupayMoveRule(this.game), new SupaySacrificeRule(this.game)];
+    };
+    SupayEffectRule.prototype.getPlayerMoves = function () {
+        return this.getRules().flatMap(function (rule) { return rule.getPlayerMoves(); });
+    };
+    SupayEffectRule.prototype.afterItemMove = function (move) {
+        return this.getRules().flatMap(function (rule) { return rule.afterItemMove(move); });
+    };
+    return SupayEffectRule;
+}(Effect_1.PlayerEffectRule));
+exports.SupayEffectRule = SupayEffectRule;
+var SupaySacrificeRule = (function (_super) {
+    __extends(SupaySacrificeRule, _super);
+    function SupaySacrificeRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SupaySacrificeRule.prototype.getCardsToSacrifice = function () {
+        return new SupayEffectRule(this.game).getCreaturesInLine();
+    };
+    return SupaySacrificeRule;
+}(SacrificeEffectRule_1.SacrificeEffectRule));
+exports.SupaySacrificeRule = SupaySacrificeRule;
+var SupayMoveRule = (function (_super) {
+    __extends(SupayMoveRule, _super);
+    function SupayMoveRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SupayMoveRule.prototype.getMovingCards = function () {
+        return new SupayEffectRule(this.game).getCreaturesInLine();
+    };
+    return SupayMoveRule;
+}(MoveEffectRule_1.MoveEffectRule));
+exports.SupayMoveRule = SupayMoveRule;

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

@@ -0,0 +1,13 @@
+import { ItemMove } from '@gamepark/rules-api';
+import { PlayerEffectRule } from '../../material/entity/Effect';
+import { PlaceCardEffectRule } from '../../material/entity/PlaceCardEffectRule';
+import { RuleId } from '../RuleId';
+export declare class UkukuEffectRule extends PlayerEffectRule {
+    ruleId: RuleId;
+    getPlayerMoves(): import("@gamepark/rules-api").MoveItem<number, number, number>[];
+    afterItemMove(move: ItemMove): import("@gamepark/rules-api").StartRule<RuleId.UkukuPlaceEffect>[];
+}
+export declare class UkukuPlaceEffectRule extends PlaceCardEffectRule {
+    getCardsToPlace(): import("@gamepark/rules-api").Material<number, number, number>;
+    getAvailableDestinations(cardIndex: number): import("@gamepark/rules-api").XYCoordinates[];
+}

package/dist/rules/effects/UkukuEffectRule.js

@@ -0,0 +1,60 @@
+"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.UkukuPlaceEffectRule = exports.UkukuEffectRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var Destiny_1 = require("../../material/Destiny");
+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 UkukuEffectRule = (function (_super) {
+    __extends(UkukuEffectRule, _super);
+    function UkukuEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.UkukuEffect;
+        return _this;
+    }
+    UkukuEffectRule.prototype.getPlayerMoves = function () {
+        return new Destiny_1.Destiny(this.game).creaturesOnTopOfDecks.moveItems({ type: LocationType_1.LocationType.PlayerBufferArea, player: this.player });
+    };
+    UkukuEffectRule.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.UkukuPlaceEffect)];
+        }
+        return [];
+    };
+    return UkukuEffectRule;
+}(Effect_1.PlayerEffectRule));
+exports.UkukuEffectRule = UkukuEffectRule;
+var UkukuPlaceEffectRule = (function (_super) {
+    __extends(UkukuPlaceEffectRule, _super);
+    function UkukuPlaceEffectRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    UkukuPlaceEffectRule.prototype.getCardsToPlace = function () {
+        return this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.PlayerBufferArea).player(this.player);
+    };
+    UkukuPlaceEffectRule.prototype.getAvailableDestinations = function (cardIndex) {
+        var ukuku = this.material(MaterialType_1.MaterialType.EntityCard).getItem(cardIndex);
+        return new Pantheon_1.Pantheon(this.game, this.player).legalSpaces.filter(function (space) { return space.x === ukuku.location.x; });
+    };
+    return UkukuPlaceEffectRule;
+}(PlaceCardEffectRule_1.PlaceCardEffectRule));
+exports.UkukuPlaceEffectRule = UkukuPlaceEffectRule;

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

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

package/dist/rules/effects/ViracochaEffectRule.js

@@ -0,0 +1,64 @@
+"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.ViracochaEffectRule = void 0;
+var Entity_1 = require("../../material/Entity");
+var SacrificeEffectRule_1 = require("../../material/entity/SacrificeEffectRule");
+var Pantheon_1 = require("../../material/Pantheon");
+var RuleId_1 = require("../RuleId");
+var ViracochaEffectRule = (function (_super) {
+    __extends(ViracochaEffectRule, _super);
+    function ViracochaEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.ViracochaEffect;
+        return _this;
+    }
+    ViracochaEffectRule.prototype.getCardsToSacrifice = function () {
+        return _super.prototype.getCardsToSacrifice.call(this).id(function (id) { return (0, Entity_1.isCreature)(id.front); });
+    };
+    ViracochaEffectRule.prototype.onSacrifice = function () {
+        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
+        return __spreadArray([pantheon.gainGems(2)], __read(this.endEffect()), false);
+    };
+    return ViracochaEffectRule;
+}(SacrificeEffectRule_1.SacrificeEffectRule));
+exports.ViracochaEffectRule = ViracochaEffectRule;

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

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

package/dist/rules/effects/YanluoWangEffectRule.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.YanluoWangEffectRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+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 Memory_1 = require("../../Memory");
+var RuleId_1 = require("../RuleId");
+var YanluoWangEffectRule = (function (_super) {
+    __extends(YanluoWangEffectRule, _super);
+    function YanluoWangEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.YanluoWangEffect;
+        return _this;
+    }
+    YanluoWangEffectRule.prototype.onRuleStart = function () {
+        var e_1, _a;
+        if (new Pantheon_1.Pantheon(this.game, this.player).gems) {
+            try {
+                for (var _b = __values(this.game.players), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var player = _c.value;
+                    if (player !== this.player) {
+                        var emptySpace = new Pantheon_1.Pantheon(this.game, player).grid[2].filter(function (space) { return space === undefined; }).length;
+                        this.memorize(Memory_1.Memory.YanluoWangCount, emptySpace, player);
+                    }
+                }
+            }
+            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 [];
+        }
+        else {
+            return [this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
+        }
+    };
+    YanluoWangEffectRule.prototype.getPlayerMoves = function () {
+        var e_2, _a;
+        var moves = [this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
+        var gems = this.material(MaterialType_1.MaterialType.GemToken).location(LocationType_1.LocationType.PlayerGems).player(this.player);
+        if (gems.getQuantity() > 0) {
+            try {
+                for (var _b = __values(this.game.players), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var player = _c.value;
+                    if (this.remind(Memory_1.Memory.YanluoWangCount, player) && new Pantheon_1.Pantheon(this.game, player).favor) {
+                        moves.push(gems.moveItem({ type: LocationType_1.LocationType.PlayerGems, player: player }, 1));
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+        return moves;
+    };
+    YanluoWangEffectRule.prototype.afterItemMove = function (move) {
+        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.GemToken)(move)) {
+            var player = move.location.player;
+            this.memorize(Memory_1.Memory.YanluoWangCount, function (count) { return count - 1; }, player);
+            var favor = this.material(MaterialType_1.MaterialType.FavorToken).location(LocationType_1.LocationType.PlayerFavor).player(player);
+            return [favor.moveItem({ type: LocationType_1.LocationType.PlayerFavor, player: this.player }, 1)];
+        }
+        return [];
+    };
+    return YanluoWangEffectRule;
+}(Effect_1.PlayerEffectRule));
+exports.YanluoWangEffectRule = YanluoWangEffectRule;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamepark/mythologies",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "The rules of Mythologies adapted for Game Park",
   "sideEffects": false,
   "main": "dist/index.js",
@@ -29,5 +29,5 @@
     "i18next": "^22.0.3",
     "lodash": "^4.17.21"
   },
-  "gitHead": "58603385bd3898b027d4ad792b8740ad85575519"
+  "gitHead": "de5a3ab0f3d679595718820f22bac06791fb7eb9"
 }