@gamepark/odin 0.0.1

package/dist/OdinOptions.d.ts

@@ -0,0 +1,5 @@
+import { OptionsSpec } from '@gamepark/rules-api';
+export type OdinOptions = {
+    players: number;
+};
+export declare const OdinOptionsSpec: OptionsSpec<OdinOptions>;

package/dist/OdinOptions.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OdinOptionsSpec = void 0;
+exports.OdinOptionsSpec = {};

package/dist/OdinRules.d.ts

@@ -0,0 +1,33 @@
+import { CustomMove, MaterialGame, MaterialMove, PlayMoveContext, PositiveSequenceStrategy, SecretMaterialRules, TimeLimit } from '@gamepark/rules-api';
+import { LocationType } from './material/LocationType';
+import { MaterialType } from './material/MaterialType';
+import { PlayerId } from './PlayerId';
+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>> {
+    rules: {
+        1: typeof PlayCardsRule;
+        4: typeof DealCardsRule;
+        2: typeof PickCardRule;
+        3: typeof EndOfRoundRule;
+    };
+    hidingStrategies: {
+        1: {
+            1: import("@gamepark/rules-api").HidingStrategy<number, number>;
+            2: <P extends number = number, L extends number = number>(item: import("@gamepark/rules-api").MaterialItem<P, L, any>, player?: P | undefined) => string[];
+        };
+    };
+    locationsStrategies: {
+        1: {
+            2: PositiveSequenceStrategy<number, number, number>;
+            1: PositiveSequenceStrategy<number, number, number>;
+            3: PositiveSequenceStrategy<number, number, number>;
+            4: PositiveSequenceStrategy<number, number, number>;
+        };
+    };
+    restoreTransientState(previousState: MaterialGame): void;
+    giveTime(): number;
+    onCustomMove(move: CustomMove, context: PlayMoveContext): MaterialMove<number, MaterialType, LocationType, number>[];
+}

package/dist/OdinRules.js

@@ -0,0 +1,71 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OdinRules = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var LocationType_1 = require("./material/LocationType");
+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 Memory_1 = require("./rules/Memory");
+var PickCardRule_1 = require("./rules/PickCardRule");
+var PlayCardsRule_1 = require("./rules/PlayCardsRule");
+var RuleId_1 = require("./rules/RuleId");
+var OdinRules = (function (_super) {
+    __extends(OdinRules, _super);
+    function OdinRules() {
+        var _a, _b, _c, _d, _e;
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.rules = (_a = {},
+            _a[RuleId_1.RuleId.PlayCards] = PlayCardsRule_1.PlayCardsRule,
+            _a[RuleId_1.RuleId.DealCards] = DealCardsRule_1.DealCardsRule,
+            _a[RuleId_1.RuleId.PickCard] = PickCardRule_1.PickCardRule,
+            _a[RuleId_1.RuleId.EndOfRound] = EndOfRoundRule_1.EndOfRoundRule,
+            _a);
+        _this.hidingStrategies = (_b = {},
+            _b[MaterialType_1.MaterialType.Card] = (_c = {},
+                _c[LocationType_1.LocationType.Deck] = rules_api_1.hideItemId,
+                _c[LocationType_1.LocationType.Hand] = rules_api_1.hideItemIdToOthers,
+                _c),
+            _b);
+        _this.locationsStrategies = (_d = {},
+            _d[MaterialType_1.MaterialType.Card] = (_e = {},
+                _e[LocationType_1.LocationType.Hand] = new rules_api_1.PositiveSequenceStrategy(),
+                _e[LocationType_1.LocationType.Deck] = new rules_api_1.PositiveSequenceStrategy(),
+                _e[LocationType_1.LocationType.MiddleOfTable] = new rules_api_1.PositiveSequenceStrategy(),
+                _e[LocationType_1.LocationType.Discard] = new rules_api_1.PositiveSequenceStrategy(),
+                _e),
+            _d);
+        return _this;
+    }
+    OdinRules.prototype.restoreTransientState = function (previousState) {
+        _super.prototype.restoreTransientState.call(this, previousState);
+        this.memorize(Memory_1.Memory.HandSort, previousState.memory[Memory_1.Memory.HandSort]);
+    };
+    OdinRules.prototype.giveTime = function () {
+        return 60;
+    };
+    OdinRules.prototype.onCustomMove = function (move, context) {
+        if (move.type === CustomMoveType_1.CustomMoveType.SortHand) {
+            this.memorize(Memory_1.Memory.HandSort, move.data);
+        }
+        return _super.prototype.onCustomMove.call(this, move, context);
+    };
+    return OdinRules;
+}(rules_api_1.SecretMaterialRules));
+exports.OdinRules = OdinRules;

package/dist/OdinSetup.d.ts

