@gamepark/react-game 6.38.4 → 7.0.0-beta.0

package/dist/locators/HexagonalGridLocator.js

@@ -1,309 +1,304 @@
-"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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HexagonalGridLocator = exports.HexOrientation = void 0;
-var rules_api_1 = require("@gamepark/rules-api");
-var findLastIndex_1 = __importDefault(require("lodash/findLastIndex"));
-var isEqual_1 = __importDefault(require("lodash/isEqual"));
-var omit_1 = __importDefault(require("lodash/omit"));
-var uniqWith_1 = __importDefault(require("lodash/uniqWith"));
-var components_1 = require("../components");
-var Locator_1 = require("./Locator");
-var HexOrientation;
-(function (HexOrientation) {
-    HexOrientation[HexOrientation["Flat"] = 1] = "Flat";
-    HexOrientation[HexOrientation["Pointy"] = 2] = "Pointy";
-})(HexOrientation = exports.HexOrientation || (exports.HexOrientation = {}));
-/**
- * This locator is responsible for placing locations and items on a hexagonal grid.
- */
-var HexagonalGridLocator = /** @class */ (function (_super) {
-    __extends(HexagonalGridLocator, _super);
-    function HexagonalGridLocator() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.dropPreview = true;
-        return _this;
-    }
-    Object.defineProperty(HexagonalGridLocator.prototype, "sizeX", {
-        /**
-         * Horizontal size of a hexagon
-         */
-        get: function () {
-            return typeof this.size === 'number' ? this.size : this.size.x;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(HexagonalGridLocator.prototype, "sizeY", {
-        /**
-         * Vertical size of a hexagon
-         */
-        get: function () {
-            return typeof this.size === 'number' ? this.size : this.size.y;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * Override if you need a dynamic drop area
-     * @param _location The location to consider
-     * @param _context Context of the game
-     * @return the current drop area
-     */
-    HexagonalGridLocator.prototype.getDropArea = function (_location, _context) {
-        return this.dropArea;
-    };
-    /**
-     * Get the coordinates for the full grid area
-     * @param location Location to place
-     * @param context Context of the game
-     * @returns The coordinates of the area
-     */
-    HexagonalGridLocator.prototype.getAreaCoordinates = function (location, context) {
-        var _a = this.getCoordinates(location, context), _b = _a.x, x = _b === void 0 ? 0 : _b, _c = _a.y, y = _c === void 0 ? 0 : _c, z = _a.z;
-        var dropArea = this.getDropArea(location, context);
-        if (!dropArea)
-            return { x: x, y: y, z: z };
-        var _d = this.getBoundaries(dropArea), xMin = _d.xMin, xMax = _d.xMax, yMin = _d.yMin, yMax = _d.yMax;
-        return { x: (xMin + xMax) / 2, y: (yMin + yMax) / 2, z: z };
-    };
-    /**
-     * Get the coordinates of a location on the grid
-     * @param location Location to place
-     * @param context Context of the game
-     * @return the coordinates
-     */
-    HexagonalGridLocator.prototype.getLocationCoordinates = function (location, context) {
-        if (location.x === undefined && location.y === undefined) {
-            return this.getAreaCoordinates(location, context);
-        }
-        var _a = this.getCoordinates(location, context), _b = _a.x, baseX = _b === void 0 ? 0 : _b, _c = _a.y, baseY = _c === void 0 ? 0 : _c, baseZ = _a.z;
-        var _d = this.getHexagonPosition(location), _e = _d.x, x = _e === void 0 ? 0 : _e, _f = _d.y, y = _f === void 0 ? 0 : _f;
-        return { x: baseX + x, y: baseY + y, z: baseZ };
-    };
-    /**
-     * Get the position of a hexagon
-     * @param coordinates Coordinates of the hexagon
-     * @param coordinatesSystem System of coordinates to consider
-     * @return coordinates to place the hexagon on the location
-     */
-    HexagonalGridLocator.prototype.getHexagonPosition = function (coordinates, coordinatesSystem) {
-        if (coordinatesSystem === void 0) { coordinatesSystem = this.coordinatesSystem; }
-        var _a = coordinates.x, x = _a === void 0 ? 0 : _a, _b = coordinates.y, y = _b === void 0 ? 0 : _b;
-        switch (coordinatesSystem) {
-            case rules_api_1.HexGridSystem.Axial: {
-                if (!this.orientation) {
-                    throw new Error('You must specify the orientation (flat or pointy) when using the Axial HexGridSystem');
-                }
-                else if (this.orientation === HexOrientation.Flat) {
-                    return {
-                        x: x * 3 / 2 * this.sizeX,
-                        y: (x * Math.sqrt(3) / 2 + y * Math.sqrt(3)) * this.sizeY
-                    };
-                }
-                else {
-                    return {
-                        x: (x * Math.sqrt(3) + y * Math.sqrt(3) / 2) * this.sizeX,
-                        y: y * 3 / 2 * this.sizeY
-                    };
-                }
-            }
-            case rules_api_1.HexGridSystem.OddQ: {
-                y += ((x % 2 + 2) % 2) / 2;
-                return {
-                    x: x * 3 / 2 * this.sizeX,
-                    y: y * Math.sqrt(3) * this.sizeY
-                };
-            }
-            case rules_api_1.HexGridSystem.EvenQ: {
-                y -= ((x % 2 + 2) % 2) / 2;
-                return {
-                    x: x * 3 / 2 * this.sizeX,
-                    y: y * Math.sqrt(3) * this.sizeY
-                };
-            }
-            case rules_api_1.HexGridSystem.OddR: {
-                throw new Error('OddR HexGridSystem is not yet implemented');
-            }
-            case rules_api_1.HexGridSystem.EvenR: {
-                throw new Error('EvenR HexGridSystem is not yet implemented');
-            }
-        }
-    };
-    /**
-     * Get the coordinates of an item on the grid. If the item is a Polyhex, the shape will be used to center the origin coordinates of the item on the
-     * correct grid location.
-     * @param item Item to place
-     * @param context Context of the game
-     * @return the coordinates of the item
-     */
-    HexagonalGridLocator.prototype.getItemCoordinates = function (item, context) {
-        var _a = _super.prototype.getItemCoordinates.call(this, item, context), _b = _a.x, x = _b === void 0 ? 0 : _b, _c = _a.y, y = _c === void 0 ? 0 : _c, z = _a.z;
-        var description = context.material[context.type];
-        if (!description || !(0, components_1.isPolyhexDescription)(description)) {
-            return { x: x, y: y, z: z };
-        }
-        var polyhex = description.getPolyhex(item, context);
-        var _d = this.getBoundaries(polyhex), xMax = _d.xMax, xMin = _d.xMin, yMin = _d.yMin, yMax = _d.yMax;
-        var _e = rotateVector({ x: (xMin + xMax) / 2, y: (yMin + yMax) / 2 }, this.getItemRotateZ(item, context)), deltaX = _e.x, deltaY = _e.y;
-        return { x: x + deltaX, y: y + deltaY, z: z };
-    };
-    /**
-     * Rotate the location. On a hexagonal grid, by default the rotation is expected to be [0, 5] and it is multiplied by 60 degrees.
-     * @param location Location to rotate
-     * @param _context Context of the item
-     * @return the location's rotation in degrees
-     */
-    HexagonalGridLocator.prototype.getRotateZ = function (location, _context) {
-        var _a;
-        // TODO: the real rotation depends on the sizeX / sizeY ratio for 1, 2, 4 & 5 rotations (custom override applied for King of Tokyo Duel)
-        return ((_a = location.rotation) !== null && _a !== void 0 ? _a : 0) * 60;
-    };
-    /**
-     * Returns the drop locations for current dragged item. The hexagonal grid must be one simple drop location.
-     */
-    HexagonalGridLocator.prototype.getDropLocations = function (moves, context) {
-        if (!this.locationDescription || this.locationDescription.ignoreCoordinates) {
-            return (0, uniqWith_1.default)(moves.map(function (move) { return (0, omit_1.default)(move.location, ['x', 'y', 'z', 'rotation']); }), isEqual_1.default);
-        }
-        else {
-            return _super.prototype.getDropLocations.call(this, moves, context);
-        }
-    };
-    /**
-     * Generate automatically a {@link HexGridDropAreaDescription} based on the grid boundaries
-     */
-    HexagonalGridLocator.prototype.getLocationDescription = function (location, context) {
-        if (this.locationDescription)
-            return this.locationDescription;
-        if (location.x !== undefined || location.y !== undefined)
-            return _super.prototype.getLocationDescription.call(this, location, context);
-        var dropArea = this.getDropArea(location, context);
-        if (!dropArea)
-            return _super.prototype.getLocationDescription.call(this, location, context);
-        var _a = this.getBoundaries(dropArea), xMin = _a.xMin, xMax = _a.xMax, yMin = _a.yMin, yMax = _a.yMax;
-        var borderRadius = this.sizeX / 3;
-        return new components_1.HexGridDropAreaDescription({
-            width: xMax - xMin,
-            height: yMax - yMin,
-            borderRadius: borderRadius
-        });
-    };
-    HexagonalGridLocator.prototype.getBoundaries = function (polyhex) {
-        var _this = this;
-        var boundaries = { xMin: 0, xMax: 0, yMin: 0, yMax: 0 };
-        if (!polyhex) {
-            return boundaries;
-        }
-        switch (polyhex.system) {
-            case rules_api_1.HexGridSystem.Axial: {
-                if (!this.orientation) {
-                    throw new Error('You must specify the orientation (flat or pointy) when using the Axial HexGridSystem');
-                }
-                else if (this.orientation === HexOrientation.Flat) {
-                    boundaries.xMin = polyhex.xMin * 3 / 2 * this.sizeX - this.sizeX;
-                    boundaries.xMax = polyhex.xMax * 3 / 2 * this.sizeX + this.sizeX;
-                    boundaries.yMin = Math.min.apply(Math, __spreadArray([], __read(polyhex.grid.map(function (line, index) {
-                        var xMin = polyhex.xMin + line.findIndex(function (value) { return !polyhex.isEmpty(value); });
-                        return (polyhex.yMin + index + xMin / 2 - 0.5) * Math.sqrt(3) * _this.sizeY;
-                    })), false));
-                    boundaries.yMax = Math.max.apply(Math, __spreadArray([], __read(polyhex.grid.map(function (line, index) {
-                        var xMax = polyhex.xMin + (0, findLastIndex_1.default)(line, function (value) { return !polyhex.isEmpty(value); });
-                        return (polyhex.yMin + index + xMax / 2 + 0.5) * Math.sqrt(3) * _this.sizeY;
-                    })), false));
-                }
-                else {
-                    throw new Error('Axial HexGridSystem for pointy top orientation is not yet implemented');
-                }
-                break;
-            }
-            case rules_api_1.HexGridSystem.OddQ:
-            case rules_api_1.HexGridSystem.EvenQ: {
-                boundaries.xMin = polyhex.xMin * 3 / 2 * this.sizeX - this.sizeX;
-                var xMax = Math.max.apply(Math, __spreadArray([], __read(polyhex.grid.map(function (line) { return line.length; })), false)) - 1;
-                boundaries.xMax = (xMax + polyhex.xMin) * 3 / 2 * this.sizeX + this.sizeX;
-                var swapSystem_1 = polyhex.xMin % 2 !== 0;
-                var yMin = polyhex.yMin - 0.5;
-                var firstLine = polyhex.grid[0];
-                if (polyhex.system === rules_api_1.HexGridSystem.OddQ && firstLine.every(function (value, y) { return polyhex.isEmpty(value) || (swapSystem_1 ? !(y % 2) : y % 2); })) {
-                    yMin += 0.5;
-                }
-                else if (polyhex.system === rules_api_1.HexGridSystem.EvenQ && firstLine.some(function (value, y) { return !polyhex.isEmpty(value) && (swapSystem_1 ? !(y % 2) : y % 2); })) {
-                    yMin -= 0.5;
-                }
-                boundaries.yMin = yMin * Math.sqrt(3) * this.sizeY;
-                var yMax = polyhex.grid.length + polyhex.yMin - 0.5;
-                var lastLine = polyhex.grid[polyhex.grid.length - 1];
-                if (polyhex.system === rules_api_1.HexGridSystem.OddQ && lastLine.some(function (value, y) { return !polyhex.isEmpty(value) && (swapSystem_1 ? !(y % 2) : y % 2); })) {
-                    yMax += 0.5;
-                }
-                else if (polyhex.system === rules_api_1.HexGridSystem.EvenQ && lastLine.every(function (value, y) { return polyhex.isEmpty(value) || (swapSystem_1 ? !(y % 2) : y % 2); })) {
-                    yMax -= 0.5;
-                }
-                boundaries.yMax = yMax * Math.sqrt(3) * this.sizeY;
-                break;
-            }
-            case rules_api_1.HexGridSystem.OddR: {
-                throw new Error('OddR HexGridSystem is not yet implemented');
-            }
-            case rules_api_1.HexGridSystem.EvenR: {
-                throw new Error('EvenR HexGridSystem is not yet implemented');
-            }
-        }
-        return boundaries;
-    };
-    return HexagonalGridLocator;
-}(Locator_1.Locator));
-exports.HexagonalGridLocator = HexagonalGridLocator;
-function rotateVector(vector, degrees) {
-    var rad = degrees * (Math.PI / 180);
-    var cos = Math.cos(rad);
-    var sin = Math.sin(rad);
-    return {
-        x: Math.round(10000 * (vector.x * cos - vector.y * sin)) / 10000,
-        y: Math.round(10000 * (vector.x * sin + vector.y * cos)) / 10000
-    };
-}
+"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.HexagonalGridLocator = exports.HexOrientation = void 0;
+var rules_api_1 = require("@gamepark/rules-api");
+var es_toolkit_1 = require("es-toolkit");
+var compat_1 = require("es-toolkit/compat");
+var components_1 = require("../components");
+var Locator_1 = require("./Locator");
+var HexOrientation;
+(function (HexOrientation) {
+    HexOrientation[HexOrientation["Flat"] = 1] = "Flat";
+    HexOrientation[HexOrientation["Pointy"] = 2] = "Pointy";
+})(HexOrientation || (exports.HexOrientation = HexOrientation = {}));
+/**
+ * This locator is responsible for placing locations and items on a hexagonal grid.
+ */
+var HexagonalGridLocator = /** @class */ (function (_super) {
+    __extends(HexagonalGridLocator, _super);
+    function HexagonalGridLocator() {
+        var _this = _super.apply(this, __spreadArray([], __read(arguments), false)) || this;
+        _this.dropPreview = true;
+        return _this;
+    }
+    Object.defineProperty(HexagonalGridLocator.prototype, "sizeX", {
+        /**
+         * Horizontal size of a hexagon
+         */
+        get: function () {
+            return typeof this.size === 'number' ? this.size : this.size.x;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(HexagonalGridLocator.prototype, "sizeY", {
+        /**
+         * Vertical size of a hexagon
+         */
+        get: function () {
+            return typeof this.size === 'number' ? this.size : this.size.y;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Override if you need a dynamic drop area
+     * @param _location The location to consider
+     * @param _context Context of the game
+     * @return the current drop area
+     */
+    HexagonalGridLocator.prototype.getDropArea = function (_location, _context) {
+        return this.dropArea;
+    };
+    /**
+     * Get the coordinates for the full grid area
+     * @param location Location to place
+     * @param context Context of the game
+     * @returns The coordinates of the area
+     */
+    HexagonalGridLocator.prototype.getAreaCoordinates = function (location, context) {
+        var _a = this.getCoordinates(location, context), _b = _a.x, x = _b === void 0 ? 0 : _b, _c = _a.y, y = _c === void 0 ? 0 : _c, z = _a.z;
+        var dropArea = this.getDropArea(location, context);
+        if (!dropArea)
+            return { x: x, y: y, z: z };
+        var _d = this.getBoundaries(dropArea), xMin = _d.xMin, xMax = _d.xMax, yMin = _d.yMin, yMax = _d.yMax;
+        return { x: (xMin + xMax) / 2, y: (yMin + yMax) / 2, z: z };
+    };
+    /**
+     * Get the coordinates of a location on the grid
+     * @param location Location to place
+     * @param context Context of the game
+     * @return the coordinates
+     */
+    HexagonalGridLocator.prototype.getLocationCoordinates = function (location, context) {
+        if (location.x === undefined && location.y === undefined) {
+            return this.getAreaCoordinates(location, context);
+        }
+        var _a = this.getCoordinates(location, context), _b = _a.x, baseX = _b === void 0 ? 0 : _b, _c = _a.y, baseY = _c === void 0 ? 0 : _c, baseZ = _a.z;
+        var _d = this.getHexagonPosition(location), _e = _d.x, x = _e === void 0 ? 0 : _e, _f = _d.y, y = _f === void 0 ? 0 : _f;
+        return { x: baseX + x, y: baseY + y, z: baseZ };
+    };
+    /**
+     * Get the position of a hexagon
+     * @param coordinates Coordinates of the hexagon
+     * @param coordinatesSystem System of coordinates to consider
+     * @return coordinates to place the hexagon on the location
+     */
+    HexagonalGridLocator.prototype.getHexagonPosition = function (coordinates, coordinatesSystem) {
+        if (coordinatesSystem === void 0) { coordinatesSystem = this.coordinatesSystem; }
+        var _a = coordinates.x, x = _a === void 0 ? 0 : _a, _b = coordinates.y, y = _b === void 0 ? 0 : _b;
+        switch (coordinatesSystem) {
+            case rules_api_1.HexGridSystem.Axial: {
+                if (!this.orientation) {
+                    throw new Error('You must specify the orientation (flat or pointy) when using the Axial HexGridSystem');
+                }
+                else if (this.orientation === HexOrientation.Flat) {
+                    return {
+                        x: x * 3 / 2 * this.sizeX,
+                        y: (x * Math.sqrt(3) / 2 + y * Math.sqrt(3)) * this.sizeY
+                    };
+                }
+                else {
+                    return {
+                        x: (x * Math.sqrt(3) + y * Math.sqrt(3) / 2) * this.sizeX,
+                        y: y * 3 / 2 * this.sizeY
+                    };
+                }
+            }
+            case rules_api_1.HexGridSystem.OddQ: {
+                y += ((x % 2 + 2) % 2) / 2;
+                return {
+                    x: x * 3 / 2 * this.sizeX,
+                    y: y * Math.sqrt(3) * this.sizeY
+                };
+            }
+            case rules_api_1.HexGridSystem.EvenQ: {
+                y -= ((x % 2 + 2) % 2) / 2;
+                return {
+                    x: x * 3 / 2 * this.sizeX,
+                    y: y * Math.sqrt(3) * this.sizeY
+                };
+            }
+            case rules_api_1.HexGridSystem.OddR: {
+                throw new Error('OddR HexGridSystem is not yet implemented');
+            }
+            case rules_api_1.HexGridSystem.EvenR: {
+                throw new Error('EvenR HexGridSystem is not yet implemented');
+            }
+        }
+    };
+    /**
+     * Get the coordinates of an item on the grid. If the item is a Polyhex, the shape will be used to center the origin coordinates of the item on the
+     * correct grid location.
+     * @param item Item to place
+     * @param context Context of the game
+     * @return the coordinates of the item
+     */
+    HexagonalGridLocator.prototype.getItemCoordinates = function (item, context) {
+        var _a = _super.prototype.getItemCoordinates.call(this, item, context), _b = _a.x, x = _b === void 0 ? 0 : _b, _c = _a.y, y = _c === void 0 ? 0 : _c, z = _a.z;
+        var description = context.material[context.type];
+        if (!description || !(0, components_1.isPolyhexDescription)(description)) {
+            return { x: x, y: y, z: z };
+        }
+        var polyhex = description.getPolyhex(item, context);
+        var _d = this.getBoundaries(polyhex), xMax = _d.xMax, xMin = _d.xMin, yMin = _d.yMin, yMax = _d.yMax;
+        var _e = rotateVector({ x: (xMin + xMax) / 2, y: (yMin + yMax) / 2 }, this.getItemRotateZ(item, context)), deltaX = _e.x, deltaY = _e.y;
+        return { x: x + deltaX, y: y + deltaY, z: z };
+    };
+    /**
+     * Rotate the location. On a hexagonal grid, by default the rotation is expected to be [0, 5] and it is multiplied by 60 degrees.
+     * @param location Location to rotate
+     * @param _context Context of the item
+     * @return the location's rotation in degrees
+     */
+    HexagonalGridLocator.prototype.getRotateZ = function (location, _context) {
+        var _a;
+        // TODO: the real rotation depends on the sizeX / sizeY ratio for 1, 2, 4 & 5 rotations (custom override applied for King of Tokyo Duel)
+        return ((_a = location.rotation) !== null && _a !== void 0 ? _a : 0) * 60;
+    };
+    /**
+     * Returns the drop locations for current dragged item. The hexagonal grid must be one simple drop location.
+     */
+    HexagonalGridLocator.prototype.getDropLocations = function (moves, context) {
+        if (!this.locationDescription || this.locationDescription.ignoreCoordinates) {
+            return (0, es_toolkit_1.uniqWith)(moves.map(function (move) { return (0, es_toolkit_1.omit)(move.location, ['x', 'y', 'z', 'rotation']); }), es_toolkit_1.isEqual);
+        }
+        else {
+            return _super.prototype.getDropLocations.call(this, moves, context);
+        }
+    };
+    /**
+     * Generate automatically a {@link HexGridDropAreaDescription} based on the grid boundaries
+     */
+    HexagonalGridLocator.prototype.getLocationDescription = function (location, context) {
+        if (this.locationDescription)
+            return this.locationDescription;
+        if (location.x !== undefined || location.y !== undefined)
+            return _super.prototype.getLocationDescription.call(this, location, context);
+        var dropArea = this.getDropArea(location, context);
+        if (!dropArea)
+            return _super.prototype.getLocationDescription.call(this, location, context);
+        var _a = this.getBoundaries(dropArea), xMin = _a.xMin, xMax = _a.xMax, yMin = _a.yMin, yMax = _a.yMax;
+        var borderRadius = this.sizeX / 3;
+        return new components_1.HexGridDropAreaDescription({
+            width: xMax - xMin,
+            height: yMax - yMin,
+            borderRadius: borderRadius
+        });
+    };
+    HexagonalGridLocator.prototype.getBoundaries = function (polyhex) {
+        var _this = this;
+        var boundaries = { xMin: 0, xMax: 0, yMin: 0, yMax: 0 };
+        if (!polyhex) {
+            return boundaries;
+        }
+        switch (polyhex.system) {
+            case rules_api_1.HexGridSystem.Axial: {
+                if (!this.orientation) {
+                    throw new Error('You must specify the orientation (flat or pointy) when using the Axial HexGridSystem');
+                }
+                else if (this.orientation === HexOrientation.Flat) {
+                    boundaries.xMin = polyhex.xMin * 3 / 2 * this.sizeX - this.sizeX;
+                    boundaries.xMax = polyhex.xMax * 3 / 2 * this.sizeX + this.sizeX;
+                    boundaries.yMin = Math.min.apply(Math, __spreadArray([], __read(polyhex.grid.map(function (line, index) {
+                        var xMin = polyhex.xMin + line.findIndex(function (value) { return !polyhex.isEmpty(value); });
+                        return (polyhex.yMin + index + xMin / 2 - 0.5) * Math.sqrt(3) * _this.sizeY;
+                    })), false));
+                    boundaries.yMax = Math.max.apply(Math, __spreadArray([], __read(polyhex.grid.map(function (line, index) {
+                        var xMax = polyhex.xMin + (0, compat_1.findLastIndex)(line, function (value) { return !polyhex.isEmpty(value); });
+                        return (polyhex.yMin + index + xMax / 2 + 0.5) * Math.sqrt(3) * _this.sizeY;
+                    })), false));
+                }
+                else {
+                    throw new Error('Axial HexGridSystem for pointy top orientation is not yet implemented');
+                }
+                break;
+            }
+            case rules_api_1.HexGridSystem.OddQ:
+            case rules_api_1.HexGridSystem.EvenQ: {
+                boundaries.xMin = polyhex.xMin * 3 / 2 * this.sizeX - this.sizeX;
+                var xMax = Math.max.apply(Math, __spreadArray([], __read(polyhex.grid.map(function (line) { return line.length; })), false)) - 1;
+                boundaries.xMax = (xMax + polyhex.xMin) * 3 / 2 * this.sizeX + this.sizeX;
+                var swapSystem_1 = polyhex.xMin % 2 !== 0;
+                var yMin = polyhex.yMin - 0.5;
+                var firstLine = polyhex.grid[0];
+                if (polyhex.system === rules_api_1.HexGridSystem.OddQ && firstLine.every(function (value, y) { return polyhex.isEmpty(value) || (swapSystem_1 ? !(y % 2) : y % 2); })) {
+                    yMin += 0.5;
+                }
+                else if (polyhex.system === rules_api_1.HexGridSystem.EvenQ && firstLine.some(function (value, y) { return !polyhex.isEmpty(value) && (swapSystem_1 ? !(y % 2) : y % 2); })) {
+                    yMin -= 0.5;
+                }
+                boundaries.yMin = yMin * Math.sqrt(3) * this.sizeY;
+                var yMax = polyhex.grid.length + polyhex.yMin - 0.5;
+                var lastLine = polyhex.grid[polyhex.grid.length - 1];
+                if (polyhex.system === rules_api_1.HexGridSystem.OddQ && lastLine.some(function (value, y) { return !polyhex.isEmpty(value) && (swapSystem_1 ? !(y % 2) : y % 2); })) {
+                    yMax += 0.5;
+                }
+                else if (polyhex.system === rules_api_1.HexGridSystem.EvenQ && lastLine.every(function (value, y) { return polyhex.isEmpty(value) || (swapSystem_1 ? !(y % 2) : y % 2); })) {
+                    yMax -= 0.5;
+                }
+                boundaries.yMax = yMax * Math.sqrt(3) * this.sizeY;
+                break;
+            }
+            case rules_api_1.HexGridSystem.OddR: {
+                throw new Error('OddR HexGridSystem is not yet implemented');
+            }
+            case rules_api_1.HexGridSystem.EvenR: {
+                throw new Error('EvenR HexGridSystem is not yet implemented');
+            }
+        }
+        return boundaries;
+    };
+    return HexagonalGridLocator;
+}(Locator_1.Locator));
+exports.HexagonalGridLocator = HexagonalGridLocator;
+function rotateVector(vector, degrees) {
+    var rad = degrees * (Math.PI / 180);
+    var cos = Math.cos(rad);
+    var sin = Math.sin(rad);
+    return {
+        x: Math.round(10000 * (vector.x * cos - vector.y * sin)) / 10000,
+        y: Math.round(10000 * (vector.x * sin + vector.y * cos)) / 10000
+    };
+}
 //# sourceMappingURL=HexagonalGridLocator.js.map