@gamepark/odin 0.0.1 → 0.0.2

package/dist/OdinRules.d.ts

@@ -1,4 +1,5 @@
 import { CustomMove, MaterialGame, MaterialMove, PlayMoveContext, PositiveSequenceStrategy, SecretMaterialRules, TimeLimit } from '@gamepark/rules-api';
+import { CompetitiveScore } from '../../../rules-api';
 import { LocationType } from './material/LocationType';
 import { MaterialType } from './material/MaterialType';
 import { PlayerId } from './PlayerId';
@@ -6,7 +7,7 @@ import { DealCardsRule } from './rules/DealCardsRule';
 import { EndOfRoundRule } from './rules/EndOfRoundRule';
 import { PickCardRule } from './rules/PickCardRule';
 import { PlayCardsRule } from './rules/PlayCardsRule';
-export declare class OdinRules extends SecretMaterialRules<PlayerId, MaterialType, LocationType> implements TimeLimit<MaterialGame<PlayerId, MaterialType, LocationType>, MaterialMove<PlayerId, MaterialType, LocationType>> {
+export declare class OdinRules extends SecretMaterialRules<PlayerId, MaterialType, LocationType> implements TimeLimit<MaterialGame<PlayerId, MaterialType, LocationType>, MaterialMove<PlayerId, MaterialType, LocationType>>, CompetitiveScore<MaterialGame<PlayerId, MaterialType, LocationType>, MaterialMove<PlayerId, MaterialType, LocationType>, PlayerId> {
     rules: {
         1: typeof PlayCardsRule;
         4: typeof DealCardsRule;
@@ -29,5 +30,7 @@ export declare class OdinRules extends SecretMaterialRules<PlayerId, MaterialTyp
     };
     restoreTransientState(previousState: MaterialGame): void;
     giveTime(): number;
+    getScore(playerId: PlayerId): number;
+    rankByLowerScore: boolean;
     onCustomMove(move: CustomMove, context: PlayMoveContext): MaterialMove<number, MaterialType, LocationType, number>[];
 }

package/dist/OdinRules.js

@@ -22,6 +22,7 @@ var MaterialType_1 = require("./material/MaterialType");
 var CustomMoveType_1 = require("./rules/CustomMoveType");
 var DealCardsRule_1 = require("./rules/DealCardsRule");
 var EndOfRoundRule_1 = require("./rules/EndOfRoundRule");
+var ScoreHelper_1 = require("./rules/helper/ScoreHelper");
 var Memory_1 = require("./rules/Memory");
 var PickCardRule_1 = require("./rules/PickCardRule");
 var PlayCardsRule_1 = require("./rules/PlayCardsRule");
@@ -51,6 +52,7 @@ var OdinRules = (function (_super) {
                 _e[LocationType_1.LocationType.Discard] = new rules_api_1.PositiveSequenceStrategy(),
                 _e),
             _d);
+        _this.rankByLowerScore = true;
         return _this;
     }
     OdinRules.prototype.restoreTransientState = function (previousState) {
@@ -60,6 +62,9 @@ var OdinRules = (function (_super) {
     OdinRules.prototype.giveTime = function () {
         return 60;
     };
+    OdinRules.prototype.getScore = function (playerId) {
+        return new ScoreHelper_1.ScoreHelper(this.game, playerId).score;
+    };
     OdinRules.prototype.onCustomMove = function (move, context) {
         if (move.type === CustomMoveType_1.CustomMoveType.SortHand) {
             this.memorize(Memory_1.Memory.HandSort, move.data);

package/dist/OdinSetup.js

@@ -36,6 +36,7 @@ var OdinSetup = (function (_super) {
     };
     OdinSetup.prototype.start = function () {
         this.memorize(Memory_1.Memory.FirstPlayer, this.game.players[0]);
+        this.memorize(Memory_1.Memory.Round, 1);
         this.startRule(RuleId_1.RuleId.DealCards);
     };
     return OdinSetup;

package/dist/rules/EndOfRoundRule.d.ts

@@ -2,6 +2,7 @@ import { ItemMove, MaterialMove, MaterialRulesPart } from '@gamepark/rules-api';
 import { PlayerId } from '../PlayerId';
 export declare class EndOfRoundRule extends MaterialRulesPart {
     onRuleStart(): MaterialMove<number, number, number, number>[];
+    onRoundEnd(): MaterialMove[];
     get deck(): import("@gamepark/rules-api").MaterialDeck<number, number, number>;
     get groupToDeckMove(): MaterialMove<number, number, number, number>[];
     afterItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];

package/dist/rules/EndOfRoundRule.js

@@ -39,9 +39,24 @@ 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.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EndOfRoundRule = void 0;
 var rules_api_1 = require("@gamepark/rules-api");
+var sum_1 = __importDefault(require("lodash/sum"));
 var LocationType_1 = require("../material/LocationType");
 var MaterialType_1 = require("../material/MaterialType");
 var Memory_1 = require("./Memory");
@@ -52,10 +67,47 @@ var EndOfRoundRule = (function (_super) {
         return _super !== null && _super.apply(this, arguments) || this;
     }
     EndOfRoundRule.prototype.onRuleStart = function () {
-        var moves = [];
-        moves.push.apply(moves, __spreadArray([], __read(this.groupToDeckMove), false));
+        var moves = this.onRoundEnd();
+        if (!moves.length) {
+            moves.push.apply(moves, __spreadArray([], __read(this.groupToDeckMove), false));
+        }
         return moves;
     };
+    EndOfRoundRule.prototype.onRoundEnd = function () {
+        var e_1, _a;
+        var ended = false;
+        var _loop_1 = function (player) {
+            var hand = this_1.material(MaterialType_1.MaterialType.Card).location(LocationType_1.LocationType.Hand).player(player);
+            this_1.memorize(Memory_1.Memory.PlayerScore, function (s) {
+                if (s === void 0) { s = []; }
+                return __spreadArray(__spreadArray([], __read(s), false), [hand.length], false);
+            }, player);
+            var score = (0, sum_1.default)(this_1.remind(Memory_1.Memory.PlayerScore, player));
+            if (!ended && score >= 15)
+                ended = true;
+        };
+        var this_1 = this;
+        try {
+            for (var _b = __values(this.game.players), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var player = _c.value;
+                _loop_1(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; }
+        }
+        if (!ended) {
+            this.memorize(Memory_1.Memory.Round, function (r) {
+                return r + 1;
+            });
+            return [];
+        }
+        return [this.endGame()];
+    };
     Object.defineProperty(EndOfRoundRule.prototype, "deck", {
         get: function () {
             return this.material(MaterialType_1.MaterialType.Card).location(LocationType_1.LocationType.Deck).deck();

package/dist/rules/Memory.d.ts

@@ -2,5 +2,7 @@ export declare enum Memory {
     PlayedCards = 1,
     FirstPlayer = 2,
     LastPlayerThatPlay = 3,
-    HandSort = 4
+    HandSort = 4,
+    Round = 5,
+    PlayerScore = 6
 }

package/dist/rules/Memory.js

@@ -7,4 +7,6 @@ var Memory;
     Memory[Memory["FirstPlayer"] = 2] = "FirstPlayer";
     Memory[Memory["LastPlayerThatPlay"] = 3] = "LastPlayerThatPlay";
     Memory[Memory["HandSort"] = 4] = "HandSort";
+    Memory[Memory["Round"] = 5] = "Round";
+    Memory[Memory["PlayerScore"] = 6] = "PlayerScore";
 })(Memory = exports.Memory || (exports.Memory = {}));

package/dist/rules/helper/ScoreHelper.d.ts

@@ -0,0 +1,10 @@
+import { MaterialGame, MaterialRulesPart } from '@gamepark/rules-api';
+import { PlayerId } from '../../PlayerId';
+export declare class ScoreHelper extends MaterialRulesPart {
+    readonly player: PlayerId;
+    constructor(game: MaterialGame, player: PlayerId);
+    isWinningRound(round: number): boolean;
+    get score(): number;
+    getRoundScore(round: number): number;
+    get isWinning(): boolean;
+}

package/dist/rules/helper/ScoreHelper.js

@@ -0,0 +1,56 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScoreHelper = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var sum_1 = __importDefault(require("lodash/sum"));
+var LocationType_1 = require("../../material/LocationType");
+var MaterialType_1 = require("../../material/MaterialType");
+var Memory_1 = require("../Memory");
+var ScoreHelper = (function (_super) {
+    __extends(ScoreHelper, _super);
+    function ScoreHelper(game, player) {
+        var _this = _super.call(this, game) || this;
+        _this.player = player;
+        return _this;
+    }
+    ScoreHelper.prototype.isWinningRound = function (round) {
+        return this.getRoundScore(round) === 0;
+    };
+    Object.defineProperty(ScoreHelper.prototype, "score", {
+        get: function () {
+            return (0, sum_1.default)(this.remind(Memory_1.Memory.PlayerScore, this.player));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ScoreHelper.prototype.getRoundScore = function (round) {
+        return this.remind(Memory_1.Memory.PlayerScore, this.player)[round];
+    };
+    Object.defineProperty(ScoreHelper.prototype, "isWinning", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.Card).location(LocationType_1.LocationType.Hand).player(this.player).length === 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ScoreHelper;
+}(rules_api_1.MaterialRulesPart));
+exports.ScoreHelper = ScoreHelper;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gamepark/odin",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "The rules of Odin adapted for Game Park",
   "sideEffects": false,
   "main": "dist/index.js",
@@ -29,5 +29,5 @@
     "i18next": "^22.0.3",
     "lodash": "^4.17.21"
   },
-  "gitHead": "b29d409632381911a0d74c1b6756a80016d81d1e"
+  "gitHead": "c5272c1052e76fc49097aa007043479a237ac668"
 }