Skip to the content

Meikyuu documentation

Meikyuu API: every export

Every export of every entry point, each with its own page. This page keeps the addresses the old one-page reference had.

@johnmorrisdotca/meikyuu/draw

arrowMarkupfunction

The arrow's picture: its stem, its head, and a padlock if it is locked.

boardLookOffunction

The look a board name or board object means.

doorPlacefunction

Where a door is: the middle of its gap in the wall, and the way out through it as a unit vector.

drawArrowsfunction

Render the native arrow board, locked/present arrows and optional hint as SVG text.

DrawArrowsOptionstype

AN ARROW BOARD AS SVG TEXT: a faint dot on every cell of the picture, and each arrow on it as a line through its cells with a head at the end it points from.

DrawMazeOptionstype

Native maze appearance, current trail, collected keys, stones, hints, label and SVG presentation choices.

fixedfunction

A number as short text: two decimals at most, so a drawing is small.

framedfunction

The rectangle to look at to see the whole of a shape with a margin of pad cells.

linePathfunction

A line through the middles of the cells, in order.

lookAttributesfunction

The attributes (as text) that make an element a Meikyuu drawing: its class, its look, and its custom properties.

lookStylefunction

The inline custom properties a look needs: none for plain paper with the default line, which the style gives.

marksOffunction

The marks on a maze: the start, the goal or exit, the doors and the keys, as SVG.

MazeLooktype

What a maze looks like: every option that does not depend on where the line is.

MEIKYUU_BOARDSconstant

The paper, wall, frame and default trail colours of every named maze board.

MEIKYUU_STRINGSconstant

Native English and Japanese labels, announcements and interpolation templates.

MEIKYUU_STYLEconstant

The scoped native SVG styles for mazes and arrow boards.

MEIKYUU_TRAILSconstant

The light and dark colours of every named trail.

MeikyuuBoardLooktype

A board's colours: the paper, the walls, the frame, whether it is a dark board, and the line that shows on it when none is chosen.

MeikyuuLanguagetype

THE WORDS MEIKYUU SAYS, in English and Japanese: what a screen reader hears of a drawing, what the buttons and the lines under a playable board say, and the names of the shapes and the ways to play.

meikyuuLanguageOffunction

The language a lang attribute asks for: Japanese for any ja, English for everything else.

meikyuuSayfunction

A line in a language, with its {name} values filled in, and its One form when n is 1.

standingWallsfunction

Every wall of the maze that is standing: between cells that are not joined, and round the outside, except the doors.

stonesOffunction

The stones laid on a maze, as SVG: each a marble (mk-stone) with a small gleam (mk-gleam) on the cell, one unit across being a cell.

wallPathfunction

The path data for a wall: a line, or an arc round the middle of a circle maze.

@johnmorrisdotca/meikyuu/play

createMeikyuuSoundsfunction

Create the optional synthesized native sound player; sound playback is requested by host actions.

EDGEconstant

How near an edge of the box a line's end must be dragged to move the view, and the most the view moves in a frame there, in pixels.

EDGE_STEPconstant

The native viewport edge-pan step in pixels.

edgeNudgefunction

How far to move the view in a frame for a finger at (px, py) of a box: the board moves the other way, toward the finger.

ensureMeikyuuPlayStylefunction

Put the style in the page once: in the document's head, or in the shadow root the host is in.

FIT_MODESconstant

What a fit makes visible: both the whole board (default); width the board as wide as the box, which for a board taller than the box is the top of it with the rest to move down to; height the board as tall as the box, the left of it for a board wider than the box.

FitModetype

Fit both dimensions, only the width, or only the height of a board.

fitViewfunction

The view that shows the board as a mode says, with a margin of pad cells: centred where it fits, and at the top or left where it does not.

isFittedfunction

Whether the view is the board fitted, as the mode says.

keptViewfunction

A view kept where some of the board can be seen: its middle never leaves the area (with a margin).

MEIKYUU_GUTTERconstant

The page left beside the box, in pixels: the least, and the most the zoom-out widens it to.

MEIKYUU_PLAY_STYLEconstant

THE STYLE a playable Meikyuu board wears (mountMeikyuu, <meikyuu-board>): the drawing's own (MEIKYUU_STYLE) and the board's box, its buttons, its lines of words and its tabs.

MEIKYUU_RESERVEconstant

What a window is assumed to hold besides the box, in pixels: the page's header, and the board's buttons and lines of words.

MEIKYUU_SOUND_KINDSconstant

THE SOUNDS, made in the browser: short tones from the Web Audio API, one for each thing that happens (a step, drawing back, a key, an arrow bumping, an arrow flying off, an unlock, a solve, a loss).

MeikyuuMounttype

The mounted flat maze, arrow or mixed board, its game/actions, view and cleanup handle.

MeikyuuMountOptionstype

Native puzzle/level/recipe, display, controls, sound, stones and event callbacks for a flat player.

MeikyuuSoundstype

