@gamepark/mythologies 0.4.0 → 0.5.0

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

@@ -1,9 +1,9 @@
-import { Location, Material, MaterialMove, MoveItem, XYCoordinates } from '@gamepark/rules-api';
+import { Location, Material, MoveItem, XYCoordinates } from '@gamepark/rules-api';
 import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
 import { RuleId } from '../RuleId';
 export declare class SphinxEffectRule extends MoveEffectRule {
     ruleId: RuleId;
     getMovingCards(): Material;
     isLegalDestination(space: XYCoordinates, cardLocation: Location): boolean;
-    onCardMoved(move: MoveItem): MaterialMove[];
+    onCardMoved(move: MoveItem): import("@gamepark/rules-api").MaterialMove<number, number, number, number>[];
 }

package/dist/rules/effects/SphinxEffectRule.js

@@ -16,6 +16,7 @@ var __extends = (this && this.__extends) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SphinxEffectRule = void 0;
+var CustomMoveType_1 = require("../../CustomMoveType");
 var MoveEffectRule_1 = require("../../material/entity/MoveEffectRule");
 var MaterialType_1 = require("../../material/MaterialType");
 var Pantheon_1 = require("../../material/Pantheon");
@@ -36,7 +37,9 @@ var SphinxEffectRule = (function (_super) {
     };
     SphinxEffectRule.prototype.onCardMoved = function (move) {
         var entity = this.material(MaterialType_1.MaterialType.EntityCard).getItem(move.itemIndex).id.front;
-        return new Pantheon_1.Pantheon(this.game, this.player).getInvokeGains(entity, move.location.y).concat(this.endEffect());
+        var moves = new Pantheon_1.Pantheon(this.game, this.player).getInvokeGains(entity, move.location.y);
+        moves.push(this.customMove(CustomMoveType_1.CustomMoveType.EndEffect));
+        return moves;
     };
     return SphinxEffectRule;
 }(MoveEffectRule_1.MoveEffectRule));

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

@@ -1,4 +1,4 @@
-import { ItemMove, MaterialMove, XYCoordinates } from '@gamepark/rules-api';
+import { MaterialMove, MoveItem, XYCoordinates } from '@gamepark/rules-api';
 import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
 import { SimultaneousMoveEffectRule } from '../../material/entity/SimultaneousMoveEffectRule';
 import { PlayerColor } from '../../PlayerColor';
@@ -6,8 +6,7 @@ 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[];
+    onCardMoved(move: MoveItem): MaterialMove<number, number, number, number>[];
 }
 export declare class TianlongOpponentsEffectRule extends SimultaneousMoveEffectRule {
     getAffectedPlayers(): number[];

package/dist/rules/effects/TianlongEffectRule.js

@@ -52,7 +52,6 @@ var __values = (this && this.__values) || function(o) {
 };
 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,50 +73,44 @@ var TianlongEffectRule = (function (_super) {
         }
         return moves;
     };
-    TianlongEffectRule.prototype.beforeItemMove = function (move) {
+    TianlongEffectRule.prototype.onCardMoved = 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);
-                    }
+        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]);
                 }
-            }
-            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);
+                else {
+                    playersWithChoice.push(player);
                 }
-                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));
+        }
+        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);
             }
-            return moves;
+            finally { if (e_1) throw e_1.error; }
         }
-        return [];
-    };
-    TianlongEffectRule.prototype.onCardMoved = function () {
-        return [];
+        if (playersWithChoice.length) {
+            moves.push(this.startSimultaneousRule(RuleId_1.RuleId.TianlongOpponentsEffect, playersWithChoice));
+        }
+        else {
+            this.forget(Memory_1.Memory.TianlongVector);
+            moves.push(this.customMove(CustomMoveType_1.CustomMoveType.EndEffect));
+        }
+        return moves;
     };
     return TianlongEffectRule;
 }(MoveEffectRule_1.MoveEffectRule));
