@gamepark/mythologies 0.7.4 → 0.7.5

package/dist/MythologiesRules.js

@@ -244,7 +244,7 @@ var MythologiesRules = (function (_super) {
                 if (pendingRule) {
                     this.forget(Memory_1.Memory.PendingRule);
                     if (pendingRule.id === RuleId_1.RuleId.EndGame) {
-                        moves.push(this.endGame());
+                        moves.push.apply(moves, __spreadArray(__spreadArray([], __read(new EndGameRule_1.EndGameRule(this.game).convertGems()), false), [this.endGame()], false));
                     }
                     else {
                         moves.push(this.startPlayerTurn(RuleId_1.RuleId.PlaceCards, pendingRule.player));

package/dist/material/entity/greek/Poseidon.js

@@ -22,7 +22,7 @@ var Entity_1 = require("../../Entity");
 var Pantheon_1 = require("../../Pantheon");
 var Effect_1 = require("../Effect");
 exports.Poseidon = {
-    invoke: [{}, { gem: 2 }, { favor: 1 }],
+    invoke: [{}, { gem: 1 }, { favor: 1 }],
     effect: {
         trigger: function (event, _a) {
             var cardLocation = _a.cardLocation;

package/dist/rules/EndGameRule.d.ts

@@ -1,5 +1,5 @@
-import { PlayerTurnRule } from '@gamepark/rules-api';
-import { RuleId } from './RuleId';
+import { MaterialMove, PlayerTurnRule } from '@gamepark/rules-api';
 export declare class EndGameRule extends PlayerTurnRule {
-    onRuleStart(): import("@gamepark/rules-api").StartPlayerTurn<number, RuleId.ResolveEffects>[] | import("@gamepark/rules-api").EndGame[];
+    onRuleStart(): MaterialMove<number, number, number, number>[];
+    convertGems(): MaterialMove<number, number, number, number>[];
 }

package/dist/rules/EndGameRule.js

@@ -14,11 +14,48 @@ var __extends = (this && this.__extends) || (function () {
         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.EndGameRule = void 0;
 var rules_api_1 = require("@gamepark/rules-api");
 var Effect_1 = require("../material/entity/Effect");
 var MaterialType_1 = require("../material/MaterialType");
+var Pantheon_1 = require("../material/Pantheon");
 var Memory_1 = require("../Memory");
 var TriggerEffectsRule_1 = require("./effects/TriggerEffectsRule");
 var RuleId_1 = require("./RuleId");
@@ -36,8 +73,32 @@ var EndGameRule = (function (_super) {
             return [this.startPlayerTurn(RuleId_1.RuleId.ResolveEffects, player)];
         }
         else {
-            return [this.endGame()];
+            return __spreadArray(__spreadArray([], __read(this.convertGems()), false), [this.endGame()], false);
+        }
+    };
+    EndGameRule.prototype.convertGems = function () {
+        var e_1, _a;
+        var moves = [];
+        try {
+            for (var _b = __values(this.game.players), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var player = _c.value;
+                var pantheon = new Pantheon_1.Pantheon(this.game, player);
+                var gems = pantheon.gems;
+                if (gems >= 3) {
+                    var favor = Math.floor(gems / 3);
+                    moves.push(pantheon.spendGems(favor * 3));
+                    moves.push(pantheon.gainFavor(favor));
+                }
+            }
+        }
+        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;
     };
     return EndGameRule;
 }(rules_api_1.PlayerTurnRule));

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

@@ -2,6 +2,10 @@ import { InvokeEffectRule } from '../../material/entity/PlaceCardEffectRule';
 import { RuleId } from '../RuleId';
 export declare class ImpunduluEffectRule extends InvokeEffectRule {
     ruleId: RuleId;
-    playEffect(): import("@gamepark/rules-api").MaterialMove<number, number, number, number>[];
+    playEffect(): import("@gamepark/rules-api").StartRule<RuleId>[];
+    onRuleStart(): import("@gamepark/rules-api").MoveItem<number, number, number>[];
     getCardsToPlace(): import("@gamepark/rules-api").Material<number, number, number>;
+    get availableSanctuaryCards(): import("@gamepark/rules-api").Material<number, number, number>;
+    get topCreaturesDeckCard(): import("@gamepark/rules-api").Material<number, number, number>;
+    get mythology(): import("../../material/Mythology").Mythology;
 }

package/dist/rules/effects/ImpunduluEffectRule.js

@@ -32,16 +32,50 @@ var ImpunduluEffectRule = (function (_super) {
     }
     ImpunduluEffectRule.prototype.playEffect = function () {
         var player = this.card.location.player;
-        return new Pantheon_1.Pantheon(this.game, player).hasCrushed(this.card) ? _super.prototype.playEffect.call(this) : [];
+        return new Pantheon_1.Pantheon(this.game, player).hasCrushed(this.card) ? [this.startRule(this.ruleId)] : [];
+    };
+    ImpunduluEffectRule.prototype.onRuleStart = function () {
+        if (this.availableSanctuaryCards.length === 0) {
+            return [this.topCreaturesDeckCard.rotateItem(true)];
+        }
+        return [];
     };
     ImpunduluEffectRule.prototype.getCardsToPlace = function () {
-        var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
-        var _a = this.card.location, x = _a.x, y = _a.y;
-        var crushed = pantheon.coveredEntities.location(function (l) { return l.x === x && l.y === y; }).maxBy(function (item) { return item.location.z; });
-        var mythology = (0, Entity_1.entityMythology)(crushed.getItem().id.front);
-        var board = this.material(MaterialType_1.MaterialType.MythologyBoard).id(function (id) { return id.mythology === mythology; });
-        return new Destiny_1.Destiny(this.game).cardsWithoutToken.location(LocationType_1.LocationType.SanctuaryCreatureSpot).parent(board.getIndex());
+        var availableSanctuaryCards = this.availableSanctuaryCards;
+        if (availableSanctuaryCards.length) {
+            return availableSanctuaryCards;
+        }
+        else {
+            return this.topCreaturesDeckCard;
+        }
     };
+    Object.defineProperty(ImpunduluEffectRule.prototype, "availableSanctuaryCards", {
+        get: function () {
+            var _this = this;
+            var board = this.material(MaterialType_1.MaterialType.MythologyBoard).id(function (id) { return id.mythology === _this.mythology; });
+            return new Destiny_1.Destiny(this.game).cardsWithoutToken.location(LocationType_1.LocationType.SanctuaryCreatureSpot).parent(board.getIndex());
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImpunduluEffectRule.prototype, "topCreaturesDeckCard", {
+        get: function () {
+            var deck = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.CreaturesDeck).locationId(this.mythology);
+            return deck.maxBy(function (item) { return item.location.x; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(ImpunduluEffectRule.prototype, "mythology", {
+        get: function () {
+            var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
+            var _a = this.card.location, x = _a.x, y = _a.y;
+            var crushed = pantheon.coveredEntities.location(function (l) { return l.x === x && l.y === y; }).maxBy(function (item) { return item.location.z; });
+            return (0, Entity_1.entityMythology)(crushed.getItem().id.front);
+        },
+        enumerable: false,
+        configurable: true
+    });
     return ImpunduluEffectRule;
 }(PlaceCardEffectRule_1.InvokeEffectRule));
 exports.ImpunduluEffectRule = ImpunduluEffectRule;

package/dist/rules/effects/MinotaurEffectRule.js

@@ -33,7 +33,8 @@ var MinotaurEffectRule = (function (_super) {
         return _super.prototype.onRuleStart.call(this);
     };
     MinotaurEffectRule.prototype.getMovingCards = function (player) {
-        var column = this.remind(Memory_1.Memory.TargetLine);
+        var _a;
+        var column = (_a = this.remind(Memory_1.Memory.TargetLine)) !== null && _a !== void 0 ? _a : this.card.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) {

package/dist/rules/effects/ViracochaEffectRule.js

@@ -33,7 +33,7 @@ var ViracochaEffectRule = (function (_super) {
     };
     ViracochaEffectRule.prototype.onSacrifice = function () {
         var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
-        return [pantheon.gainGems(2), this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
+        return [pantheon.gainFavor(2), this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
     };
     return ViracochaEffectRule;
 }(SacrificeEffectRule_1.SacrificeEffectRule));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamepark/mythologies",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "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": "5775c7ed56e3ac920aa4e85663de4803319b542c"
+  "gitHead": "bbba515638381571625dafa8ebcfd509082d316a"
 }