@gamepark/mythologies 0.7.1 → 0.7.3

package/dist/rules/effects/TianlongEffectRule.js

@@ -39,19 +39,9 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     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");
@@ -74,43 +64,22 @@ var TianlongEffectRule = (function (_super) {
         return moves;
     };
     TianlongEffectRule.prototype.onCardMoved = function (move) {
-        var e_1, _a;
-        var _b = this.material(MaterialType_1.MaterialType.EntityCard).getItem(move.itemIndex).location, x = _b.x, y = _b.y;
-        this.memorize(Memory_1.Memory.TargetLocations, [
-            { 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);
+        if (move.location.player === this.player) {
+            var _a = this.material(MaterialType_1.MaterialType.EntityCard).getItem(move.itemIndex).location, x = _a.x, y = _a.y;
+            this.memorize(Memory_1.Memory.TargetLocations, [
+                { x: x, y: y },
+                { x: move.location.x, y: move.location.y }
+            ]);
+            var opponentsEffectRule = new TianlongOpponentsEffectRule(this.game);
+            var moves = [new Pantheon_1.Pantheon(this.game, this.player).spendGems(1)];
+            moves.push.apply(moves, __spreadArray([], __read(opponentsEffectRule.playEffect()), false));
+            if (!moves.some(rules_api_1.isStartSimultaneousRule)) {
+                this.forget(Memory_1.Memory.TargetLocations);
+                moves.push(this.customMove(CustomMoveType_1.CustomMoveType.EndEffect));
             }
-            finally { if (e_1) throw e_1.error; }
+            return moves;
         }
-        if (playersWithChoice.length) {
-            moves.push(this.startSimultaneousRule(RuleId_1.RuleId.TianlongOpponentsEffect, playersWithChoice));
-        }
-        else {
-            this.forget(Memory_1.Memory.TargetLocations);
-            moves.push(this.customMove(CustomMoveType_1.CustomMoveType.EndEffect));
-        }
-        return moves;
+        return [];
     };
     return TianlongEffectRule;
 }(MoveEffectRule_1.MoveEffectRule));
@@ -118,11 +87,13 @@ exports.TianlongEffectRule = TianlongEffectRule;
 var TianlongOpponentsEffectRule = (function (_super) {
     __extends(TianlongOpponentsEffectRule, _super);
     function TianlongOpponentsEffectRule() {
-        return _super !== null && _super.apply(this, arguments) || this;
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.ruleId = RuleId_1.RuleId.TianlongOpponentsEffect;
+        return _this;
     }
     TianlongOpponentsEffectRule.prototype.getAffectedPlayers = function () {
         var _this = this;
-        return this.game.players.filter(function (player) { return _this.isOpponent(player) && _this.getActivePlayerLegalMoves(player).length > 0; });
+        return this.game.players.filter(function (player) { return _this.isOpponent(player); });
     };
     TianlongOpponentsEffectRule.prototype.getMovingCards = function (player) {
         var _a = this.remind(Memory_1.Memory.TargetLocations)[0], x = _a.x, y = _a.y;

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

@@ -1,11 +1,11 @@
-import { Material, MaterialRulesPart } from '@gamepark/rules-api';
+import { Location, MaterialRulesPart } from '@gamepark/rules-api';
 import { PendingEffect, TriggerEvent } from '../../material/entity/Effect';
 import { PlayerColor } from '../../PlayerColor';
 export declare class TriggerEffectsRule extends MaterialRulesPart {
     triggerEffects(...triggerEvents: TriggerEvent[]): void;
     triggerPlayerEffects(player: PlayerColor, ...triggerEvents: TriggerEvent[]): void;
     getPlayerEffects(player: PlayerColor, ...triggerEvents: TriggerEvent[]): PendingEffect<TriggerEvent>[];
-    triggerCardEffect(card: Material, triggerEvent: TriggerEvent): void;
-    getCardEffects(card: Material, triggerEvent: TriggerEvent): PendingEffect[];
+    triggerCardEffect(cardIndex: number, cardLocation: Location, triggerEvent: TriggerEvent): void;
+    getCardEffects(cardIndex: number, cardLocation: Location, triggerEvent: TriggerEvent): PendingEffect[];
     private getPlayersByEffectPriorityOrder;
 }

package/dist/rules/effects/TriggerEffectsRule.js

@@ -103,16 +103,22 @@ var TriggerEffectsRule = (function (_super) {
         var pendingEffects = [];
         var pantheon = new Pantheon_1.Pantheon(this.game, player);
         var material = this.material(MaterialType_1.MaterialType.EntityCard);
-        var cards = pantheon.visibleEntities.getIndexes();
+        var cards = pantheon.visibleEntities.getIndexes().map(function (index) { return ({ index: index, location: material.getItem(index).location }); });
+        var _loop_1 = function (event) {
+            if (event.type === Effect_1.TriggerEventType.EntityCrushed) {
+                var location = material.getItem(event.cardIndex).location;
+                if (location.player === player && !cards.some(function (card) { return card.index === event.cardIndex; })) {
+                    cards.push({ index: event.cardIndex, location: location });
+                }
+            }
+            if (event.type === Effect_1.TriggerEventType.EntityPlaced && event.location.player === player && !cards.some(function (card) { return card.index === event.cardIndex; })) {
+                cards.push({ index: event.cardIndex, location: event.location });
+            }
+        };
         try {
             for (var triggerEvents_1 = __values(triggerEvents), triggerEvents_1_1 = triggerEvents_1.next(); !triggerEvents_1_1.done; triggerEvents_1_1 = triggerEvents_1.next()) {
                 var event = triggerEvents_1_1.value;
-                if (event.type === Effect_1.TriggerEventType.EntityCrushed && material.getItem(event.cardIndex).location.player === player && !cards.includes(event.cardIndex)) {
-                    cards.push(event.cardIndex);
-                }
-                if (event.type === Effect_1.TriggerEventType.EntityPlaced && event.location.player === player && !cards.includes(event.cardIndex)) {
-                    cards.push(event.cardIndex);
-                }
+                _loop_1(event);
             }
         }
         catch (e_2_1) { e_2 = { error: e_2_1 }; }
@@ -127,9 +133,8 @@ var TriggerEffectsRule = (function (_super) {
                 var triggerEvent = triggerEvents_2_1.value;
                 try {
                     for (var cards_1 = (e_4 = void 0, __values(cards)), cards_1_1 = cards_1.next(); !cards_1_1.done; cards_1_1 = cards_1.next()) {
-                        var cardIndex = cards_1_1.value;
-                        var card = material.index(cardIndex);
-                        pendingEffects.push.apply(pendingEffects, __spreadArray([], __read(this.getCardEffects(card, triggerEvent)), false));
+                        var _d = cards_1_1.value, index = _d.index, location = _d.location;
+                        pendingEffects.push.apply(pendingEffects, __spreadArray([], __read(this.getCardEffects(index, location, triggerEvent)), false));
                     }
                 }
                 catch (e_4_1) { e_4 = { error: e_4_1 }; }
@@ -150,19 +155,18 @@ var TriggerEffectsRule = (function (_super) {
         }
         return pendingEffects;
     };
-    TriggerEffectsRule.prototype.triggerCardEffect = function (card, triggerEvent) {
-        var pendingEffects = this.getCardEffects(card, triggerEvent);
+    TriggerEffectsRule.prototype.triggerCardEffect = function (cardIndex, cardLocation, triggerEvent) {
+        var pendingEffects = this.getCardEffects(cardIndex, cardLocation, triggerEvent);
         if (pendingEffects.length) {
             this.remind(Memory_1.Memory.PendingEffects).unshift(pendingEffects);
         }
     };
-    TriggerEffectsRule.prototype.getCardEffects = function (card, triggerEvent) {
+    TriggerEffectsRule.prototype.getCardEffects = function (cardIndex, cardLocation, triggerEvent) {
         var pendingEffects = [];
-        var cardIndex = card.getIndex();
-        var cardItem = card.getItem();
-        for (var effectIndex = 0; effectIndex < (0, EntityDescription_1.getEffects)(cardItem.id.front).length; effectIndex++) {
-            var effect = (0, EntityDescription_1.getEffects)(cardItem.id.front)[effectIndex];
-            if ((0, Effect_1.isTriggeredEffect)(effect) && effect.trigger(triggerEvent, card, this.game)) {
+        var card = this.material(MaterialType_1.MaterialType.EntityCard).getItem(cardIndex);
+        for (var effectIndex = 0; effectIndex < (0, EntityDescription_1.getEffects)(card.id.front).length; effectIndex++) {
+            var effect = (0, EntityDescription_1.getEffects)(card.id.front)[effectIndex];
+            if ((0, Effect_1.isTriggeredEffect)(effect) && effect.trigger(triggerEvent, { cardIndex: cardIndex, cardLocation: cardLocation, game: this.game })) {
                 pendingEffects.push({ cardIndex: cardIndex, effectIndex: effectIndex, triggerEvent: triggerEvent, auto: !!effect.auto });
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamepark/mythologies",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "The rules of Mythologies adapted for Game Park",
   "sideEffects": false,
   "main": "dist/index.js",
@@ -20,14 +20,14 @@
     "lint": "eslint --fix"
   },
   "peerDependencies": {
-    "@gamepark/rules-api": ">=6.38",
+    "@gamepark/rules-api": ">=6.38.5",
     "lodash": ">=4.17"
   },
   "devDependencies": {
-    "@gamepark/rules-api": "~6.38.0",
+    "@gamepark/rules-api": "~6.38.5",
     "@types/lodash": "^4.17.7",
     "i18next": "^22.0.3",
     "lodash": "^4.17.21"
   },
-  "gitHead": "c14d682186f3955885026c16a9446734b4002eb0"
+  "gitHead": "dea6a9053b6c44493df694a064d2b1288ae86a3b"
 }