@@ -140,6 +133,7 @@ var TianlongOpponentsEffectRule = (function (_super) {
         return space.x === x && space.y === y;
     };
     TianlongOpponentsEffectRule.prototype.onRuleEnd = function () {
+        this.forget(Memory_1.Memory.EntityMoved);
         this.forget(Memory_1.Memory.TianlongVector);
         return [];
     };

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

@@ -6,6 +6,6 @@ export declare class TriggerEffectsRule extends MaterialRulesPart {
     triggerPlayerEffects(player: PlayerColor, ...triggerEvents: TriggerEvent[]): void;
     getPlayerEffects(player: PlayerColor, ...triggerEvents: TriggerEvent[]): PendingEffect<TriggerEvent>[];
     triggerCardEffect(card: Material, triggerEvent: TriggerEvent): void;
-    getCardEffect(card: Material, triggerEvent: TriggerEvent): PendingEffect[];
+    getCardEffects(card: Material, triggerEvent: TriggerEvent): PendingEffect[];
     private getPlayersByEffectPriorityOrder;
 }

package/dist/rules/effects/TriggerEffectsRule.js

@@ -53,6 +53,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TriggerEffectsRule = void 0;
 var rules_api_1 = require("@gamepark/rules-api");
+var Effect_1 = require("../../material/entity/Effect");
 var EntityDescription_1 = require("../../material/entity/EntityDescription");
 var MaterialType_1 = require("../../material/MaterialType");
 var Pantheon_1 = require("../../material/Pantheon");
@@ -94,55 +95,72 @@ var TriggerEffectsRule = (function (_super) {
         }
     };
     TriggerEffectsRule.prototype.getPlayerEffects = function (player) {
-        var e_2, _a, e_3, _b;
+        var e_2, _a, e_3, _b, e_4, _c;
         var triggerEvents = [];
         for (var _i = 1; _i < arguments.length; _i++) {
             triggerEvents[_i - 1] = arguments[_i];
         }
         var pendingEffects = [];
         var pantheon = new Pantheon_1.Pantheon(this.game, player);
-        var cards = pantheon.visibleEntities;
+        var material = this.material(MaterialType_1.MaterialType.EntityCard);
+        var cards = pantheon.visibleEntities.getIndexes();
         try {
             for (var triggerEvents_1 = __values(triggerEvents), triggerEvents_1_1 = triggerEvents_1.next(); !triggerEvents_1_1.done; triggerEvents_1_1 = triggerEvents_1.next()) {
-                var triggerEvent = triggerEvents_1_1.value;
+                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);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (triggerEvents_1_1 && !triggerEvents_1_1.done && (_a = triggerEvents_1.return)) _a.call(triggerEvents_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        try {
+            for (var triggerEvents_2 = __values(triggerEvents), triggerEvents_2_1 = triggerEvents_2.next(); !triggerEvents_2_1.done; triggerEvents_2_1 = triggerEvents_2.next()) {
+                var triggerEvent = triggerEvents_2_1.value;
                 try {
-                    for (var _c = (e_3 = void 0, __values(cards.getIndexes())), _d = _c.next(); !_d.done; _d = _c.next()) {
-                        var cardIndex = _d.value;
-                        pendingEffects.push.apply(pendingEffects, __spreadArray([], __read(this.getCardEffect(cards.index(cardIndex), triggerEvent)), false));
+                    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));
                     }
                 }
-                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
                 finally {
                     try {
-                        if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
+                        if (cards_1_1 && !cards_1_1.done && (_c = cards_1.return)) _c.call(cards_1);
                     }
-                    finally { if (e_3) throw e_3.error; }
+                    finally { if (e_4) throw e_4.error; }
                 }
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
         finally {
             try {
-                if (triggerEvents_1_1 && !triggerEvents_1_1.done && (_a = triggerEvents_1.return)) _a.call(triggerEvents_1);
+                if (triggerEvents_2_1 && !triggerEvents_2_1.done && (_b = triggerEvents_2.return)) _b.call(triggerEvents_2);
             }
-            finally { if (e_2) throw e_2.error; }
+            finally { if (e_3) throw e_3.error; }
         }
         return pendingEffects;
     };
     TriggerEffectsRule.prototype.triggerCardEffect = function (card, triggerEvent) {
-        var pendingEffects = this.getCardEffect(card, triggerEvent);
+        var pendingEffects = this.getCardEffects(card, triggerEvent);
         if (pendingEffects.length) {
             this.remind(Memory_1.Memory.PendingEffects).unshift(pendingEffects);
         }
     };
-    TriggerEffectsRule.prototype.getCardEffect = function (card, triggerEvent) {
+    TriggerEffectsRule.prototype.getCardEffects = function (card, triggerEvent) {
         var pendingEffects = [];
         var cardIndex = card.getIndex();
         var cardItem = card.getItem();
-        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 });
+        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)) {
+                pendingEffects.push({ cardIndex: cardIndex, effectIndex: effectIndex, triggerEvent: triggerEvent, auto: !!effect.auto });
             }
         }
         return pendingEffects;

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

