@gamepark/mythologies 0.2.0 → 0.3.0

package/dist/rules/effects/ResolveEffectsRule.js

@@ -51,23 +51,26 @@ var ResolveEffectsRule = (function (_super) {
                     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 this.playEffect(pendingEffect_1);
         }
         return [];
     };
+    ResolveEffectsRule.prototype.playEffect = function (pendingEffect) {
+        this.memorize(Memory_1.Memory.OngoingEffect, pendingEffect);
+        var card = this.material(MaterialType_1.MaterialType.EntityCard).getItem(pendingEffect.cardIndex);
+        var effect = EntityDescription_1.entities[card.id.front].effect;
+        if (effect.trigger === Effect_1.oncePerTurn) {
+            this.memorize(Memory_1.Memory.OncePerTurn, function (indexes) {
+                if (indexes === void 0) { indexes = []; }
+                return indexes.concat(pendingEffect.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 ResolveEffectsRule;
 }(rules_api_1.PlayerTurnRule));
 exports.ResolveEffectsRule = ResolveEffectsRule;

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

@@ -6,5 +6,5 @@ export declare class ShivaEffectRule extends PlayerEffectRule {
     canPlayEffect(cardIndex: number): boolean;
     onRuleStart(): MaterialMove[];
     getPlayerMoves(): MaterialMove[];
-    afterItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];
+    beforeItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];
 }

package/dist/rules/effects/ShivaEffectRule.js

@@ -70,10 +70,13 @@ var ShivaEffectRule = (function (_super) {
         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) {
+    ShivaEffectRule.prototype.beforeItemMove = 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);
+            var topCard = this.material(MaterialType_1.MaterialType.EntityCard)
+                .index(move.indexes)
+                .maxBy(function (item) { return item.location.z; });
+            return __spreadArray(__spreadArray([pantheon.gainFavor(move.indexes.length)], __read(pantheon.onEntitySacrificed(topCard)), false), __read(this.endEffect()), false);
         }
         return [];
     };

package/dist/rules/effects/SphinxEffectRule.js

@@ -28,12 +28,8 @@ var SphinxEffectRule = (function (_super) {
         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; });
+        var _a = this.card.location, x = _a.x, y = _a.y, z = _a.z;
+        return new Pantheon_1.Pantheon(this.game, this.player).allCards.location(function (l) { return l.x === x && l.y === y && l.z === z - 1; });
     };
     SphinxEffectRule.prototype.isLegalDestination = function (space, cardLocation) {
         return space.x === cardLocation.x;

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

@@ -7,5 +7,5 @@ export declare class ThorEffectRule extends SimultaneousSacrificeEffectRule {
     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>[];
+    beforeItemMove(move: ItemMove): import("@gamepark/rules-api").MaterialMove<number, number, number, number>[];
 }

package/dist/rules/effects/ThorEffectRule.js

@@ -49,7 +49,9 @@ var ThorEffectRule = (function (_super) {
         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 [];
+        else {
+            return _super.prototype.beforeItemMove.call(this, move);
+        }
     };
     return ThorEffectRule;
 }(SimultaneousSacrificeEffectRule_1.SimultaneousSacrificeEffectRule));

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

@@ -0,0 +1,17 @@
+import { ItemMove, MaterialMove, XYCoordinates } from '@gamepark/rules-api';
+import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
+import { SimultaneousMoveEffectRule } from '../../material/entity/SimultaneousMoveEffectRule';
+import { PlayerColor } from '../../PlayerColor';
+import { RuleId } from '../RuleId';
+export declare class TianlongEffectRule extends MoveEffectRule {
+    ruleId: RuleId;
+    getPlayerMoves(): MaterialMove<number, number, number, number>[];
+    beforeItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];
+    onCardMoved(): never[];
+}
+export declare class TianlongOpponentsEffectRule extends SimultaneousMoveEffectRule {
+    getAffectedPlayers(): number[];
+    getMovingCards(player: PlayerColor): import("@gamepark/rules-api").Material<number, number, number>;
+    isLegalDestination(space: XYCoordinates): boolean;
+    onRuleEnd(): never[];
+}

package/dist/rules/effects/TianlongEffectRule.js