Native synthesized sound playback and cleanup methods.

MOST_CELL_PIXELSconstant

The scales a view may have: the whole board fitted, to a cell this many pixels wide (at least a bit past the fit, so a small maze can still zoom).

pannedByfunction

The view moved so that the board slides by (dx, dy) pixels under the box.

pointAtfunction

The point of the board under a pixel of the box.

puzzleOffunction

The puzzle a set of options names: a level of the package's lists, or a recipe given, or null.

scaleLimitsfunction

Read the minimum and maximum view scale for this viewport and gutter.

Viewtype

A BOARD LOOKED AT THROUGH A BOX, which may be zoomed in until a cell is as big as a thumb and moved about: the arithmetic of the view, without a page.

ViewBoxtype

How a box of width by height pixels shows a board: the margin round it in cells, and how far in a view may go.

viewBoxOffunction

The text of the viewBox attribute that shows the view.

visibleAreafunction

The part of the board the view shows.

zoomedAboutfunction

The view zoomed by factor about the pixel (px, py) of the box, which stays over the same spot of the board.

@johnmorrisdotca/meikyuu/element

defineBoardfunction

Register a standard or custom tag without replacing a definition.

MeikyuuBoardclass

Native custom element with reflected setup and presentation.

@johnmorrisdotca/meikyuu/element/define

defineBoardfunction

Register a standard or custom tag without replacing a definition.

MeikyuuBoardclass

Native custom element with reflected setup and presentation.

@johnmorrisdotca/meikyuu/levels

bandOffunction

Read the easy, medium or hard third of a numbered level collection.

findMazeLevelsfunction

The levels of a kind that pass a filter, with their numbers: by shape, by way to play and by size, each when given.

levelOffunction

Level number n (from 1) of a kind, or null when there is none.

mazeLevelOfSizefunction

Level n (from 1) of a size, or null when there is none.

mazeLevelsOfSizefunction

The levels of one size, in order: 256 of them, each a little harder than the one before.

MEIKYUU_KINDSconstant

THE LEVELS: numbered lists of recipes, easiest first, never drawings.

MEIKYUU_LEVELS_PER_SIZEconstant

How many levels each size has: 256, so a size is sixteen pages of sixteen, and the four sizes make 1,024.

MEIKYUU_MAZE_LEVELSconstant

The fixed numbered flat-maze recipes and their measured difficulty metadata.

MeikyuuArrowLeveltype

A numbered arrow-puzzle recipe and its native difficulty metadata.

MeikyuuBandtype

Which third of a size's list a level is in: the easy, medium and hard a site files it under.

MeikyuuKindtype

The flat maze, arrow or mixed puzzle family.

MeikyuuLeveltype

One native numbered maze, arrow or mixed level.

MeikyuuMazeLeveltype

A numbered flat-maze recipe, difficulty measures, cell count and place within its size.

MeikyuuMixedLeveltype

A numbered mixed-puzzle recipe and its native difficulty metadata.

MeikyuuSizetype

The small, medium, large or huge numbered flat-maze collection.

sizeOffunction

How big a maze is, in words a person picks by: under 150 cells is small, under 800 medium, under 4,000 large, and the rest huge.

@johnmorrisdotca/meikyuu/levels/tall

findTallLevelsfunction

The tall levels that pass a filter, by shape, way to play and size, each when given.

MEIKYUU_TALL_LEVELSconstant

The fixed numbered tall-maze recipes, dimensions and difficulty metadata.

MEIKYUU_TALL_SIZESconstant

The sizes: their number, how many cells across, and the squares' columns and rows ("6×9").

MeikyuuTallLeveltype

THE TALL LEVELS: portrait mazes for a phone held upright, 1,536 of them in six sizes of 256, each size in order of the score difficultyOf gives, so no level is easier than the one before inside its size.

TALL_RATIOconstant

The ratio of a tall container, width over height: two to three.

TALL_WIDTHSconstant

How many cells across each size of the tall levels is.

tallDimensionsfunction

The columns and rows of a maze of shape for the size width (a square maze of that size is width by one and a half times that): as near 2:3 as its cells allow, and with about as many cells as that square maze has (width times one and a half width), so that the sizes are as big to draw whatever the shape is.

tallLevelOffunction

Tall level n (from 1) of the whole list, or null when there is none.

@johnmorrisdotca/meikyuu/levels/colossal

COLOSSAL_CELLSconstant

The cells a square colossal level has, least and most: a hundred by a hundred is 10,000.

COLOSSAL_TALL_WIDTHconstant

How many cells across a tall colossal level is, and its rows (a square maze of it is 64 by 96, 6,144 cells).

colossalLevelOffunction

Square colossal level n (from 1), or null when there is none.

findColossalLevelsfunction

The colossal levels of a list that pass a filter, by shape and way to play, each when given.

MeikyuuColossalLeveltype

THE COLOSSAL LEVELS: the biggest mazes of the lists, about ten thousand cells, in two lists of 128.