@@ -0,0 +1,11 @@
+import { MaterialGameSetup } from '@gamepark/rules-api';
+import { OdinOptions } from './OdinOptions';
+import { OdinRules } from './OdinRules';
+import { LocationType } from './material/LocationType';
+import { MaterialType } from './material/MaterialType';
+import { PlayerId } from './PlayerId';
+export declare class OdinSetup extends MaterialGameSetup<PlayerId, MaterialType, LocationType, OdinOptions> {
+    Rules: typeof OdinRules;
+    setupMaterial(_options: OdinOptions): void;
+    start(): void;
+}

package/dist/OdinSetup.js

@@ -0,0 +1,43 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OdinSetup = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var OdinRules_1 = require("./OdinRules");
+var LocationType_1 = require("./material/LocationType");
+var MaterialType_1 = require("./material/MaterialType");
+var Memory_1 = require("./rules/Memory");
+var RuleId_1 = require("./rules/RuleId");
+var Card_1 = require("./material/Card");
+var OdinSetup = (function (_super) {
+    __extends(OdinSetup, _super);
+    function OdinSetup() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.Rules = OdinRules_1.OdinRules;
+        return _this;
+    }
+    OdinSetup.prototype.setupMaterial = function (_options) {
+        this.material(MaterialType_1.MaterialType.Card).createItems((0, rules_api_1.getEnumValues)(Card_1.Card).map(function (id) { return ({ id: id, location: { type: LocationType_1.LocationType.Deck } }); }));
+        this.material(MaterialType_1.MaterialType.Card).shuffle();
+    };
+    OdinSetup.prototype.start = function () {
+        this.memorize(Memory_1.Memory.FirstPlayer, this.game.players[0]);
+        this.startRule(RuleId_1.RuleId.DealCards);
+    };
+    return OdinSetup;
+}(rules_api_1.MaterialGameSetup));
+exports.OdinSetup = OdinSetup;

package/dist/PlayerId.d.ts

@@ -0,0 +1 @@
+export type PlayerId = number;

package/dist/PlayerId.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { OdinRules } from './OdinRules';
+export { OdinOptionsSpec } from './OdinOptions';
+export { OdinSetup } from './OdinSetup';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OdinSetup = exports.OdinOptionsSpec = exports.OdinRules = void 0;
+var OdinRules_1 = require("./OdinRules");
+Object.defineProperty(exports, "OdinRules", { enumerable: true, get: function () { return OdinRules_1.OdinRules; } });
+var OdinOptions_1 = require("./OdinOptions");
+Object.defineProperty(exports, "OdinOptionsSpec", { enumerable: true, get: function () { return OdinOptions_1.OdinOptionsSpec; } });
+var OdinSetup_1 = require("./OdinSetup");
+Object.defineProperty(exports, "OdinSetup", { enumerable: true, get: function () { return OdinSetup_1.OdinSetup; } });

package/dist/material/Card.d.ts

@@ -0,0 +1,66 @@
+export declare enum Card {
+    Blue1 = 11,
+    Blue2 = 12,
+    Blue3 = 13,
+    Blue4 = 14,
+    Blue5 = 15,
+    Blue6 = 16,
+    Blue7 = 17,
+    Blue8 = 18,
+    Blue9 = 19,
+    Red1 = 21,
+    Red2 = 22,
+    Red3 = 23,
+    Red4 = 24,
+    Red5 = 25,
+    Red6 = 26,
+    Red7 = 27,
+    Red8 = 28,
+    Red9 = 29,
+    Green1 = 31,
+    Green2 = 32,
+    Green3 = 33,
+    Green4 = 34,
+    Green5 = 35,
+    Green6 = 36,
+    Green7 = 37,
+    Green8 = 38,
+    Green9 = 39,
+    Orange1 = 41,
+    Orange2 = 42,
+    Orange3 = 43,
+    Orange4 = 44,
+    Orange5 = 45,
+    Orange6 = 46,
+    Orange7 = 47,
+    Orange8 = 48,
+    Orange9 = 49,
+    Pink1 = 51,
+    Pink2 = 52,
+    Pink3 = 53,
+    Pink4 = 54,
+    Pink5 = 55,
+    Pink6 = 56,
+    Pink7 = 57,
+    Pink8 = 58,
+    Pink9 = 59,
+    Brown1 = 61,
+    Brown2 = 62,
+    Brown3 = 63,
+    Brown4 = 64,
+    Brown5 = 65,
+    Brown6 = 66,
+    Brown7 = 67,
+    Brown8 = 68,
+    Brown9 = 69
+}
+export declare enum CardColor {
+    Blue = 1,
+    Red = 2,
+    Green = 3,
+    Orange = 4,
+    Pink = 5,
+    Brown = 6
+}
+export declare const getCardColor: (card: Card) => CardColor;
+export declare const getCardValue: (card: Card) => number;