@@ -0,0 +1,148 @@
+"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));
+};
+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.TianlongOpponentsEffectRule = exports.TianlongEffectRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var CustomMoveType_1 = require("../../CustomMoveType");
+var MoveEffectRule_1 = require("../../material/entity/MoveEffectRule");
+var SimultaneousMoveEffectRule_1 = require("../../material/entity/SimultaneousMoveEffectRule");
+var MaterialType_1 = require("../../material/MaterialType");
+var Pantheon_1 = require("../../material/Pantheon");
+var Memory_1 = require("../../Memory");
+var RuleId_1 = require("../RuleId");
+var TianlongEffectRule = (function (_super) {
+    __extends(TianlongEffectRule, _super);
+    function TianlongEffectRule() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.TianlongEffect;
+        return _this;
+    }
+    TianlongEffectRule.prototype.getPlayerMoves = function () {
+        var moves = [this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
+        if (new Pantheon_1.Pantheon(this.game, this.player).gems > 0) {
+            moves.push.apply(moves, __spreadArray([], __read(_super.prototype.getPlayerMoves.call(this)), false));
+        }
+        return moves;
+    };
+    TianlongEffectRule.prototype.beforeItemMove = function (move) {
+        var e_1, _a;
+        if ((0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.EntityCard)(move) && move.location.player === this.player) {
+            var _b = this.material(MaterialType_1.MaterialType.EntityCard).getItem(move.itemIndex).location, x = _b.x, y = _b.y;
+            this.memorize(Memory_1.Memory.TianlongVector, [
+                { x: x, y: y },
+                { x: move.location.x, y: move.location.y }
+            ]);
+            var opponentsEffectRule = new TianlongOpponentsEffectRule(this.game);
+            var affectedPlayers = opponentsEffectRule.getAffectedPlayers();
+            var playersWithChoice = [];
+            var moves = [new Pantheon_1.Pantheon(this.game, this.player).spendGems(1)];
+            try {
+                for (var affectedPlayers_1 = __values(affectedPlayers), affectedPlayers_1_1 = affectedPlayers_1.next(); !affectedPlayers_1_1.done; affectedPlayers_1_1 = affectedPlayers_1.next()) {
+                    var player = affectedPlayers_1_1.value;
+                    var legalMoves = opponentsEffectRule.getActivePlayerLegalMoves(player);
+                    if (legalMoves.length === 1) {
+                        moves.push(legalMoves[0]);
+                    }
+                    else {
+                        playersWithChoice.push(player);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (affectedPlayers_1_1 && !affectedPlayers_1_1.done && (_a = affectedPlayers_1.return)) _a.call(affectedPlayers_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            if (playersWithChoice.length) {
+                moves.push(this.startSimultaneousRule(RuleId_1.RuleId.TianlongOpponentsEffect, playersWithChoice));
+            }
+            else {
+                this.forget(Memory_1.Memory.TianlongVector);
+                moves.push.apply(moves, __spreadArray([], __read(this.endEffect()), false));
+            }
+            return moves;
+        }
+        return [];
+    };
+    TianlongEffectRule.prototype.onCardMoved = function () {
+        return [];
+    };
+    return TianlongEffectRule;
+}(MoveEffectRule_1.MoveEffectRule));
+exports.TianlongEffectRule = TianlongEffectRule;
+var TianlongOpponentsEffectRule = (function (_super) {
+    __extends(TianlongOpponentsEffectRule, _super);
+    function TianlongOpponentsEffectRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TianlongOpponentsEffectRule.prototype.getAffectedPlayers = function () {
+        var _this = this;
+        return this.game.players.filter(function (player) { return _this.isOpponent(player) && _this.getActivePlayerLegalMoves(player).length > 0; });
+    };
+    TianlongOpponentsEffectRule.prototype.getMovingCards = function (player) {
+        var _a = this.remind(Memory_1.Memory.TianlongVector)[0], x = _a.x, y = _a.y;
+        return _super.prototype.getMovingCards.call(this, player).location(function (l) { return l.x === x && l.y === y; });
+    };
+    TianlongOpponentsEffectRule.prototype.isLegalDestination = function (space) {
+        var _a = this.remind(Memory_1.Memory.TianlongVector)[1], x = _a.x, y = _a.y;
+        return space.x === x && space.y === y;
+    };
+    TianlongOpponentsEffectRule.prototype.onRuleEnd = function () {
+        this.forget(Memory_1.Memory.TianlongVector);
+        return [];
+    };
+    return TianlongOpponentsEffectRule;
+}(SimultaneousMoveEffectRule_1.SimultaneousMoveEffectRule));
+exports.TianlongOpponentsEffectRule = TianlongOpponentsEffectRule;

package/dist/rules/effects/TriggerEffectsRule.js

@@ -139,11 +139,10 @@ var TriggerEffectsRule = (function (_super) {
         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 });
+        if (cardItem.id.front) {
+            var effect = EntityDescription_1.entities[cardItem.id.front].effect;
+            if (effect === null || effect === void 0 ? void 0 : effect.trigger(triggerEvent, card, this.game)) {
+                pendingEffects.push({ cardIndex: cardIndex, triggerEvent: triggerEvent, auto: !!effect.auto });
             }
         }
         return pendingEffects;

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.2.0",
+  "version": "0.3.0",
   "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": "a9d4070ed2adea2a03d0e61312b0b947c70341c9"
+  "gitHead": "040c56993fd93fc1fa5978d53414ee6fa9b79b2f"
 }