@johnmorrisdotca/meikyuu/levels/legacy

legacyLevelOfCodefunction

What became of a recipe the 1.0.0 list had, or null when it was not one of its levels.

@johnmorrisdotca/meikyuu/3d

cachedSolidGridfunction

The grid of a solid cut n ways, kept: a grid is never changed, and a script that makes thousands of mazes of one size builds it once.

cellsAlongDragfunction

The cells a straight drag from one point to another crosses, in order, by sampling it finely enough that no cell the drag passes through is missed.

checkSolidAnswerfunction

Whether a list of cells is the answer: it starts at the start, ends at the goal, steps from each cell to one joined to it by a passage, and never visits a cell twice.

dragTurnfunction

The turn a drag from one point to another makes: the point of the solid under the first is carried to under the second.

drawSolidfunction

Render a surface maze and optional trail/stones as native SVG text.

DrawSolidOptionstype

A MAZE OVER A SOLID AS SVG TEXT, a still picture of it from one side: the near side's cells shaded by how squarely they face the viewer, the walls that stand, and, if asked, the line, the stones and the way through.

EDGE_FULLconstant

The normalized threshold used for a full native edge turn.

EDGE_NEIGHBOURconstant

The normalized neighbouring-cell edge-turn threshold.

EDGE_RATEconstant

The fastest the solid turns by itself, in radians a second.

EDGE_SAFEconstant

THE SOLID TURNS BY ITSELF to keep the end of a line being drawn in view.

edgeTurnfunction

Compute a view rotation that follows a surface path near an edge, or null when no turn is needed.

faceCellTurnfunction