package/dist/material/Card.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCardValue = exports.getCardColor = exports.CardColor = exports.Card = void 0;
+var Card;
+(function (Card) {
+    Card[Card["Blue1"] = 11] = "Blue1";
+    Card[Card["Blue2"] = 12] = "Blue2";
+    Card[Card["Blue3"] = 13] = "Blue3";
+    Card[Card["Blue4"] = 14] = "Blue4";
+    Card[Card["Blue5"] = 15] = "Blue5";
+    Card[Card["Blue6"] = 16] = "Blue6";
+    Card[Card["Blue7"] = 17] = "Blue7";
+    Card[Card["Blue8"] = 18] = "Blue8";
+    Card[Card["Blue9"] = 19] = "Blue9";
+    Card[Card["Red1"] = 21] = "Red1";
+    Card[Card["Red2"] = 22] = "Red2";
+    Card[Card["Red3"] = 23] = "Red3";
+    Card[Card["Red4"] = 24] = "Red4";
+    Card[Card["Red5"] = 25] = "Red5";
+    Card[Card["Red6"] = 26] = "Red6";
+    Card[Card["Red7"] = 27] = "Red7";
+    Card[Card["Red8"] = 28] = "Red8";
+    Card[Card["Red9"] = 29] = "Red9";
+    Card[Card["Green1"] = 31] = "Green1";
+    Card[Card["Green2"] = 32] = "Green2";
+    Card[Card["Green3"] = 33] = "Green3";
+    Card[Card["Green4"] = 34] = "Green4";
+    Card[Card["Green5"] = 35] = "Green5";
+    Card[Card["Green6"] = 36] = "Green6";
+    Card[Card["Green7"] = 37] = "Green7";
+    Card[Card["Green8"] = 38] = "Green8";
+    Card[Card["Green9"] = 39] = "Green9";
+    Card[Card["Orange1"] = 41] = "Orange1";
+    Card[Card["Orange2"] = 42] = "Orange2";
+    Card[Card["Orange3"] = 43] = "Orange3";
+    Card[Card["Orange4"] = 44] = "Orange4";
+    Card[Card["Orange5"] = 45] = "Orange5";
+    Card[Card["Orange6"] = 46] = "Orange6";
+    Card[Card["Orange7"] = 47] = "Orange7";
+    Card[Card["Orange8"] = 48] = "Orange8";
+    Card[Card["Orange9"] = 49] = "Orange9";
+    Card[Card["Pink1"] = 51] = "Pink1";
+    Card[Card["Pink2"] = 52] = "Pink2";
+    Card[Card["Pink3"] = 53] = "Pink3";
+    Card[Card["Pink4"] = 54] = "Pink4";
+    Card[Card["Pink5"] = 55] = "Pink5";
+    Card[Card["Pink6"] = 56] = "Pink6";
+    Card[Card["Pink7"] = 57] = "Pink7";
+    Card[Card["Pink8"] = 58] = "Pink8";
+    Card[Card["Pink9"] = 59] = "Pink9";
+    Card[Card["Brown1"] = 61] = "Brown1";
+    Card[Card["Brown2"] = 62] = "Brown2";
+    Card[Card["Brown3"] = 63] = "Brown3";
+    Card[Card["Brown4"] = 64] = "Brown4";
+    Card[Card["Brown5"] = 65] = "Brown5";
+    Card[Card["Brown6"] = 66] = "Brown6";
+    Card[Card["Brown7"] = 67] = "Brown7";
+    Card[Card["Brown8"] = 68] = "Brown8";
+    Card[Card["Brown9"] = 69] = "Brown9";
+})(Card = exports.Card || (exports.Card = {}));
+var CardColor;
+(function (CardColor) {
+    CardColor[CardColor["Blue"] = 1] = "Blue";
+    CardColor[CardColor["Red"] = 2] = "Red";
+    CardColor[CardColor["Green"] = 3] = "Green";
+    CardColor[CardColor["Orange"] = 4] = "Orange";
+    CardColor[CardColor["Pink"] = 5] = "Pink";
+    CardColor[CardColor["Brown"] = 6] = "Brown";
+})(CardColor = exports.CardColor || (exports.CardColor = {}));
+var getCardColor = function (card) { return Math.floor(card / 10); };
+exports.getCardColor = getCardColor;
+var getCardValue = function (card) { return card % 10; };
+exports.getCardValue = getCardValue;

package/dist/material/LocationType.d.ts

@@ -0,0 +1,10 @@
+export declare enum LocationType {
+    Deck = 1,
+    Hand = 2,
+    MiddleOfTable = 3,
+    Discard = 4
+}
+export declare enum MiddleOfTable {
+    Current = 1,
+    Next = 2
+}

package/dist/material/LocationType.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiddleOfTable = exports.LocationType = void 0;
+var LocationType;
+(function (LocationType) {
+    LocationType[LocationType["Deck"] = 1] = "Deck";
+    LocationType[LocationType["Hand"] = 2] = "Hand";
+    LocationType[LocationType["MiddleOfTable"] = 3] = "MiddleOfTable";
+    LocationType[LocationType["Discard"] = 4] = "Discard";
+})(LocationType = exports.LocationType || (exports.LocationType = {}));
+var MiddleOfTable;
+(function (MiddleOfTable) {
+    MiddleOfTable[MiddleOfTable["Current"] = 1] = "Current";
+    MiddleOfTable[MiddleOfTable["Next"] = 2] = "Next";
+})(MiddleOfTable = exports.MiddleOfTable || (exports.MiddleOfTable = {}));