@@ -1,4 +1,4 @@
-import { MaterialItem, MaterialMove } from '@gamepark/rules-api';
+import { MaterialItem, MaterialMove, MoveItem } from '@gamepark/rules-api';
 import { MoveEffectRule } from '../../material/entity/MoveEffectRule';
 import { RuleId } from '../RuleId';
 export declare class VetalaEffectRule extends MoveEffectRule {
@@ -6,6 +6,7 @@ export declare class VetalaEffectRule extends MoveEffectRule {
     onRuleStart(): MaterialMove[];
     getPlayerMoves(): MaterialMove<number, number, number, number>[];
     getAvailableDestinations(card: MaterialItem, cardIndex: number): import("@gamepark/rules-api").XYCoordinates[];
-    onCardMoved(): MaterialMove[];
+    onCardMoved(): import("@gamepark/rules-api").CustomMove<number>[];
+    onCardSacrificed(move: MoveItem): import("@gamepark/rules-api").CustomMove<number>[];
     onRuleEnd(): never[];
 }

package/dist/rules/effects/VetalaEffectRule.js

@@ -33,11 +33,11 @@ var VetalaEffectRule = (function (_super) {
     VetalaEffectRule.prototype.onRuleStart = function () {
         var entitiesSacrificed = this.material(MaterialType_1.MaterialType.EntityCard).location(LocationType_1.LocationType.PlayerDiscard).player(this.player).length;
         if (entitiesSacrificed) {
-            this.memorize(Memory_1.Memory.VetalaCount, entitiesSacrificed);
+            this.memorize(Memory_1.Memory.EffectCount, entitiesSacrificed);
             return [];
         }
         else {
-            return this.endEffect();
+            return [this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
         }
     };
     VetalaEffectRule.prototype.getPlayerMoves = function () {
@@ -47,11 +47,16 @@ var VetalaEffectRule = (function (_super) {
         return _super.prototype.getAvailableDestinations.call(this, card, cardIndex).filter(function (space) { return (0, rules_api_1.areAdjacentSquares)(card.location, space); });
     };
     VetalaEffectRule.prototype.onCardMoved = function () {
-        var count = this.memorize(Memory_1.Memory.VetalaCount, function (count) { return count - 1; });
-        return count > 0 ? [] : this.endEffect();
+        var count = this.memorize(Memory_1.Memory.EffectCount, function (count) { return count - 1; });
+        return count > 0 ? [] : [this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
+    };
+    VetalaEffectRule.prototype.onCardSacrificed = function (move) {
+        _super.prototype.onCardSacrificed.call(this, move);
+        return this.onCardMoved();
     };
     VetalaEffectRule.prototype.onRuleEnd = function () {
-        this.forget(Memory_1.Memory.VetalaCount);
+        this.forget(Memory_1.Memory.EntityMoved);
+        this.forget(Memory_1.Memory.EffectCount);
         return [];
     };
     return VetalaEffectRule;

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

@@ -3,5 +3,5 @@ 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>[];
+    onSacrifice(): (import("@gamepark/rules-api").CustomMove<number> | import("@gamepark/rules-api").CreateItem<number, number, number>)[];
 }

package/dist/rules/effects/ViracochaEffectRule.js

@@ -14,33 +14,9 @@ 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));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ViracochaEffectRule = void 0;
+var CustomMoveType_1 = require("../../CustomMoveType");
 var Entity_1 = require("../../material/Entity");
 var SacrificeEffectRule_1 = require("../../material/entity/SacrificeEffectRule");
 var Pantheon_1 = require("../../material/Pantheon");
@@ -57,7 +33,7 @@ var ViracochaEffectRule = (function (_super) {
     };
     ViracochaEffectRule.prototype.onSacrifice = function () {
         var pantheon = new Pantheon_1.Pantheon(this.game, this.player);
-        return __spreadArray([pantheon.gainGems(2)], __read(this.endEffect()), false);
+        return [pantheon.gainGems(2), this.customMove(CustomMoveType_1.CustomMoveType.EndEffect)];
     };
     return ViracochaEffectRule;
 }(SacrificeEffectRule_1.SacrificeEffectRule));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamepark/mythologies",
-  "version": "0.4.0",
+  "version": "0.5.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": "d1fe28d9163e93c887671815f4d48d64776adb30"
+  "gitHead": "d8a6ef2a164b825fc27f47ead850ec5b7bd29c6a"
 }