# hexgrid
Tools for working with hex grid maps and coordinates.
Based in large part on the writings of [Amit Patel of Red Blob Games](https://www.redblobgames.com/grids/hexagons/).
## Usage
Install via your favorite package manager.
Each package supports CommonJS `require`, ESM `import`, and TypeScript usage.
You also have a choice: barrel imports or direct imports.
Barrel imports mean you're going to require/import everything from the same package-level namespace:
```typescript
// CommonJS
const { isPlainObject, isListOf } = require("@rickosborne/guard");
// ESM / TypeScript
import { isPlainObject, isListOf } from "@rickosborne/guard";
```
Implications:
- Nice and simple.
- Your build system needs to do tree-shaking well ... or you'll end up adding the entire package even if you only import two functions.
The other option is to use direct imports:
```typescript
// CommonJS
const { isPlainObject } = require("@rickosborne/guard/is-object");
const { isListOf } = require("@rickosborne/guard/is-list-of");
// ESM / TypeScript
import { isPlainObject } from "@rickosborne/guard/is-object.js";
import { isListOf } from "@rickosborne/guard/is-list-of.js";
```
Implications:
- You (probably) don't have to worry about tree-shaking as your build (likely) ends up with only the functions you need.
If you're using a modern build system, there aren't any strong reasons to prefer one way over the other.
It's really just down to your personal preference.
### A quick note about file extensions
Do you need to use file extensions?
And if so, which extensions?
Honestly ... this is a dumpster fire question.
It really comes down to your own setup and configuration.
Within each package itself:
- The CommonJS files all have `.cjs` extensions.
- The ESM files all have `.mjs` extensions.
- Node subpath exports have been set up to send `.js` imports to the `.cjs` (via `require`) or `.mjs` (via `import`) files, depending on your setup.
So, in theory, the only extension which _won't_ work would be `.ts` because the source isn't included.
If you run into a problem with a particular configuration, file a GitHub issue with:
- Your `tsconfig.json`'s `module`, `moduleResolution`, and `target` settings.
- Your `package.json`'s `type` and `imports` settings.
- An example of another package which imports correctly for you.
## License
This package is licensed as [CC-BY-NC-SA-4.0] unless otherwise noted.
That is, Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International.
[CC-BY-NC-SA-4.0]: https://creativecommons.org/licenses/by-nc-sa/4.0/
***
## API
### Functions
#### axialAdd
```typescript
axialAdd: (left: AxialPoint, right: AxialPoint) => AxialPoint
```
Add together two axial points to form a third.
#### axialFromCube
```typescript
axialFromCube: (cube: HexCubePoint) => AxialPoint
```
Rebrand a Cube point to an Axial point.
#### axialFromDoubleHeight
```typescript
axialFromDoubleHeight: (double: DoubleHeightPoint) => AxialPoint
```
#### axialFromDoubleWidth
```typescript
axialFromDoubleWidth: (double: DoubleWidthPoint) => AxialPoint
```
#### axialFromOffset
```typescript
axialFromOffset: (offset: OffsetPoint) => AxialPoint
```
#### axialFromQR
```typescript
axialFromQR: (q: number, r: number) => AxialPoint
```
#### axialIntersection
```typescript
axialIntersection: (center1: AxialPoint, radius1: number, center2: AxialPoint, radius2?: number) => AxialPoint[]
```
#### axialLerp
```typescript
axialLerp: (left: AxialPoint, right: AxialPoint, fraction01: number) => AxialPoint
```
#### axialLineDraw
```typescript
axialLineDraw: (left: AxialPoint, right: AxialPoint) => AxialPoint[]
```
#### axialNeighbor
```typescript
axialNeighbor: (axial: AxialPoint, direction: AxialDirection) => AxialPoint
```
#### axialRange
```typescript
axialRange: (center: AxialPoint, radius: number) => AxialPoint[]
```
#### axialRound
```typescript
axialRound: (axial: AxialPoint) => AxialPoint
```
#### axialSubtract
```typescript
axialSubtract: (left: AxialPoint, right: AxialPoint) => AxialPoint
```
Subtract one axial point from another.
#### bareQRS
```typescript
bareQRS: (q: number, r: number) => BareQRSPoint
```
#### bareQRSScale
```typescript
bareQRSScale: (point: BareQRSPoint, factor: number) => BareQRSPoint
```
#### bareQRSSubtract
```typescript
bareQRSSubtract: (left: BareQRSPoint, right: BareQRSPoint) => BareQRSPoint
```
#### coverRect
```typescript
coverRect: (width: number, height: number, layout: HexLayout) => QRWithXY[]
```
Generate a hex grid which completely covers a rectangle of the given dimensions.
#### cubeAdd
```typescript
cubeAdd: (left: HexCubePoint, right: HexCubePoint) => HexCubePoint
```
Add two Cube points together.
#### cubeDistance
```typescript
cubeDistance: (left: HexCubePoint, right: HexCubePoint) => number
```
Calculate the Manhattan distance between two points.
#### cubeFromAxial
```typescript
cubeFromAxial: (axial: AxialPoint) => HexCubePoint
```
Transform an Axial point into a Cube point by calculating and materializing `s`.
#### cubeFromDoubleHeight
```typescript
cubeFromDoubleHeight: (double: DoubleHeightPoint) => HexCubePoint
```
#### cubeFromDoubleWidth
```typescript
cubeFromDoubleWidth: (double: DoubleWidthPoint) => HexCubePoint
```
#### cubeFromQR
```typescript
cubeFromQR: (q: number, r: number) => HexCubePoint
```
Build a branded Cube point from `q` and `r` coordinates.
#### cubeHeading
```typescript
cubeHeading: (from: HexCubePoint, toward: HexCubePoint) => HexCubeDirection | undefined
```
#### cubeIntersection
```typescript
cubeIntersection: (center1: HexCubePoint, radius1: number, center2: HexCubePoint, radius2?: number) => HexCubePoint[]
```
#### cubeLerp
```typescript
cubeLerp: (a: HexCubePoint, b: HexCubePoint, frac: number) => HexCubePoint
```
#### cubeLineDraw
```typescript
cubeLineDraw: (a: HexCubePoint, b: HexCubePoint) => HexCubePoint[]
```
#### cubeNeighbor
```typescript
cubeNeighbor: (cube: HexCubePoint, direction: HexCubeDirection | CubeDiagDirection) => HexCubePoint
```
Find the neighbor of the given hex in the given direction.
#### cubeRange
```typescript
cubeRange: (center: HexCubePoint, radius: number) => HexCubePoint[]
```
#### cubeRotate
```typescript
cubeRotate: (center: HexCubePoint, outer: HexCubePoint, rotation: HexRotation) => HexCubePoint
```
#### cubeRound
```typescript
cubeRound: (cube: HexCubePoint) => HexCubePoint
```
#### cubeSubtract
```typescript
cubeSubtract: (left: HexCubePoint, right: HexCubePoint) => HexCubePoint
```
#### doubleHeightAdd
```typescript
doubleHeightAdd: (left: DoubleHeightPoint, right: DoubleHeightPoint) => DoubleHeightPoint
```
#### doubleHeightDistance
```typescript
doubleHeightDistance: (left: DoubleHeightPoint, right: DoubleHeightPoint) => number
```
#### doubleHeightFromQRS
```typescript
doubleHeightFromQRS: (qrs: BareQRSPoint) => DoubleHeightPoint
```
#### doubleHeightNeighbor
```typescript
doubleHeightNeighbor: (double: DoubleHeightPoint, direction: DoubleHeightDirection) => DoubleHeightPoint
```
#### doubleWidthAdd
```typescript
doubleWidthAdd: (left: DoubleWidthPoint, right: DoubleWidthPoint) => DoubleWidthPoint
```
#### doubleWidthDistance
```typescript
doubleWidthDistance: (left: DoubleWidthPoint, right: DoubleWidthPoint) => number
```
#### doubleWidthFromQRS
```typescript
doubleWidthFromQRS: (qrs: BareQRSPoint) => DoubleWidthPoint
```
#### doubleWidthNeighbor
```typescript
doubleWidthNeighbor: (double: DoubleWidthPoint, direction: DoubleWidthDirection) => DoubleWidthPoint
```
#### evenQFromQRS
```typescript
evenQFromQRS: (point: BareQRSPoint) => EvenQPoint
```
#### evenRFromQRS
```typescript
evenRFromQRS: (point: BareQRSPoint) => EvenRPoint
```
#### flatQRSFromPixel
```typescript
flatQRSFromPixel: , S extends QRSSystem>({ x, y }: {
x: number;
y: number;
}, builder: QRSBuilder
, scale?: number) => P
```
#### hexContainsChecker
```typescript
hexContainsChecker: (corners: PointXY[]) => (xy: PointXY) => boolean
```
Build a function which can check to see if the given pixel coordinates would be contained by the hex described by the corners. To be useful, cache this function, and then call it with pixel coordinates translated to the original hex's center.
#### hexCorners
```typescript
hexCorners: (qrs: BareQRSPoint, layout: HexLayout) => PointXY[]
```
#### hexCornersContainPoint
```typescript
hexCornersContainPoint: (corners: PointXY[], xy: PointXY) => boolean
```
#### hexDistance
```typescript
hexDistance: (left: BareQRSPoint, right: BareQRSPoint) => number
```
Calculate the Manhattan distance between two hex points.
#### hexesWithin
```typescript
hexesWithin: (radius: number) => number
```
How many hexes are reachable from a starting hex given a Manhattan distance radius?
#### hexEuclidDistance
```typescript
hexEuclidDistance: (left: BareQRSPoint, right: BareQRSPoint) => number
```
Euclidean distance between two hex points.
#### hexReachable
```typescript
hexReachable:
(start: P, steps: number, directions: Readonly[]>, adder: (left: P, right: P) => P, identity: (point: P) => Id, isBlocked: (point: P, id: Id) => boolean, onPoint?: ((point: P, distance: number, prior: P, direction: Readonly) => void) | undefined) => HexReachable
[]
```
#### lerp
```typescript
lerp: (a: number, b: number, frac: number) => number
```
Linear interpolate from `a` to `b` with `frac` fractional progress (percent complete, in the range `[0,1]`).
#### oddQFromQRS
```typescript
oddQFromQRS: (point: BareQRSPoint) => OddQPoint
```
#### oddRFromQRS
```typescript
oddRFromQRS: (point: BareQRSPoint) => OddRPoint
```
#### offsetDistance
```typescript
offsetDistance: (left: OffsetPoint, right: OffsetPoint) => number
```
#### offsetNeighbor
```typescript
offsetNeighbor: (offset: OffsetPoint, direction: OffsetDirection) => OffsetPoint
```
#### pixelFromFlatQRS
```typescript
pixelFromFlatQRS: ({ q, r }: BareQRSPoint, scale?: number) => PointXY
```
#### pixelFromPointyQRS
```typescript
pixelFromPointyQRS: ({ q, r }: BareQRSPoint, scale?: number) => PointXY
```
#### pixelFromQRS
```typescript
pixelFromQRS: ({ q, r }: BareQRSPoint, { orientation: { f0, f1, f2, f3 }, origin: { x: cx, y: cy }, size: { x: scaleX, y: scaleY } }: HexLayout) => PointXY
```
#### pixelOffsetOfCorner
```typescript
pixelOffsetOfCorner: (t: HexCorner, u: HexLayout) => Readonly
```
#### pointyQRSFromPixel
```typescript
pointyQRSFromPixel: , S extends QRSSystem>({ x, y }: {
x: number;
y: number;
}, builder: QRSBuilder
, scale?: number) => P
```
#### qrsEQ
```typescript
qrsEQ: (a: Readonly, b: Readonly) => boolean
```
#### qrsFromDoubleHeight
```typescript
qrsFromDoubleHeight: >(double: DoubleHeightPoint, builder: QRSBuilder) => P
```
#### qrsFromDoubleWidth
```typescript
qrsFromDoubleWidth: >(double: DoubleWidthPoint, builder: QRSBuilder
) => P
```
#### qrsFromPixel
```typescript
qrsFromPixel:
, S extends QRSSystem>({ x, y }: PointXY, { orientation: { b0, b1, b2, b3 }, origin: { x: cx, y: cy }, size: { x: scaleX, y: scaleY } }: HexLayout, builder: QRSBuilder
) => P
```
#### qrsHashCode
```typescript
qrsHashCode: ({ q, r }: BareQRSPoint) => bigint
```
Generate a (very simplistic) hash code for a hex point which could be used as a Map/Hash key.
#### qrsIntersection
```typescript
qrsIntersection:
>(buildFn: QRSBuilder
, center1: P, radius1: number, center2: P, radius2?: number) => P[]
```
#### qrsRange
```typescript
qrsRange:
>(addFn: QRSAdder
, buildFn: QRSBuilder
, center: P, radius: number) => P[]
```
Calculate all the points within a given radius of a given center.
#### qrsRing
```typescript
qrsRing:
, S extends QRSSystem>(center: P, radius: number, builder: QRSBuilder
) => P[]
```
#### qrsScale
```typescript
qrsScale:
, S extends QRSSystem>(point: P, factor: number, builder: QRSBuilder
) => P
```
#### qrsSpiral
```typescript
qrsSpiral:
, S extends QRSSystem>(center: P, radius: number, builder: QRSBuilder
) => P[]
```
#### qrsSubtract
```typescript
qrsSubtract:
, S extends QRSSystem>(left: P, right: P, builder: QRSBuilder
) => P
```
#### stringifyAxial
```typescript
stringifyAxial: ({ q, r }: AxialPoint | BareQRSPoint) => string
```
#### stringifyCube
```typescript
stringifyCube: ({ q, r, s }: BareHexCubePoint) => string
```
#### stringifyOffset
```typescript
stringifyOffset: ({ row, col, system }: OffsetPoint) => string
```
#### svgForHexGrid
```typescript
svgForHexGrid: (grid: {
height: number;
hexes: QRWithXY[];
width: number;
}, layout: HexLayout) => string
```
Build a rudimentary SVG for the described grid. Intended more for testing and visual inspection than for anything significant.
#### triangleContainsChecker
```typescript
triangleContainsChecker: (triangle: [PointXY, PointXY, PointXY]) => (xy: PointXY) => boolean
```
Generate a function which can check to see if a given point is inside the triangle described by the three points.
#### triangleContainsPoint
```typescript
triangleContainsPoint: (triangle: [PointXY, PointXY, PointXY], point: PointXY) => boolean
```
### Interfaces
#### BareDouble
```typescript
export interface BareDouble
```
#### BareHexCubePoint
```typescript
export interface BareHexCubePoint extends BareQRSPoint
```
Cube points store the `s` value explicitly, instead of calculating it.
#### BareOffset
```typescript
export interface BareOffset
```
#### BareQRSPoint
```typescript
export interface BareQRSPoint
```
In the QRS notation, `q` is the column, while `r` is the row.
#### DoubleHeightPoint
```typescript
export interface DoubleHeightPoint extends DoublePoint
```
#### DoublePoint
```typescript
export interface DoublePoint extends Point, BareDouble
```
#### DoubleWidthPoint
```typescript
export interface DoubleWidthPoint extends DoublePoint
```
#### EvenQPoint
```typescript
export interface EvenQPoint extends OffsetPoint
```
#### EvenRPoint
```typescript
export interface EvenRPoint extends OffsetPoint
```
#### HexCubePoint
```typescript
export interface HexCubePoint extends QRSPoint, BareHexCubePoint
```
#### HexLayout
```typescript
export interface HexLayout
```
#### HexOrientation
```typescript
export interface HexOrientation
```
#### HexOrientations
```typescript
export interface HexOrientations
```
#### HexSystems
```typescript
export interface HexSystems
```
#### OddQPoint
```typescript
export interface OddQPoint extends OffsetPoint
```
#### OddRPoint
```typescript
export interface OddRPoint extends OffsetPoint
```
#### OffsetPoint
```typescript
export interface OffsetPoint extends Point, BareOffset
```
#### Point
```typescript
export interface Point
```
#### PointXY
```typescript
export interface PointXY
```
#### QRSPoint
```typescript
export interface QRSPoint extends Point, BareQRSPoint
```
A QRS Point which also has its [HexSystem](#api-hexsystem) materialized with its coordinates.
#### QRWithXY
```typescript
export interface QRWithXY extends PointXY, BareQRSPoint
```
### TypeAliases
#### Axial
```typescript
type Axial = typeof AXIAL;
```
#### AxialDirection
```typescript
type AxialDirection = typeof AXIAL_POINTY_E | typeof AXIAL_POINTY_NE | typeof AXIAL_POINTY_NW | typeof AXIAL_POINTY_W | typeof AXIAL_POINTY_SW | typeof AXIAL_POINTY_SE;
```
#### AxialPoint
```typescript
type AxialPoint = QRSPoint;
```
Axial coordinates don't store the `s` coordinate, as it can always be calculated via `q + r + s = 0`.
#### AxialTuple
```typescript
type AxialTuple = [q: number, r: number];
```
#### Axis
```typescript
type Axis = Exclude;
```
#### Cube
```typescript
type Cube = typeof CUBE;
```
#### CubeDiagDirection
```typescript
type CubeDiagDirection = typeof CUBE_DIAG_SE | typeof CUBE_DIAG_NW | typeof CUBE_DIAG_POINTY_N | typeof CUBE_DIAG_POINTY_NE | typeof CUBE_DIAG_POINTY_S | typeof CUBE_DIAG_POINTY_SW;
```
#### CubeTuple
```typescript
type CubeTuple = [q: number, r: number, s: number];
```
#### DoubleHeight
```typescript
type DoubleHeight = typeof DOUBLE_H;
```
#### DoubleHeightDirection
```typescript
type DoubleHeightDirection = typeof DOUBLE_H_N | typeof DOUBLE_H_NE | typeof DOUBLE_H_SE | typeof DOUBLE_H_S | typeof DOUBLE_H_SW | typeof DOUBLE_H_NW;
```
#### DoubleSystem
```typescript
type DoubleSystem = DoubleWidth | DoubleHeight;
```
#### DoubleWidth
```typescript
type DoubleWidth = typeof DOUBLE_W;
```
#### DoubleWidthDirection
```typescript
type DoubleWidthDirection = typeof DOUBLE_W_E | typeof DOUBLE_W_SE | typeof DOUBLE_W_SW | typeof DOUBLE_W_W | typeof DOUBLE_W_NW | typeof DOUBLE_W_NE;
```
#### EvenQ
```typescript
type EvenQ = typeof EVEN_Q;
```
#### EvenR
```typescript
type EvenR = typeof EVEN_R;
```
#### HexCorner
```typescript
type HexCorner = 0 | 1 | 2 | 3 | 4 | 5;
```
#### HexCubeDirection
```typescript
type HexCubeDirection = typeof CUBE_POINTY_E | typeof CUBE_NE | typeof CUBE_POINTY_NW | typeof CUBE_POINTY_W | typeof CUBE_SW | typeof CUBE_POINTY_SE;
```
#### HexOrientationName
```typescript
type HexOrientationName = keyof HexOrientations;
```
#### HexReachable
```typescript
type HexReachable = {
direction?: undefined;
distance: 0;
point: P;
prior?: undefined;
} | {
direction: Readonly
;
distance: Exclude;
point: P;
prior: P;
};
```
#### HexRotation
```typescript
type HexRotation = 0 | typeof CW_60 | typeof CW_120 | typeof CW_180 | typeof CW_240 | typeof CW_300;
```
#### HexSystem
```typescript
type HexSystem = keyof HexSystems;
```
#### OddQ
```typescript
type OddQ = typeof ODD_Q;
```
#### OddR
```typescript
type OddR = typeof ODD_R;
```
#### OffsetDirection
```typescript
type OffsetDirection = typeof OFFSET_R_E | typeof OFFSET_R_NE | typeof OFFSET_R_NW | typeof OFFSET_R_W | typeof OFFSET_R_SW | typeof OFFSET_R_SE;
```
#### OffsetSystem
```typescript
type OffsetSystem = typeof ODD_Q | typeof ODD_R | typeof EVEN_Q | typeof EVEN_R;
```
#### QRSAdder
```typescript
type QRSAdder> = (left: P, right: P) => P;
```
A function which can add together two QRS points with the same system.
#### QRSBuilder
```typescript
type QRSBuilder
> = (q: number, r: number) => P;
```
A function which can structures numbers into a QRS point for a given system.
#### QRSSystem
```typescript
type QRSSystem = Axial | Cube;
```
### Variables
#### AXIAL
```typescript
AXIAL: "axial"
```
#### AXIAL_DIRECTIONS
```typescript
AXIAL_DIRECTIONS: Readonly
```
#### AXIAL_EPSILON
```typescript
AXIAL_EPSILON: Readonly<{
readonly q: 0.000001;
readonly r: 0.000001;
readonly system: "axial";
}>
```
#### AXIAL_FLAT_N
```typescript
AXIAL_FLAT_N: Readonly<{
readonly q: 0;
readonly r: -1;
readonly system: "axial";
}>
```
#### AXIAL_FLAT_NE
```typescript
AXIAL_FLAT_NE: Readonly<{
readonly q: 1;
readonly r: -1;
readonly system: "axial";
}>
```
#### AXIAL_FLAT_NW
```typescript
AXIAL_FLAT_NW: Readonly<{
readonly q: -1;
readonly r: 0;
readonly system: "axial";
}>
```
#### AXIAL_FLAT_S
```typescript
AXIAL_FLAT_S: Readonly<{
readonly q: 0;
readonly r: 1;
readonly system: "axial";
}>
```
#### AXIAL_FLAT_SE
```typescript
AXIAL_FLAT_SE: Readonly<{
readonly q: 1;
readonly r: 0;
readonly system: "axial";
}>
```
#### AXIAL_FLAT_SW
```typescript
AXIAL_FLAT_SW: Readonly<{
readonly q: -1;
readonly r: 1;
readonly system: "axial";
}>
```
#### AXIAL_ORIGIN
```typescript
AXIAL_ORIGIN: Readonly<{
readonly q: 0;
readonly r: 0;
readonly system: "axial";
}>
```
#### AXIAL_POINTY_E
```typescript
AXIAL_POINTY_E: Readonly<{
readonly q: 1;
readonly r: 0;
readonly system: "axial";
}>
```
#### AXIAL_POINTY_NE
```typescript
AXIAL_POINTY_NE: Readonly<{
readonly q: 1;
readonly r: -1;
readonly system: "axial";
}>
```
#### AXIAL_POINTY_NW
```typescript
AXIAL_POINTY_NW: Readonly<{
readonly q: 0;
readonly r: -1;
readonly system: "axial";
}>
```
#### AXIAL_POINTY_SE
```typescript
AXIAL_POINTY_SE: Readonly<{
readonly q: 0;
readonly r: 1;
readonly system: "axial";
}>
```
#### AXIAL_POINTY_SW
```typescript
AXIAL_POINTY_SW: Readonly<{
readonly q: -1;
readonly r: 1;
readonly system: "axial";
}>
```
#### AXIAL_POINTY_W
```typescript
AXIAL_POINTY_W: Readonly<{
readonly q: -1;
readonly r: 0;
readonly system: "axial";
}>
```
#### CCW_120
```typescript
CCW_120 = 240
```
#### CCW_180
```typescript
CCW_180 = 180
```
#### CCW_240
```typescript
CCW_240 = 120
```
#### CCW_300
```typescript
CCW_300 = 60
```
#### CCW_60
```typescript
CCW_60 = 300
```
#### CUBE
```typescript
CUBE: "cube"
```
#### CUBE_DIAG_FLAT_E
```typescript
CUBE_DIAG_FLAT_E: Readonly<{
readonly q: 2;
readonly r: -1;
readonly s: 1;
readonly system: "cube";
}>
```
#### CUBE_DIAG_FLAT_NE
```typescript
CUBE_DIAG_FLAT_NE: Readonly<{
readonly q: 1;
readonly r: -2;
readonly s: 1;
readonly system: "cube";
}>
```
#### CUBE_DIAG_FLAT_SW
```typescript
CUBE_DIAG_FLAT_SW: Readonly<{
readonly q: -1;
readonly r: 2;
readonly s: -1;
readonly system: "cube";
}>
```
#### CUBE_DIAG_FLAT_W
```typescript
CUBE_DIAG_FLAT_W: Readonly<{
readonly q: -2;
readonly r: 1;
readonly s: 1;
readonly system: "cube";
}>
```
#### CUBE_DIAG_NW
```typescript
CUBE_DIAG_NW: Readonly<{
readonly q: -1;
readonly r: -1;
readonly s: 2;
readonly system: "cube";
}>
```
#### CUBE_DIAG_POINTY_N
```typescript
CUBE_DIAG_POINTY_N: Readonly<{
readonly q: 1;
readonly r: -2;
readonly s: 1;
readonly system: "cube";
}>
```
#### CUBE_DIAG_POINTY_NE
```typescript
CUBE_DIAG_POINTY_NE: Readonly<{
readonly q: 2;
readonly r: -1;
readonly s: 1;
readonly system: "cube";
}>
```
#### CUBE_DIAG_POINTY_S
```typescript
CUBE_DIAG_POINTY_S: Readonly<{
readonly q: -1;
readonly r: 2;
readonly s: -1;
readonly system: "cube";
}>
```
#### CUBE_DIAG_POINTY_SW
```typescript
CUBE_DIAG_POINTY_SW: Readonly<{
readonly q: -2;
readonly r: 1;
readonly s: 1;
readonly system: "cube";
}>
```
#### CUBE_DIAG_SE
```typescript
CUBE_DIAG_SE: Readonly<{
readonly q: 1;
readonly r: 1;
readonly s: -2;
readonly system: "cube";
}>
```
#### CUBE_EPSILON
```typescript
CUBE_EPSILON: Readonly<{
q: number;
r: number;
s: number;
system: "cube";
}>
```
#### CUBE_FLAT_N
```typescript
CUBE_FLAT_N: Readonly<{
readonly q: 0;
readonly r: -1;
readonly s: 1;
readonly system: "cube";
}>
```
#### CUBE_FLAT_NW
```typescript
CUBE_FLAT_NW: Readonly<{
readonly q: -1;
readonly r: 0;
readonly s: 1;
readonly system: "cube";
}>
```
#### CUBE_FLAT_S
```typescript
CUBE_FLAT_S: Readonly<{
readonly q: 0;
readonly r: 1;
readonly s: -1;
readonly system: "cube";
}>
```
#### CUBE_FLAT_SE
```typescript
CUBE_FLAT_SE: Readonly<{
readonly q: 1;
readonly r: 0;
readonly s: -1;
readonly system: "cube";
}>
```
#### CUBE_NE
```typescript
CUBE_NE: Readonly<{
readonly q: 1;
readonly r: -1;
readonly s: 0;
readonly system: "cube";
}>
```
#### CUBE_ORIGIN
```typescript
CUBE_ORIGIN: Readonly<{
readonly q: 0;
readonly r: 0;
readonly s: 0;
readonly system: "cube";
}>
```
#### CUBE_POINTY_E
```typescript
CUBE_POINTY_E: Readonly<{
readonly q: 1;
readonly r: 0;
readonly s: -1;
readonly system: "cube";
}>
```
#### CUBE_POINTY_NW
```typescript
CUBE_POINTY_NW: Readonly<{
readonly q: 0;
readonly r: -1;
readonly s: 1;
readonly system: "cube";
}>
```
#### CUBE_POINTY_SE
```typescript
CUBE_POINTY_SE: Readonly<{
readonly q: 0;
readonly r: 1;
readonly s: -1;
readonly system: "cube";
}>
```
#### CUBE_POINTY_W
```typescript
CUBE_POINTY_W: Readonly<{
readonly q: -1;
readonly r: 0;
readonly s: 1;
readonly system: "cube";
}>
```
#### CUBE_SW
```typescript
CUBE_SW: Readonly<{
readonly q: -1;
readonly r: 1;
readonly s: 0;
readonly system: "cube";
}>
```
#### CW_120
```typescript
CW_120 = 120
```
#### CW_180
```typescript
CW_180 = 180
```
#### CW_240
```typescript
CW_240 = 240
```
#### CW_300
```typescript
CW_300 = 300
```
#### CW_60
```typescript
CW_60 = 60
```
#### DOUBLE_H
```typescript
DOUBLE_H: "doubleH"
```
#### DOUBLE_H_N
```typescript
DOUBLE_H_N: Readonly<{
readonly col: 0;
readonly row: -2;
readonly system: "doubleH";
}>
```
#### DOUBLE_H_NE
```typescript
DOUBLE_H_NE: Readonly<{
readonly col: 1;
readonly row: -1;
readonly system: "doubleH";
}>
```
#### DOUBLE_H_NW
```typescript
DOUBLE_H_NW: Readonly<{
readonly col: -1;
readonly row: -1;
readonly system: "doubleH";
}>
```
#### DOUBLE_H_S
```typescript
DOUBLE_H_S: Readonly<{
readonly col: 0;
readonly row: 2;
readonly system: "doubleH";
}>
```
#### DOUBLE_H_SE
```typescript
DOUBLE_H_SE: Readonly<{
readonly col: 1;
readonly row: 1;
readonly system: "doubleH";
}>
```
#### DOUBLE_H_SW
```typescript
DOUBLE_H_SW: Readonly<{
readonly col: -1;
readonly row: 1;
readonly system: "doubleH";
}>
```
#### DOUBLE_W
```typescript
DOUBLE_W: "doubleW"
```
#### DOUBLE_W_E
```typescript
DOUBLE_W_E: Readonly<{
readonly col: 2;
readonly row: 0;
readonly system: "doubleW";
}>
```
#### DOUBLE_W_NE
```typescript
DOUBLE_W_NE: Readonly<{
readonly col: 1;
readonly row: -1;
readonly system: "doubleW";
}>
```
#### DOUBLE_W_NW
```typescript
DOUBLE_W_NW: Readonly<{
readonly col: -1;
readonly row: 1;
readonly system: "doubleW";
}>
```
#### DOUBLE_W_SE
```typescript
DOUBLE_W_SE: Readonly<{
readonly col: 1;
readonly row: 1;
readonly system: "doubleW";
}>
```
#### DOUBLE_W_SW
```typescript
DOUBLE_W_SW: Readonly<{
readonly col: -1;
readonly row: 1;
readonly system: "doubleW";
}>
```
#### DOUBLE_W_W
```typescript
DOUBLE_W_W: Readonly<{
readonly col: -2;
readonly row: 0;
readonly system: "doubleW";
}>
```
#### EVEN_Q
```typescript
EVEN_Q: "evenQ"
```
#### EVEN_R
```typescript
EVEN_R: "evenR"
```
#### FLAT
```typescript
FLAT = "flat"
```
#### HEX_CORNERS
```typescript
HEX_CORNERS: readonly HexCorner[]
```
#### HEX_CUBE_DIRECTIONS
```typescript
HEX_CUBE_DIRECTIONS: Readonly
```
#### HEX_SYSTEMS
```typescript
HEX_SYSTEMS: readonly HexSystem[]
```
#### ODD_Q
```typescript
ODD_Q: "oddQ"
```
#### ODD_R
```typescript
ODD_R: "oddR"
```
#### OFFSET_DIRECTIONS
```typescript
OFFSET_DIRECTIONS: Readonly[]>
```
#### OFFSET_Q_N
```typescript
OFFSET_Q_N = 2
```
#### OFFSET_Q_NE
```typescript
OFFSET_Q_NE = 1
```
#### OFFSET_Q_NW
```typescript
OFFSET_Q_NW = 3
```
#### OFFSET_Q_S
```typescript
OFFSET_Q_S = 5
```
#### OFFSET_Q_SE
```typescript
OFFSET_Q_SE = 0
```
#### OFFSET_Q_SW
```typescript
OFFSET_Q_SW = 4
```
#### OFFSET_R_E
```typescript
OFFSET_R_E = 0
```
#### OFFSET_R_NE
```typescript
OFFSET_R_NE = 1
```
#### OFFSET_R_NW
```typescript
OFFSET_R_NW = 2
```
#### OFFSET_R_SE
```typescript
OFFSET_R_SE = 5
```
#### OFFSET_R_SW
```typescript
OFFSET_R_SW = 4
```
#### OFFSET_R_W
```typescript
OFFSET_R_W = 3
```
#### ORIENTATION_FLAT
```typescript
ORIENTATION_FLAT: Readonly
```
#### ORIENTATION_POINTY
```typescript
ORIENTATION_POINTY: Readonly
```
#### POINTY
```typescript
POINTY = "pointy"
```
#### QRS_ORIGIN
```typescript
QRS_ORIGIN: Readonly<{
readonly q: 0;
readonly r: 0;
}>
```
#### SQRT_3
```typescript
SQRT_3: number
```
#### SQRT_3_2
```typescript
SQRT_3_2: number
```
#### SQRT_3_3
```typescript
SQRT_3_3: number
```
#### TWO_PI
```typescript
TWO_PI: number
```