package/dist/material/MaterialType.d.ts

@@ -0,0 +1,3 @@
+export declare enum MaterialType {
+    Card = 1
+}

package/dist/material/MaterialType.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaterialType = void 0;
+var MaterialType;
+(function (MaterialType) {
+    MaterialType[MaterialType["Card"] = 1] = "Card";
+})(MaterialType = exports.MaterialType || (exports.MaterialType = {}));

package/dist/rules/BasePlayerTurn.d.ts

@@ -0,0 +1,5 @@
+import { PlayerTurnRule } from '@gamepark/rules-api';
+export declare class BasePlayerTurn extends PlayerTurnRule {
+    get nextPlayer(): number;
+    get firstPlayer(): number;
+}

package/dist/rules/BasePlayerTurn.js

@@ -0,0 +1,52 @@
+"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.BasePlayerTurn = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var orderBy_1 = __importDefault(require("lodash/orderBy"));
+var Memory_1 = require("./Memory");
+var BasePlayerTurn = (function (_super) {
+    __extends(BasePlayerTurn, _super);
+    function BasePlayerTurn() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(BasePlayerTurn.prototype, "nextPlayer", {
+        get: function () {
+            var _this = this;
+            var playerIndex = this.game.players.indexOf(this.firstPlayer);
+            var players = (0, orderBy_1.default)(this.game.players, function (id) {
+                var index = _this.game.players.indexOf(id);
+                return (index - playerIndex + _this.game.players.length) % _this.game.players.length;
+            });
+            return players[(players.indexOf(this.player) + 1) % players.length];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(BasePlayerTurn.prototype, "firstPlayer", {
+        get: function () {
+            return this.remind(Memory_1.Memory.FirstPlayer);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BasePlayerTurn;
+}(rules_api_1.PlayerTurnRule));
+exports.BasePlayerTurn = BasePlayerTurn;

package/dist/rules/CustomMoveType.d.ts

@@ -0,0 +1,5 @@
+export declare enum CustomMoveType {
+    Pass = 1,
+    TurnTempo = 2,
+    SortHand = 3
+}

package/dist/rules/CustomMoveType.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomMoveType = void 0;
+var CustomMoveType;
+(function (CustomMoveType) {
+    CustomMoveType[CustomMoveType["Pass"] = 1] = "Pass";
+    CustomMoveType[CustomMoveType["TurnTempo"] = 2] = "TurnTempo";
+    CustomMoveType[CustomMoveType["SortHand"] = 3] = "SortHand";
+})(CustomMoveType = exports.CustomMoveType || (exports.CustomMoveType = {}));

package/dist/rules/DealCardsRule.d.ts

@@ -0,0 +1,8 @@
+import { ItemMove, MaterialMove, MaterialRulesPart } from '@gamepark/rules-api';
+export declare class DealCardsRule extends MaterialRulesPart {
+    onRuleStart(): MaterialMove<number, number, number, number>[];
+    afterItemMove(move: ItemMove): MaterialMove[];
+    dealToPlayersAndGo(): MaterialMove[];
+    get deck(): import("@gamepark/rules-api").MaterialDeck<number, number, number>;
+    get discard(): import("@gamepark/rules-api").Material<number, number, number>;
+}

package/dist/rules/DealCardsRule.js

@@ -0,0 +1,124 @@
+"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.DealCardsRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var LocationType_1 = require("../material/LocationType");
+var MaterialType_1 = require("../material/MaterialType");
+var Memory_1 = require("./Memory");
+var RuleId_1 = require("./RuleId");
+var DealCardsRule = (function (_super) {
+    __extends(DealCardsRule, _super);
+    function DealCardsRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    DealCardsRule.prototype.onRuleStart = function () {
+        var discard = this.discard;
+        var moves = [];
+        if (!discard.length) {
+            moves.push.apply(moves, __spreadArray([], __read(this.dealToPlayersAndGo()), false));
+            return moves;
+        }
+        moves.push(discard.moveItemsAtOnce({
+            type: LocationType_1.LocationType.Deck
+        }));
+        moves.push(this.material(MaterialType_1.MaterialType.Card).shuffle());
+        return moves;
+    };
+    DealCardsRule.prototype.afterItemMove = function (move) {
+        if (!(0, rules_api_1.isShuffleItemType)(MaterialType_1.MaterialType.Card)(move))
+            return [];
+        return this.dealToPlayersAndGo();
+    };
+    DealCardsRule.prototype.dealToPlayersAndGo = function () {
+        var e_1, _a;
+        var moves = [];
+        var deck = this.deck;
+        for (var i = 0; i < 9; i++) {
+            try {
+                for (var _b = (e_1 = void 0, __values(this.game.players)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var player = _c.value;
+                    moves.push.apply(moves, __spreadArray([], __read(deck.deal({
+                        type: LocationType_1.LocationType.Hand,
+                        player: player
+                    })), false));
+                }
+            }
+            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; }
+            }
+        }
+        moves.push(this.startPlayerTurn(RuleId_1.RuleId.PlayCards, this.remind(Memory_1.Memory.FirstPlayer)));
+        return moves;
+    };
+    Object.defineProperty(DealCardsRule.prototype, "deck", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.Card).location(LocationType_1.LocationType.Deck).deck();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DealCardsRule.prototype, "discard", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.Card).location(LocationType_1.LocationType.Discard);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return DealCardsRule;
+}(rules_api_1.MaterialRulesPart));
+exports.DealCardsRule = DealCardsRule;

package/dist/rules/EndOfRoundRule.d.ts

@@ -0,0 +1,10 @@
+import { ItemMove, MaterialMove, MaterialRulesPart } from '@gamepark/rules-api';
+import { PlayerId } from '../PlayerId';
+export declare class EndOfRoundRule extends MaterialRulesPart {
+    onRuleStart(): MaterialMove<number, number, number, number>[];
+    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>[];
+    get newFirstPlayer(): PlayerId;
+    get firstPlayer(): number;
+}

package/dist/rules/EndOfRoundRule.js

@@ -0,0 +1,107 @@
+"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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndOfRoundRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var LocationType_1 = require("../material/LocationType");
+var MaterialType_1 = require("../material/MaterialType");
+var Memory_1 = require("./Memory");
+var RuleId_1 = require("./RuleId");
+var EndOfRoundRule = (function (_super) {
+    __extends(EndOfRoundRule, _super);
+    function EndOfRoundRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    EndOfRoundRule.prototype.onRuleStart = function () {
+        var moves = [];
+        moves.push.apply(moves, __spreadArray([], __read(this.groupToDeckMove), false));
+        return moves;
+    };
+    Object.defineProperty(EndOfRoundRule.prototype, "deck", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.Card).location(LocationType_1.LocationType.Deck).deck();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EndOfRoundRule.prototype, "groupToDeckMove", {
+        get: function () {
+            var moves = [];
+            moves.push(this.material(MaterialType_1.MaterialType.Card)
+                .location(function (l) { return l.type !== LocationType_1.LocationType.Deck; })
+                .moveItemsAtOnce({
+                type: LocationType_1.LocationType.Deck
+            }));
+            return moves;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    EndOfRoundRule.prototype.afterItemMove = function (move) {
+        var moves = [];
+        if ((0, rules_api_1.isMoveItemTypeAtOnce)(MaterialType_1.MaterialType.Card)(move) && move.location.type === LocationType_1.LocationType.Deck) {
+            moves.push(this.deck.shuffle());
+        }
+        if ((0, rules_api_1.isShuffleItemType)(MaterialType_1.MaterialType.Card)(move)) {
+            var newFirstPlayer = this.newFirstPlayer;
+            this.memorize(Memory_1.Memory.FirstPlayer, newFirstPlayer);
+            moves.push(this.startRule(RuleId_1.RuleId.DealCards));
+        }
+        return moves;
+    };
+    Object.defineProperty(EndOfRoundRule.prototype, "newFirstPlayer", {
+        get: function () {
+            return this.game.players[(this.game.players.indexOf(this.firstPlayer) + 1) % this.game.players.length];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EndOfRoundRule.prototype, "firstPlayer", {
+        get: function () {
+            return this.remind(Memory_1.Memory.FirstPlayer);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return EndOfRoundRule;
+}(rules_api_1.MaterialRulesPart));
+exports.EndOfRoundRule = EndOfRoundRule;

package/dist/rules/Memory.d.ts

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

package/dist/rules/Memory.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memory = void 0;
+var Memory;
+(function (Memory) {
+    Memory[Memory["PlayedCards"] = 1] = "PlayedCards";
+    Memory[Memory["FirstPlayer"] = 2] = "FirstPlayer";
+    Memory[Memory["LastPlayerThatPlay"] = 3] = "LastPlayerThatPlay";
+    Memory[Memory["HandSort"] = 4] = "HandSort";
+})(Memory = exports.Memory || (exports.Memory = {}));

package/dist/rules/PickCardRule.d.ts

@@ -0,0 +1,10 @@
+import { MaterialMove, MoveItem } from '@gamepark/rules-api';
+import { BasePlayerTurn } from './BasePlayerTurn';
+export declare class PickCardRule extends BasePlayerTurn {
+    onRuleStart(): MaterialMove<number, number, number, number>[];
+    getPlayerMoves(): MaterialMove[];
+    afterItemMove(move: MoveItem): MaterialMove<number, number, number, number>[];
+    goToNextRule(): MaterialMove<number, number, number, number>[];
+    get currentTable(): import("@gamepark/rules-api").Material<number, number, number>;
+    get nextTable(): import("@gamepark/rules-api").Material<number, number, number>;
+}

package/dist/rules/PickCardRule.js

@@ -0,0 +1,78 @@
+"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 __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PickCardRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var LocationType_1 = require("../material/LocationType");
+var MaterialType_1 = require("../material/MaterialType");
+var BasePlayerTurn_1 = require("./BasePlayerTurn");
+var RuleId_1 = require("./RuleId");
+var PickCardRule = (function (_super) {
+    __extends(PickCardRule, _super);
+    function PickCardRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PickCardRule.prototype.onRuleStart = function () {
+        if (this.getPlayerMoves().length)
+            return [];
+        return this.goToNextRule();
+    };
+    PickCardRule.prototype.getPlayerMoves = function () {
+        return this.currentTable.moveItems({
+            type: LocationType_1.LocationType.Hand,
+            player: this.player
+        });
+    };
+    PickCardRule.prototype.afterItemMove = function (move) {
+        if (!(0, rules_api_1.isMoveItemType)(MaterialType_1.MaterialType.Card)(move) || move.location.type !== LocationType_1.LocationType.Hand)
+            return [];
+        return this.goToNextRule();
+    };
+    PickCardRule.prototype.goToNextRule = function () {
+        var moves = [];
+        var currentTable = this.currentTable;
+        if (currentTable.length) {
+            moves.push(this.currentTable.moveItemsAtOnce({
+                type: LocationType_1.LocationType.Discard
+            }));
+        }
+        var nextTable = this.nextTable;
+        if (nextTable.length) {
+            moves.push(this.nextTable.moveItemsAtOnce({
+                id: LocationType_1.MiddleOfTable.Current
+            }));
+        }
+        moves.push(this.startPlayerTurn(RuleId_1.RuleId.PlayCards, this.nextPlayer));
+        return moves;
+    };
+    Object.defineProperty(PickCardRule.prototype, "currentTable", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.Card).location(LocationType_1.LocationType.MiddleOfTable).locationId(LocationType_1.MiddleOfTable.Current);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PickCardRule.prototype, "nextTable", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.Card).location(LocationType_1.LocationType.MiddleOfTable).locationId(LocationType_1.MiddleOfTable.Next);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return PickCardRule;
+}(BasePlayerTurn_1.BasePlayerTurn));
+exports.PickCardRule = PickCardRule;

package/dist/rules/PlayCardsRule.d.ts

@@ -0,0 +1,19 @@
+import { CustomMove, ItemMove, MaterialItem, MaterialMove } from '@gamepark/rules-api';
+import { Card } from '../material/Card';
+import { BasePlayerTurn } from './BasePlayerTurn';
+export declare class PlayCardsRule extends BasePlayerTurn {
+    getPlayerMoves(): MaterialMove<number, number, number, number>[];
+    get sort(): ((item: MaterialItem) => number)[];
+    get tableValue(): number;
+    onCustomMove(move: CustomMove): MaterialMove<number, number, number, number>[];
+    afterItemMove(move: ItemMove): MaterialMove<number, number, number, number>[];
+    goToNextPlayer(): MaterialMove<number, number, number, number>[];
+    afterPlaceCards(): MaterialMove<number, number, number, number>[];
+    get firstPlayer(): number;
+    get table(): import("@gamepark/rules-api").Material<number, number, number>;
+    get playableCards(): import("@gamepark/rules-api").Material<number, number, number>;
+    get hand(): import("@gamepark/rules-api").Material<number, number, number>;
+    kCombinations<T>(arr: T[], k: number): T[][];
+    concatCardValue(cards: Card[]): number;
+    getPlayableCombinations(hand: Card[], tableCount: number, tableValue: number): Card[][];
+}

package/dist/rules/PlayCardsRule.js

@@ -0,0 +1,289 @@
+"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.");
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlayCardsRule = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var groupBy_1 = __importDefault(require("lodash/groupBy"));
+var isEqual_1 = __importDefault(require("lodash/isEqual"));
+var orderBy_1 = __importDefault(require("lodash/orderBy"));
+var uniqWith_1 = __importDefault(require("lodash/uniqWith"));
+var Card_1 = require("../material/Card");
+var LocationType_1 = require("../material/LocationType");
+var MaterialType_1 = require("../material/MaterialType");
+var BasePlayerTurn_1 = require("./BasePlayerTurn");
+var CustomMoveType_1 = require("./CustomMoveType");
+var Memory_1 = require("./Memory");
+var RuleId_1 = require("./RuleId");
+var PlayCardsRule = (function (_super) {
+    __extends(PlayCardsRule, _super);
+    function PlayCardsRule() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    PlayCardsRule.prototype.getPlayerMoves = function () {
+        var _this = this;
+        var playableCards = this.playableCards;
+        var table = this.table;
+        var tableSize = table.length;
+        var moves = [];
+        var combinations = this.getPlayableCombinations(playableCards.getItems().map(function (item) { return item.id; }), tableSize, this.tableValue);
+        var allHandCombination = this.getPlayableCombinations(playableCards.getItems().map(function (item) { return item.id; }), playableCards.length, this.tableValue);
+        if (allHandCombination.length) {
+            moves.push.apply(moves, __spreadArray([], __read(allHandCombination.map(function (c) {
+                var _a;
+                return (_a = _this.hand
+                    .id(function (id) { return c.includes(id); }))
+                    .sort.apply(_a, __spreadArray([], __read(_this.sort), false)).moveItemsAtOnce({
+                    type: LocationType_1.LocationType.MiddleOfTable,
+                    id: LocationType_1.MiddleOfTable.Next
+                });
+            })), false));
+        }
+        moves.push.apply(moves, __spreadArray([], __read(combinations.map(function (c) {
+            var _a;
+            return (_a = _this.hand
+                .id(function (id) { return c.includes(id); }))
+                .sort.apply(_a, __spreadArray([], __read(_this.sort), false)).moveItemsAtOnce({
+                type: LocationType_1.LocationType.MiddleOfTable,
+                id: LocationType_1.MiddleOfTable.Next
+            });
+        })), false));
+        if (table.length) {
+            moves.push(this.customMove(CustomMoveType_1.CustomMoveType.Pass));
+        }
+        return moves;
+    };
+    Object.defineProperty(PlayCardsRule.prototype, "sort", {
+        get: function () {
+            return [function (item) { return -(0, Card_1.getCardValue)(item.id); }, function (item) { return (0, Card_1.getCardColor)(item.id); }];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PlayCardsRule.prototype, "tableValue", {
+        get: function () {
+            var table = this.table;
+            return !table.length ? 0 : this.concatCardValue(table.getItems().map(function (item) { return item.id; }));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PlayCardsRule.prototype.onCustomMove = function (move) {
+        if (!(0, rules_api_1.isCustomMoveType)(CustomMoveType_1.CustomMoveType.Pass)(move))
+            return [];
+        var moves = this.afterPlaceCards();
+        moves.push.apply(moves, __spreadArray([], __read(this.goToNextPlayer()), false));
+        return moves;
+    };
+    PlayCardsRule.prototype.afterItemMove = function (move) {
+        if (!(0, rules_api_1.isMoveItemTypeAtOnce)(MaterialType_1.MaterialType.Card)(move) || move.location.type !== LocationType_1.LocationType.MiddleOfTable)
+            return [];
+        var moves = this.afterPlaceCards();
+        this.memorize(Memory_1.Memory.LastPlayerThatPlay, this.player);
+        var isEndOfRound = this.hand.length === 0;
+        moves.push(this.customMove(CustomMoveType_1.CustomMoveType.TurnTempo, isEndOfRound));
+        if (this.hand.length === 0) {
+            moves.push(this.startRule(RuleId_1.RuleId.EndOfRound));
+        }
+        else {
+            moves.push(this.startRule(RuleId_1.RuleId.PickCard));
+        }
+        return moves;
+    };
+    PlayCardsRule.prototype.goToNextPlayer = function () {
+        var next = this.nextPlayer;
+        var moves = [];
+        var lastPlayerThatPlay = this.remind(Memory_1.Memory.LastPlayerThatPlay);
+        if (lastPlayerThatPlay && next === lastPlayerThatPlay) {
+            this.forget(Memory_1.Memory.LastPlayerThatPlay);
+            var table = this.table;
+            if (table.length) {
+                moves.push(this.table.moveItemsAtOnce({
+                    type: LocationType_1.LocationType.Discard
+                }));
+            }
+            moves.push(this.startPlayerTurn(RuleId_1.RuleId.PlayCards, next));
+            return moves;
+        }
+        else {
+            moves.push(this.startPlayerTurn(RuleId_1.RuleId.PlayCards, this.nextPlayer));
+        }
+        return moves;
+    };
+    PlayCardsRule.prototype.afterPlaceCards = function () {
+        var e_1, _a;
+        var moves = [];
+        var selected = this.material(MaterialType_1.MaterialType.Card).selected().getItems();
+        try {
+            for (var selected_1 = __values(selected), selected_1_1 = selected_1.next(); !selected_1_1.done; selected_1_1 = selected_1.next()) {
+                var item = selected_1_1.value;
+                delete item.selected;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (selected_1_1 && !selected_1_1.done && (_a = selected_1.return)) _a.call(selected_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return moves;
+    };
+    Object.defineProperty(PlayCardsRule.prototype, "firstPlayer", {
+        get: function () {
+            return this.remind(Memory_1.Memory.FirstPlayer);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PlayCardsRule.prototype, "table", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.Card).location(LocationType_1.LocationType.MiddleOfTable).locationId(LocationType_1.MiddleOfTable.Current);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PlayCardsRule.prototype, "playableCards", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.Card).location(LocationType_1.LocationType.Hand).player(this.player);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(PlayCardsRule.prototype, "hand", {
+        get: function () {
+            return this.material(MaterialType_1.MaterialType.Card).location(LocationType_1.LocationType.Hand).player(this.player);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PlayCardsRule.prototype.kCombinations = function (arr, k) {
+        if (k === 0)
+            return [[]];
+        if (arr.length < k)
+            return [];
+        if (arr.length === k)
+            return [arr];
+        var _a = __read(arr), first = _a[0], rest = _a.slice(1);
+        return __spreadArray(__spreadArray([], __read(this.kCombinations(rest, k)), false), __read(this.kCombinations(rest, k - 1).map(function (comb) { return __spreadArray([first], __read(comb), false); })), false);
+    };
+    PlayCardsRule.prototype.concatCardValue = function (cards) {
+        var values = cards.map(function (card) { return (0, Card_1.getCardValue)(card); }).sort(function (a, b) { return (0, Card_1.getCardValue)(b) - (0, Card_1.getCardValue)(a); });
+        return parseInt(values.join(''), 10);
+    };
+    PlayCardsRule.prototype.getPlayableCombinations = function (hand, tableCount, tableValue) {
+        var e_2, _a, e_3, _b, e_4, _c, e_5, _d;
+        var results = [];
+        var byColor = (0, groupBy_1.default)(hand, function (card) { return card % 10; });
+        var byValue = (0, groupBy_1.default)(hand, function (card) { return Math.floor(card / 10); });
+        try {
+            for (var _e = __values([byColor, byValue]), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var group = _f.value;
+                try {
+                    for (var _g = (e_3 = void 0, __values(Object.values(group))), _h = _g.next(); !_h.done; _h = _g.next()) {
+                        var cards = _h.value;
+                        try {
+                            for (var _j = (e_4 = void 0, __values([tableCount, tableCount + 1])), _k = _j.next(); !_k.done; _k = _j.next()) {
+                                var count = _k.value;
+                                if (cards.length >= count) {
+                                    try {
+                                        for (var _l = (e_5 = void 0, __values(this.kCombinations(cards, count))), _m = _l.next(); !_m.done; _m = _l.next()) {
+                                            var comb = _m.value;
+                                            if (this.concatCardValue(comb) > tableValue) {
+                                                results.push(comb);
+                                            }
+                                        }
+                                    }
+                                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                                    finally {
+                                        try {
+                                            if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
+                                        }
+                                        finally { if (e_5) throw e_5.error; }
+                                    }
+                                }
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                            }
+                            finally { if (e_4) throw e_4.error; }
+                        }
+                    }
+                }
+                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                finally {
+                    try {
+                        if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                    }
+                    finally { if (e_3) throw e_3.error; }
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        var unique = (0, uniqWith_1.default)(results, function (a, b) { return (0, isEqual_1.default)((0, orderBy_1.default)(a), (0, orderBy_1.default)(b)); });
+        return unique;
+    };
+    return PlayCardsRule;
+}(BasePlayerTurn_1.BasePlayerTurn));
+exports.PlayCardsRule = PlayCardsRule;

package/dist/rules/RuleId.d.ts

@@ -0,0 +1,6 @@
+export declare enum RuleId {
+    PlayCards = 1,
+    PickCard = 2,
+    EndOfRound = 3,
+    DealCards = 4
+}

package/dist/rules/RuleId.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuleId = void 0;
+var RuleId;
+(function (RuleId) {
+    RuleId[RuleId["PlayCards"] = 1] = "PlayCards";
+    RuleId[RuleId["PickCard"] = 2] = "PickCard";
+    RuleId[RuleId["EndOfRound"] = 3] = "EndOfRound";
+    RuleId[RuleId["DealCards"] = 4] = "DealCards";
+})(RuleId = exports.RuleId || (exports.RuleId = {}));

package/dist/rules/Sort.d.ts

@@ -0,0 +1,5 @@
+export declare enum Sort {
+    Color = 1,
+    ValueAsc = 2,
+    ValueDesc = 3
+}

package/dist/rules/Sort.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sort = void 0;
+var Sort;
+(function (Sort) {
+    Sort[Sort["Color"] = 1] = "Color";
+    Sort[Sort["ValueAsc"] = 2] = "ValueAsc";
+    Sort[Sort["ValueDesc"] = 3] = "ValueDesc";
+})(Sort = exports.Sort || (exports.Sort = {}));

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@gamepark/odin",
+  "version": "0.0.1",
+  "description": "The rules of Odin adapted for Game Park",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "author": "Romain Fromi <romain@game-park.com> (https://game-park.com/)",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "tsc",
+    "publish": "lerna publish",
+    "lint": "eslint --fix"
+  },
+  "peerDependencies": {
+    "@gamepark/rules-api": ">=6.33",
+    "lodash": ">=4.17"
+  },
+  "devDependencies": {
+    "@gamepark/rules-api": "~6.37.1",
+    "@types/lodash": "^4.17.7",
+    "i18next": "^22.0.3",
+    "lodash": "^4.17.21"
+  },
+  "gitHead": "b29d409632381911a0d74c1b6756a80016d81d1e"
+}