The turn that brings the cell round to face the viewer (see facingOf for around), by the shortest way, and then rolls it so that a side of the cell lies level (the cell's own first side, to the nearest of the turns that put one of its sides level).

isSolidCutfunction

Whether a solid can be cut n ways: a whole number of at least 2, or 1 where the solid has already sixty cells uncut (the dodecahedron's five to a face).

isSolidDiefunction

Whether a solid is among the dice (the rest are shapes).

openingTurnfunction

A view of the solid to begin with: the cell faces the viewer, then the solid is tipped a little so that its depth shows and its neighbours on the near side can be seen.

parseSolidRecipefunction

A recipe from its code, or null when it is not one, or names a solid of more than MEIKYUU_MOST_SOLID_CELLS cells.

pickCellfunction

The cell the point (x, y) of the picture is on, or -1 for none.

projectFramefunction

Put the solid, turned by q and zoomed, on a picture width by height: fills every array of the frame.

Quattype

A rotation: [x, y, z, w], of length one.

quatAnglefunction

How far apart two rotations are, in radians, from 0 to pi.

quatAxisAnglefunction

The turn of angle radians about an axis (any length but nought).

quatBetweenfunction

The shortest turn that carries the direction a onto the direction b.

quatMulfunction

Two rotations in turn: b after a.

quatNormalizefunction

A rotation made one again: the turns a drag adds up carry a little error, which this takes out.

quatSlerpfunction

Halfway (or any share) from one rotation to another along the shortest way.

SOLID_ALGORITHMSconstant

The algorithms that make a maze over a solid: all but Eller's, which needs rows.

SOLID_CUTSconstant

How many ways each solid is cut, for each size: small, medium, large, huge and colossal.

SOLID_DICEconstant

The dice, by how many sides, smallest first.

SOLID_DIE_SIDESconstant

How many sides a die has (what its name on a die is: d6).

SOLID_EYEconstant

How far the eye is from the middle of the solid, in times its reach.

SOLID_FILLconstant

The share of the box the solid's outline fills at most.

SOLID_KINDSconstant

THE SURFACE OF A SOLID AS A CELL GRAPH: the one thing a maze over a solid is made on.

SOLID_MORE_DICEconstant

The seven dice that came after the first five, and the six shapes.

SOLID_MORE_SHAPESconstant

The additional box, cross, ring, torus, star and heart surface families.

SOLID_SIZE_NAMESconstant

THE SIZES OF THE LEVELS OF A SOLID: three to each, small, medium and large, cut so that they come to about the same number of cells whichever solid it is (under a hundred, about three hundred, and six to seven hundred), and so that the one kind of solid is not the easy one: a cube cut 4, 7 and 10 ways has 96, 294 and 600 cells, a globe at frequency 3, 5 and 8 has 92, 252 and 642, an octahedron cut 3, 6 and 9 has 72, 288 and 648.

SOLID_ZOOM_LEASTconstant

How far in and out the picture can be zoomed, as a multiple of the fitted size: in to six, so that a cell of a colossal solid (about six pixels across when the whole solid is in the box) is a finger wide (about 24) at four and has room beyond.

SolidAlgorithmtype

A maze-carving algorithm supported on a surface graph.

solidAnswerStepsfunction

The answer as steps (the format a kept run uses, lineToSteps), for a maze: its whole solution.

solidCellsfunction

How many cells a solid cut n ways has.

solidDifficultyOffunction

How hard a maze over a solid is to play, from 0 to 100, on the very scale flat mazes are scored on (difficultyOf).

SolidEdgetype

The edge between two cells: its two corners (indices into vertices) and the two cells it lies between.

SolidFrametype

Where a solid is, as a picture of a given size: the turn, the zoom, and every corner and cell as it lands.

solidGeometryfunction

How a maze over a solid lies in space, for the measure: squared distance through space to the goal, and the bend of the line in three dimensions.

SolidGridtype

A surface cell graph, neighbouring faces, vertices, projected centres and shape geometry.

solidGridOffunction

The surface of a solid cut n ways (n at least 2, or 1 for a solid with sixty cells at that): its cells, which are beside which, and where each lies.

SolidKindtype

A supported polyhedron, die or shaped surface for a maze.

SolidMazetype

A maze over a solid: what a flat maze has that is not flat.

SolidRecipetype

Everything that makes a maze over a solid.

solidRecipeCodefunction

A recipe as one short word, such as cube:6:prim:48213, and the other way (parseSolidRecipe).

SolidSizetype

A named small, medium, large, huge or colossal surface-maze collection.

solidSolutionOffunction

The one way from the start to the goal, cell by cell.

stepTurnfunction

A turn about the viewer's own axes: right radians about the vertical (the solid's near side moves right) and down about the horizontal.

trackballPointfunction

The point of the trackball a point of the picture is on, for turning by a drag: the unit sphere seen from the front, and, outside it, the rim.

Vec3type

A point or a direction in three dimensions.

@johnmorrisdotca/meikyuu/3d/play

ensureSolidStylefunction

Put the style of the solid in the page once, beside the board's.

mountSolidfunction

Draw a maze over a solid into host and play it.

SOLID_PLAY_STYLEconstant

THE STYLE a playable solid wears beside the board's own (MEIKYUU_PLAY_STYLE): the canvas fills the box, the box is grabbed rather than drawn on, and the turn pad sits in a row.

SolidCellPlacetype

Where a cell is on the picture, in pixels from the top left of the box.

SolidMounttype

The mounted surface maze, game, rotation/zoom controls, native progress and cleanup handle.

SolidMountOptionstype

A PLAYABLE MAZE OVER A SOLID IN ANY PAGE: mountSolid(host, { recipe }) draws a cube, a globe or a solid of triangles with a maze over the whole of its surface, and plays it by touch and mouse.

@johnmorrisdotca/meikyuu/3d/levels

findSolidLevelsfunction

All surface levels in this entry matching the optional kind and size filters.

MeikyuuSolidLeveltype

A LEVEL OF A SOLID, AND HOW A FILE OF ROWS BECOMES THE LISTS: the shape every level entry of the solids shares (3d/levels, 3d/levels/dice, 3d/levels/shapes, 3d/levels/all), so that each file of recipes is turned into levels by the same code, and a page that shows one solid loads the file of that solid and no other.

SOLID_CUTSconstant

How many ways each solid is cut, for each size: small, medium, large, huge and colossal.

SOLID_KINDSconstant

THE SURFACE OF A SOLID AS A CELL GRAPH: the one thing a maze over a solid is made on.

SOLID_SIZE_NAMESconstant

THE SIZES OF THE LEVELS OF A SOLID: three to each, small, medium and large, cut so that they come to about the same number of cells whichever solid it is (under a hundred, about three hundred, and six to seven hundred), and so that the one kind of solid is not the easy one: a cube cut 4, 7 and 10 ways has 96, 294 and 600 cells, a globe at frequency 3, 5 and 8 has 92, 252 and 642, an octahedron cut 3, 6 and 9 has 72, 288 and 648.

SolidKindtype

A supported polyhedron, die or shaped surface for a maze.

solidLevelOffunction

The one-based surface level, or null when this entry has no such kind, size or number.

solidLevelsOffunction

The native surface-level collection for this kind and size; empty when this entry has none.

SolidSizetype

A named small, medium, large, huge or colossal surface-maze collection.

@johnmorrisdotca/meikyuu/3d/levels/dice

findSolidLevelsfunction

All surface levels in this entry matching the optional kind and size filters.

MeikyuuSolidLeveltype

A LEVEL OF A SOLID, AND HOW A FILE OF ROWS BECOMES THE LISTS: the shape every level entry of the solids shares (3d/levels, 3d/levels/dice, 3d/levels/shapes, 3d/levels/all), so that each file of recipes is turned into levels by the same code, and a page that shows one solid loads the file of that solid and no other.

SOLID_CUTSconstant

How many ways each solid is cut, for each size: small, medium, large, huge and colossal.

SOLID_KINDSconstant

THE SURFACE OF A SOLID AS A CELL GRAPH: the one thing a maze over a solid is made on.

SOLID_MORE_DICEconstant

The seven dice that came after the first five, and the six shapes.

SOLID_SIZE_NAMESconstant

THE SIZES OF THE LEVELS OF A SOLID: three to each, small, medium and large, cut so that they come to about the same number of cells whichever solid it is (under a hundred, about three hundred, and six to seven hundred), and so that the one kind of solid is not the easy one: a cube cut 4, 7 and 10 ways has 96, 294 and 600 cells, a globe at frequency 3, 5 and 8 has 92, 252 and 642, an octahedron cut 3, 6 and 9 has 72, 288 and 648.

SolidKindtype

A supported polyhedron, die or shaped surface for a maze.

solidLevelOffunction

The one-based surface level, or null when this entry has no such kind, size or number.

solidLevelsOffunction

The native surface-level collection for this kind and size; empty when this entry has none.

SolidSizetype

A named small, medium, large, huge or colossal surface-maze collection.

@johnmorrisdotca/meikyuu/3d/levels/shapes

findSolidLevelsfunction

All surface levels in this entry matching the optional kind and size filters.

MeikyuuSolidLeveltype

A LEVEL OF A SOLID, AND HOW A FILE OF ROWS BECOMES THE LISTS: the shape every level entry of the solids shares (3d/levels, 3d/levels/dice, 3d/levels/shapes, 3d/levels/all), so that each file of recipes is turned into levels by the same code, and a page that shows one solid loads the file of that solid and no other.

SOLID_CUTSconstant

How many ways each solid is cut, for each size: small, medium, large, huge and colossal.

SOLID_KINDSconstant

THE SURFACE OF A SOLID AS A CELL GRAPH: the one thing a maze over a solid is made on.

SOLID_MORE_SHAPESconstant

The additional box, cross, ring, torus, star and heart surface families.

SOLID_SIZE_NAMESconstant

THE SIZES OF THE LEVELS OF A SOLID: three to each, small, medium and large, cut so that they come to about the same number of cells whichever solid it is (under a hundred, about three hundred, and six to seven hundred), and so that the one kind of solid is not the easy one: a cube cut 4, 7 and 10 ways has 96, 294 and 600 cells, a globe at frequency 3, 5 and 8 has 92, 252 and 642, an octahedron cut 3, 6 and 9 has 72, 288 and 648.

SolidKindtype

A supported polyhedron, die or shaped surface for a maze.

solidLevelOffunction

The one-based surface level, or null when this entry has no such kind, size or number.

solidLevelsOffunction

The native surface-level collection for this kind and size; empty when this entry has none.

SolidSizetype

A named small, medium, large, huge or colossal surface-maze collection.

@johnmorrisdotca/meikyuu/3d/levels/recipes

solidLevelNumberOffunction

The place (from 1) a recipe has among the levels of a solid at a size, or null when it is not one of them.

solidRecipesOffunction

The recipes of a solid at a size, in the order of its levels (level 1 first), as the codes buildSolidMaze takes; empty for a solid or a size there is none of.

@johnmorrisdotca/meikyuu/3d/levels/all

findSolidLevelsfunction

All surface levels in this entry matching the optional kind and size filters.

isSolidDiefunction

Whether a solid is among the dice (the rest are shapes).

MeikyuuSolidLeveltype

A LEVEL OF A SOLID, AND HOW A FILE OF ROWS BECOMES THE LISTS: the shape every level entry of the solids shares (3d/levels, 3d/levels/dice, 3d/levels/shapes, 3d/levels/all), so that each file of recipes is turned into levels by the same code, and a page that shows one solid loads the file of that solid and no other.

SOLID_CUTSconstant

How many ways each solid is cut, for each size: small, medium, large, huge and colossal.

SOLID_DICEconstant

The dice, by how many sides, smallest first.

SOLID_DIE_SIDESconstant

How many sides a die has (what its name on a die is: d6).

SOLID_KINDSconstant

THE SURFACE OF A SOLID AS A CELL GRAPH: the one thing a maze over a solid is made on.

SOLID_MORE_DICEconstant

The seven dice that came after the first five, and the six shapes.

SOLID_MORE_SHAPESconstant

The additional box, cross, ring, torus, star and heart surface families.

SOLID_SIZE_NAMESconstant

THE SIZES OF THE LEVELS OF A SOLID: three to each, small, medium and large, cut so that they come to about the same number of cells whichever solid it is (under a hundred, about three hundred, and six to seven hundred), and so that the one kind of solid is not the easy one: a cube cut 4, 7 and 10 ways has 96, 294 and 600 cells, a globe at frequency 3, 5 and 8 has 92, 252 and 642, an octahedron cut 3, 6 and 9 has 72, 288 and 648.

SolidKindtype

A supported polyhedron, die or shaped surface for a maze.

solidLevelOffunction

The one-based surface level, or null when this entry has no such kind, size or number.

solidLevelsOffunction

The native surface-level collection for this kind and size; empty when this entry has none.

SolidSizetype

A named small, medium, large, huge or colossal surface-maze collection.

@johnmorrisdotca/meikyuu

Arrowtype

One arrow: its cells from tail to head (indexes into the board, row by row), and the way its head points.

ARROW_SHAPESconstant

The pictures an arrow board can be: the whole square, or one of the shapes cut from it.

ARROW_STEPSconstant

The up, right, down and left row/column increments of arrow directions.

ArrowBoardtype

The native arrow recipe, shape mask, arrow paths and locked flags.

ArrowDirectiontype

Which way an arrow's head points: up, right, down, left.

ArrowGametype

AN ARROW PUZZLE BEING PLAYED, as pure functions.

ArrowMeasuretype

How hard an arrow puzzle is: the arrows to clear, the rounds of unblocking they take, and how many are blocked at the start.

arrowRecipeCodefunction

A recipe as a short word, such as heart:15:6:77 or square:9x9:5:123:2 (the last number: how many are locked), and back.

ArrowShapetype

One of the supported flat arrow-board masks.

arrowsLeftfunction

The count of arrows still on the board.

autoTurnfunction

auto: turn a maze when that makes it bigger in the room there is.

belowfunction

A whole number in [0, n) from the stream.

blockedByfunction

The arrows on the way out of id that are still on the board.

blockersOffunction

Which arrows block others: for each arrow, the arrows whose cells lie on its way out.

boundaryCellsfunction

The cells with a side on the edge of the shape: where a door in the outer wall can be.

Boxtype

A rectangle, in cells.

buildMazefunction

Make the maze a recipe names.

buildMixedfunction

Build the maze and locked-arrow layers of one native mixed recipe.

canLayStonefunction

Whether a stone may be laid on a cell now, and if not, why not.

carveMazefunction

The open neighbours of every cell, for a perfect maze of the grid made by this algorithm from this stream.

CellGraphtype

What a generator reads of a grid: how many cells there are and which are beside which.

cellsAlongfunction

The cells a pointer enters moving from one shown point to the next: the straight path between them cut into steps of a third of a cell and each step carried back into the maze.

centreCellfunction

The cell whose middle is nearest the middle of the shape.

circleGridfunction

A circle maze: rings rings round a middle cell, cells running round each ring and out between the rings.

clearArrowsfunction

Take every arrow off by tapping only free ones, the way a test or a demo plays.

clearStonesfunction

Every stone taken up, in one step Undo can put back.

COVER_FROMconstant

Where cover begins to rise and how far it rises: (mean - COVER_FROM) / COVER_SPAN.

COVER_SPANconstant

The native coverage span used by the geometry-aware score.

COVERAGE_FLOORconstant

What the score is multiplied by at no cover at all.

coverageOffunction

How much of a map an answer covers.

decodeRunfunction

The game a run text says, for maze under rules, or null when it is not a run of that maze: a step into a wall or back onto the line, a stone on a cell the line is on, on the start or the goal, on no cell at all or twice, or any stones when rules is null.

DIFFICULTY_CEILINGSconstant

The count at which a term reaches its full weight, on its log scale.

difficultyOffunction

How hard a maze is, from 0 to 100, and what that is made of.

difficultyOfGraphfunction

The same for any maze, flat or over a solid, given how it lies in space (MazeGeometry).

Doortype

A door in the outer wall: the cell it is beside, and which of that cell's sides.

dragMazefunction

The finger moved into a cell.

easyFloorAtfunction

What the easy third asks for beyond the least, rising through it so that it climbs: at place place (from 1) of a size, a maze has at least this many traps, forks and wasted cells, and from the end of the easy third the least.

EFFORT_LEASTconstant

The easiest effort a level is given a rating for, and the hardest: 1 and 100 are these.

EFFORT_MOSTconstant

The upper native effort bound used when converting effort to a rating.

encodeRunfunction

A run kept as one short text: the line as its steps (lineToSteps), and, if any stones are down, a ~ and their cells in base 36 joined by dots, such as 0231~1a.2f.

Gridtype

The native flat cell graph with geometry, neighbour sides, bounds and point-to-cell lookup.

gridOffunction

A grid by name.

hasStonefunction

Whether a cell has a stone on it.

headOffunction

The end of the line, or null while there is none.

heldByLocksfunction

Whether an arrow cannot be cleared before the unlock whatever the player taps: with every free arrow taken off, one after another, it is still on the board.

hexGridfunction

Columns by rows of hexagons, pointy side up, every odd row shifted half a cell right.

hintArrowfunction

The arrow to tap next: one that is free now and keeps the most arrows waiting behind it, so it also frees the most others.

hintMazefunction

Where to look next: how many cells of the line to draw back (the part that has strayed from the way to what is still needed), and the next stretch of the right way from there, up to ahead cells, not counting the one the line is on.

isFreefunction

Whether an arrow can be tapped now and slide off: it is on the board, not locked, and nothing is in front of it.

isPerfectfunction

Whether the passages are a spanning tree of the grid: every cell reached, and exactly one way to each.

isTooEasyfunction

Whether a maze is too easy to be a level: it falls short of any of MEIKYUU_LEAST, or, with a place in the easy third of a size, of easyFloorAt(place).

layoutCellsfunction

How many cells laying out a recipe's grid takes, counted before anything is built: the grid's own cells for squares, hexagons, triangles and circles, and the whole raster for a shape cut out of one (a cut-out shape keeps fewer, but is built from all of them).

layStonefunction

The game with a stone laid on the cell; the same game when it may not be (canLayStone).

lineToStepsfunction

A line, cell by cell from the start, as its steps.

makeArrowsfunction

The arrows of a recipe, in the order they were added: the last one added is free from the start.

Masktype

THE OUTLINES cut out of a square raster: a function from a point of the square (both numbers from -1 to 1, y down) to whether that point is inside the shape.

maskOffunction

The outline a raster shape is cut with.

Mazetype

A seeded flat maze with its cell graph, passages, doors, endpoints and optional keys.

MazeCoretype

What the game, the stones, the measure and the steps read of a maze: the passages, the two ends, the keys, and how many cells there are and which are beside which.

MazeCoveragetype

HOW MUCH OF THE MAP THE ANSWER COVERS (coverageOf): the second half of a maze's difficulty.

MazeDifficultytype

HOW HARD A MAZE IS TO PLAY, ON ONE SCALE FROM 0 TO 100 (difficultyOf).

MazeGametype

A MAZE BEING DRAWN, as pure functions: each takes a game and returns a new one (or the same one, when nothing changed), so a page, a server and a test play by the same rules.

MazeGeometrytype

How a maze lies in space, which is all the measure needs to know of it besides the passages: how far a cell is from the goal (any measure that rises with distance will do, the squared distance is cheapest) and how far the line bends going from one cell through another to a third, in radians from 0 (straight on) to pi (back the way it came).

MazeMeasuretype

HOW HARD A MAZE IS, measured from the maze alone (docs/MAZES.md says why each number is here).

mazeProgressfunction

How far the line has got, for a progress line: cells drawn, keys, and whether it is solved.

measureArrowsfunction

Measure the arrow count, cells, dependency rounds and native clearing effort.

measureMixedfunction

How hard it is: the arrows' effort and half the labyrinth's.

MEIKYUU_ALGORITHMSconstant

THE SEVEN WAYS TO MAKE A PERFECT MAZE, each over any grid: a perfect maze is a spanning tree of the cells, so there is exactly one way between any two of them.

MEIKYUU_LEASTconstant

The least a maze must have to be a level at all, wherever it is in a list (isTooEasy): the straight guess draws at least four cells it did not need, is wrong at two forks or more, and the way has three places to choose, three wrong branches and four dead ends.

MEIKYUU_MODESconstant

A MAZE: a grid, the passages carved through it (always a spanning tree, so exactly one way between any two cells), and how it is played.

MEIKYUU_MOST_ARROW_CELLSconstant

The most cells an arrow board may have: a little over twice the biggest level's (1,849).

MEIKYUU_MOST_CELLSconstant

The most cells a recipe may lay out: a little over twice what the biggest level does (19,321, a heart, leaf, star or moon cut from a raster 139 across).

MEIKYUU_MOST_KEYSconstant

The most keys a recipe may ask for: twice the most any level uses (five).

MeikyuuModetype

The enter/leave, goal, centre-out or key-collecting native maze mode.

MeikyuuShapetype

A supported flat grid geometry or cut-out mask.

MixedBoardtype

A native mixed recipe with its flat maze and arrow layers.

MixedGametype

The current native maze and arrow states of one mixed puzzle.

MixedRecipetype

THE MIXED PUZZLE: an arrow board with some arrows locked, and a labyrinth beside it with an unlock button hidden deep inside.

mixedRecipeCodefunction

Encode a native mixed maze/arrow recipe as reproducible text.

mixedSolvedfunction

Whether the puzzle is won: every arrow cleared.

newArrowGamefunction

Create the native arrow state with all arrows present and a starting heart count.

newMazeGamefunction

A game of the maze, with nothing drawn, and, if given, the rules of its stones (stones.ts).

newMixedGamefunction

Create the native game states for both layers of a mixed board.

parseArrowRecipefunction

A recipe's arrow board from its code, or null when it is not one, or names a board bigger than MEIKYUU_MOST_ARROW_CELLS.

parseMixedRecipefunction

Read native mixed-recipe text, or null for a malformed maze/arrow recipe.

parseRecipefunction

A recipe from its code, or null when it is not one, or names a maze bigger than MEIKYUU_MOST_CELLS or more keys than MEIKYUU_MOST_KEYS.

passageCountfunction

How many passages the maze has: one fewer than its cells, if it is perfect.

peelRoundsfunction

The order the arrows come off in if every free one is taken each round, as rounds: the length of this is how many times the board has to be looked at again.

pickfunction

One of the items, chosen from the stream.

playSolutionfunction

Draw the maze's whole solution through the game, a cell at a time, as a finger would: the way a test or a demo plays.

Pointtype

A point, [x, y], in cells.

pressMazefunction

A finger down on a cell: it begins a stroke if the cell is the start, the line's end, or on the line.

Randomtype

A number in [0, 1), like Math.random, from a stream a seed fixes.

ratingOffunction

An effort as a rating from 1 to 100, on a scale where doubling the effort adds the same each time.

rayOffunction

The cells in front of an arrow's head, out to the edge of the board, nearest first.

recipeCodefunction

A recipe as one short word, such as square:12x9:wilson:to-goal:48213 or heart:25:prim:keys-3:7, and the other way (parseRecipe).

resolveTurnfunction

The turn an orientation means for a maze, given the room when it is auto.

restartArrowsfunction

Restore every native arrow and the original hearts, clearing mistakes and removals.

ringCountsfunction

How many cells each ring of a circle maze holds: one in the middle, six round it, and a ring doubles its cells when its cells would otherwise be wider than tall.

seededRandomfunction

A stream of numbers in [0, 1) fixed by a seed.

shuffledfunction

A copy of the list in a random order (Fisher–Yates); the list given is left alone.

Sidetype

One side of a cell: the cell across it (-1 for the edge of the shape) and the wall it is drawn with.

SOLID_ZONES_TOPconstant

How much of a solid's zones even a whole tour touches.

solutionOffunction

The one way from the start to the goal, cell by cell, both ends included.

squareGridfunction

Columns by rows of square cells.

stepsToLinefunction

The cells steps walk from the maze's start, or null if any step goes where a line cannot: into a wall, off the maze, or back onto the line.

stoneLimitForfunction

How many stones a maze of cells cells gets by default: three, and one more for every hundred cells across (so four for a small maze, nine for a huge one, thirteen for a colossal one).

StoneOptiontype

What the stones option of mountMeikyuu takes: true for the defaults, or any of the rules (limit: null for no limit).

StoneRulestype

STONES: a marble laid on a cell of the maze that the line may not enter.

stoneRulesOffunction

The rules an option means for a maze of cells cells, or null when the option is no stones.

stonesLeftfunction

How many stones can still be laid: null for no limit, and nought for a game with none.

StoneVerdicttype

Why a stone cannot be laid on a cell, or ok.

takeStonefunction

The game with the stone on the cell taken up (and given back); the same game when there is none.

TALL_RATIOconstant

The ratio of a tall container, width over height: two to three.

TALL_WIDTHSconstant

How many cells across each size of the tall levels is.

tallDimensionsfunction

The columns and rows of a maze of shape for the size width (a square maze of that size is width by one and a half times that): as near 2:3 as its cells allow, and with about as many cells as that square maze has (width times one and a half width), so that the sizes are as big to draw whatever the shape is.

tapArrowfunction

Attempt to remove a native arrow and return the new game and removed/blocked/locked/ignored result.

tapMazefunction

A tap on a cell: the line runs along the passage toward it as far as the next place it could have gone another way, or to the cell itself if that comes first.

toDisplayfunction

A logical point as it is shown.

toggleStonefunction

A tap on a cell: a stone there is taken up, and otherwise one is laid.

toLogicalfunction

A point of the picture as the maze has it: the inverse of toDisplay.

triangleGridfunction

Rows of triangles, each pointing up or down in turn, w to a row; a cell is up when its column and row make an even number.

Turntype

0 for a maze shown as it was made, 1 for a quarter turn counter-clockwise.

turnedBoxfunction

The rectangle a logical rectangle takes when shown.

turnForfunction

Whether to turn a maze box (as made) for an orientation.

turnTransformfunction

The SVG transform that shows a logical drawing turned, or none.

undoArrowfunction

Put the last arrow taken back, and give back no heart.

undoMazefunction

Put the whole line back as it was before the last stroke.

unturnedBoxfunction

The logical rectangle a shown rectangle covers: the inverse of turnedBox.

VERSIONconstant

The package's version.

walkfunction

How far every cell is from from along the passages, and the cell before it on the way: -1 where unreachable.

Walltype

The line a wall is drawn along, from a to b.

withMazefunction

The labyrinth changed: when its button is reached, every locked arrow is unlocked.

withStoneRulesfunction

The same game under other rules (the limit or the reach changed, or stones turned on or off): the stones down stay down, and none is ever taken off by a lower limit, only no more laid.

ZONE_REALconstant

A zone with less than this share of an average zone's cells is not a zone (a cross's corners, a ring's hole).

ZONE_VISITconstant

The cells of the answer a zone must hold to be visited.

zonesAcrossfunction

How many zones along each axis a map of cells is cut into: a flat map by 2, 3 or 4, a solid by 2 or 3.