arrowColourfunction
The colour of arrow number id.
Every export of every entry point, each with its own page. This page keeps the addresses the old one-page reference had.
@johnmorrisdotca/meikyuu/drawarrowColourfunctionThe colour of arrow number id.
arrowMarkupfunctionThe arrow's picture: its stem, its head, and a padlock if it is locked.
boardLookOffunctionThe look a board name or board object means.
doorPlacefunctionWhere a door is: the middle of its gap in the wall, and the way out through it as a unit vector.
drawArrowsfunctionRender the native arrow board, locked/present arrows and optional hint as SVG text.
DrawArrowsOptionstypeAN 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.
drawMazefunctionThe maze as SVG text.
DrawMazeOptionstypeNative maze appearance, current trail, collected keys, stones, hints, label and SVG presentation choices.
fixedfunctionA number as short text: two decimals at most, so a drawing is small.
framedfunctionThe rectangle to look at to see the whole of a shape with a margin of pad cells.
linePathfunctionA line through the middles of the cells, in order.
lookAttributesfunctionThe attributes (as text) that make an element a Meikyuu drawing: its class, its look, and its custom properties.
lookStylefunctionThe inline custom properties a look needs: none for plain paper with the default line, which the style gives.
marksOffunctionThe marks on a maze: the start, the goal or exit, the doors and the keys, as SVG.
MazeLooktypeWhat a maze looks like: every option that does not depend on where the line is.
MEIKYUU_ARROW_COLOURSconstantThe colours of each arrow on an arrow board, in turn.
MEIKYUU_BOARD_NAMESconstantThe supported named native maze board appearances.
MEIKYUU_BOARDSconstantThe paper, wall, frame and default trail colours of every named maze board.
MEIKYUU_STRINGSconstantNative English and Japanese labels, announcements and interpolation templates.
MEIKYUU_STYLEconstantThe scoped native SVG styles for mazes and arrow boards.
MEIKYUU_TRAIL_NAMESconstantThe supported named native trail colours.
MEIKYUU_TRAILSconstantThe light and dark colours of every named trail.
MeikyuuBoardLooktypeA 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.
MeikyuuBoardNametypeA supported named maze board appearance.
MeikyuuLanguagetypeTHE 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.
meikyuuLanguageOffunctionThe language a lang attribute asks for: Japanese for any ja, English for everything else.
meikyuuSayfunctionA line in a language, with its {name} values filled in, and its One form when n is 1.
MeikyuuTrailNametypeA supported named trail palette.
standingWallsfunctionEvery wall of the maze that is standing: between cells that are not joined, and round the outside, except the doors.
stonesOffunctionThe 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.
wallPathfunctionThe path data for a wall: a line, or an arc round the middle of a circle maze.
@johnmorrisdotca/meikyuu/playcreateMeikyuuSoundsfunctionCreate the optional synthesized native sound player; sound playback is requested by host actions.
EDGEconstantHow 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_STEPconstantThe native viewport edge-pan step in pixels.
edgeNudgefunctionHow 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.
ensureMeikyuuPlayStylefunctionPut the style in the page once: in the document's head, or in the shadow root the host is in.
FIT_MODESconstantWhat 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.
FitModetypeFit both dimensions, only the width, or only the height of a board.
fitViewfunctionThe 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.
isFittedfunctionWhether the view is the board fitted, as the mode says.
keptViewfunctionA view kept where some of the board can be seen: its middle never leaves the area (with a margin).
MEIKYUU_GUTTERconstantThe page left beside the box, in pixels: the least, and the most the zoom-out widens it to.
MEIKYUU_GUTTER_MAXconstantThe maximum native viewport gutter in pixels.
MEIKYUU_ORIENTATIONSconstantWHICH WAY UP A MAZE IS LOOKED AT.
MEIKYUU_PLAY_STYLEconstantTHE 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_RESERVEconstantWhat 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_KINDSconstantTHE 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).
MeikyuuEventDetailtypeWhat every event tells of the board.
MeikyuuMounttypeThe mounted flat maze, arrow or mixed board, its game/actions, view and cleanup handle.
MeikyuuMountOptionstypeNative puzzle/level/recipe, display, controls, sound, stones and event callbacks for a flat player.
MeikyuuOrientationtypeThe native portrait, landscape or automatic board orientation.
MeikyuuPuzzletypeWhat is being played.
MeikyuuSoundKindtypeOne native synthesized board sound.
MeikyuuSoundstypeNative synthesized sound playback and cleanup methods.
MOST_CELL_PIXELSconstantThe 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).
mountMeikyuufunctionDraw a puzzle into host and play it.
pannedByfunctionThe view moved so that the board slides by (dx, dy) pixels under the box.
pointAtfunctionThe point of the board under a pixel of the box.
puzzleOffunctionThe puzzle a set of options names: a level of the package's lists, or a recipe given, or null.
scaleLimitsfunctionRead the minimum and maximum view scale for this viewport and gutter.
ViewtypeA 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.
ViewBoxtypeHow a box of width by height pixels shows a board: the margin round it in cells, and how far in a view may go.
viewBoxOffunctionThe text of the viewBox attribute that shows the view.
visibleAreafunctionThe part of the board the view shows.
zoomedAboutfunctionThe view zoomed by factor about the pixel (px, py) of the box, which stays over the same spot of the board.
@johnmorrisdotca/meikyuu/elementdefineBoardfunctionRegister a standard or custom tag without replacing a definition.
MEIKYUU_EMBED_OPTION_KEYSconstantThe real mounted-board options, checked by TypeScript and the embed builder.
MeikyuuBoardclassNative custom element with reflected setup and presentation.
MeikyuuElementOptionstypeHost callbacks; the same actions emit native events.
@johnmorrisdotca/meikyuu/element/definedefineBoardfunctionRegister a standard or custom tag without replacing a definition.
MEIKYUU_EMBED_OPTION_KEYSconstantThe real mounted-board options, checked by TypeScript and the embed builder.
MeikyuuBoardclassNative custom element with reflected setup and presentation.
MeikyuuElementOptionstypeHost callbacks; the same actions emit native events.
@johnmorrisdotca/meikyuu/levelsbandOffunctionRead the easy, medium or hard third of a numbered level collection.
findMazeLevelsfunctionThe levels of a kind that pass a filter, with their numbers: by shape, by way to play and by size, each when given.
levelCountfunctionHow many levels a kind has.
levelOffunctionLevel number n (from 1) of a kind, or null when there is none.
levelsOffunctionEvery level of a kind.
mazeLevelOfSizefunctionLevel n (from 1) of a size, or null when there is none.
mazeLevelsOfSizefunctionThe levels of one size, in order: 256 of them, each a little harder than the one before.
MEIKYUU_ARROW_LEVELSconstantThe fixed numbered arrow recipes and their measured effort.
MEIKYUU_KINDSconstantTHE LEVELS: numbered lists of recipes, easiest first, never drawings.
MEIKYUU_LEVELS_PER_SIZEconstantHow many levels each size has: 256, so a size is sixteen pages of sixteen, and the four sizes make 1,024.
MEIKYUU_MAZE_LEVELSconstantThe fixed numbered flat-maze recipes and their measured difficulty metadata.
MEIKYUU_MIXED_LEVELSconstantThe fixed numbered mixed-board recipes and their measured effort.
MEIKYUU_SIZESconstantThe four sizes of the maze list.
MeikyuuArrowLeveltypeA numbered arrow-puzzle recipe and its native difficulty metadata.
MeikyuuBandtypeWhich third of a size's list a level is in: the easy, medium and hard a site files it under.
MeikyuuKindtypeThe flat maze, arrow or mixed puzzle family.
MeikyuuLeveltypeOne native numbered maze, arrow or mixed level.
MeikyuuMazeLeveltypeA numbered flat-maze recipe, difficulty measures, cell count and place within its size.
MeikyuuMixedLeveltypeA numbered mixed-puzzle recipe and its native difficulty metadata.
MeikyuuSizetypeThe small, medium, large or huge numbered flat-maze collection.
sizeOffunctionHow 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/tallfindTallLevelsfunctionThe tall levels that pass a filter, by shape, way to play and size, each when given.
MEIKYUU_TALL_LEVELSconstantThe fixed numbered tall-maze recipes, dimensions and difficulty metadata.
MEIKYUU_TALL_PER_SIZEconstantHow many levels each tall size has.
MEIKYUU_TALL_SIZESconstantThe sizes: their number, how many cells across, and the squares' columns and rows ("6×9").
MeikyuuTallLeveltypeTHE 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_RATIOconstantThe ratio of a tall container, width over height: two to three.
TALL_SHAPESconstantThe shapes that are made tall.
TALL_WIDTHSconstantHow many cells across each size of the tall levels is.
tallDimensionsfunctionThe 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.
tallLevelOffunctionTall level n (from 1) of the whole list, or null when there is none.
tallLevelOfSizefunctionLevel n (from 1) of a size, or null.
tallLevelsOfSizefunctionThe levels of one size (1 to 6), in order.
@johnmorrisdotca/meikyuu/levels/colossalCOLOSSAL_CELLSconstantThe cells a square colossal level has, least and most: a hundred by a hundred is 10,000.
COLOSSAL_TALL_HEIGHTconstantThe native height of a colossal tall maze in cells.
COLOSSAL_TALL_WIDTHconstantHow many cells across a tall colossal level is, and its rows (a square maze of it is 64 by 96, 6,144 cells).
colossalLevelOffunctionSquare colossal level n (from 1), or null when there is none.
colossalTallLevelOffunctionTall colossal level n (from 1), or null when there is none.
findColossalLevelsfunctionThe colossal levels of a list that pass a filter, by shape and way to play, each when given.
MEIKYUU_COLOSSAL_LEVELSconstantThe 128 square colossal levels.
MEIKYUU_COLOSSAL_PER_LISTconstantHow many levels each colossal list has: eight pages of sixteen.
MEIKYUU_COLOSSAL_TALL_LEVELSconstantThe 128 tall colossal levels: 64 across and 96 down, two to three.
MeikyuuColossalLeveltypeTHE COLOSSAL LEVELS: the biggest mazes of the lists, about ten thousand cells, in two lists of 128.
@johnmorrisdotca/meikyuu/levels/legacylegacyLevelOffunctionThe 1.0.0 level with this number, or null.
legacyLevelOfCodefunctionWhat became of a recipe the 1.0.0 list had, or null when it was not one of its levels.
LegacyMazeLeveltypeWHERE THE 1.0.0 MAZE LEVELS WENT.
MEIKYUU_LEGACY_MAZE_LEVELSconstantThe original published flat-maze numbering, its recipes and mappings to current collections.
@johnmorrisdotca/meikyuu/3dbuildSolidMazefunctionMake the maze a recipe names.
cachedSolidGridfunctionThe 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.
cellsAlongDragfunctionThe 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.
checkSolidAnswerfunctionWhether 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.
createFramefunctionRoom for a frame of a solid.
dragTurnfunctionThe turn a drag from one point to another makes: the point of the solid under the first is carried to under the second.
drawSolidfunctionRender a surface maze and optional trail/stones as native SVG text.
DrawSolidOptionstypeA 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_FULLconstantThe normalized threshold used for a full native edge turn.
EDGE_NEIGHBOURconstantThe normalized neighbouring-cell edge-turn threshold.
EDGE_RATEconstantThe fastest the solid turns by itself, in radians a second.
EDGE_SAFEconstantTHE SOLID TURNS BY ITSELF to keep the end of a line being drawn in view.
edgeTurnfunctionCompute a view rotation that follows a surface path near an edge, or null when no turn is needed.
faceCellTurnfunctionThe 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).
isSolidCutfunctionWhether 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).
isSolidDiefunctionWhether a solid is among the dice (the rest are shapes).
MEIKYUU_MOST_SOLID_CELLSconstantThe most cells a solid may have in a recipe: a little over twice the biggest level.
MEIKYUU_SOLID_PER_LISTconstantHow many levels each size of each solid has: eight pages of eight.
openingTurnfunctionA 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.
parseSolidRecipefunctionA recipe from its code, or null when it is not one, or names a solid of more than MEIKYUU_MOST_SOLID_CELLS cells.
pickCellfunctionThe cell the point (x, y) of the picture is on, or -1 for none.
projectFramefunctionPut the solid, turned by q and zoomed, on a picture width by height: fills every array of the frame.
QuattypeA rotation: [x, y, z, w], of length one.
QUAT_IDENTITYconstantThe rotation that does nothing.
quatAnglefunctionHow far apart two rotations are, in radians, from 0 to pi.
quatAxisAnglefunctionThe turn of angle radians about an axis (any length but nought).
quatBetweenfunctionThe shortest turn that carries the direction a onto the direction b.
quatMulfunctionTwo rotations in turn: b after a.
quatNormalizefunctionA rotation made one again: the turns a drag adds up carry a little error, which this takes out.
quatSlerpfunctionHalfway (or any share) from one rotation to another along the shortest way.
quatTurnfunctionA point turned.
SOLID_ALGORITHMSconstantThe algorithms that make a maze over a solid: all but Eller's, which needs rows.
SOLID_CUTSconstantHow many ways each solid is cut, for each size: small, medium, large, huge and colossal.
SOLID_DICEconstantThe dice, by how many sides, smallest first.
SOLID_DIE_SIDESconstantHow many sides a die has (what its name on a die is: d6).
SOLID_EYEconstantHow far the eye is from the middle of the solid, in times its reach.
SOLID_FILLconstantThe share of the box the solid's outline fills at most.
SOLID_FIRSTconstantTHE SOLIDS BY HOW THEY ARE MET.
SOLID_KINDSconstantTHE SURFACE OF A SOLID AS A CELL GRAPH: the one thing a maze over a solid is made on.
SOLID_MORE_DICEconstantThe seven dice that came after the first five, and the six shapes.
SOLID_MORE_SHAPESconstantThe additional box, cross, ring, torus, star and heart surface families.
SOLID_SHAPESconstantThe shapes.
SOLID_SIZE_NAMESconstantTHE 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_LEASTconstantHow 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.
SOLID_ZOOM_MOSTconstantThe maximum native surface-view zoom factor.
SolidAlgorithmtypeA maze-carving algorithm supported on a surface graph.
solidAnswerStepsfunctionThe answer as steps (the format a kept run uses, lineToSteps), for a maze: its whole solution.
solidCellsfunctionHow many cells a solid cut n ways has.
solidCellsOffunctionHow many cells a solid has at a size.
solidCutOffunctionThe cut of a solid at a size.
solidDifficultyOffunctionHow hard a maze over a solid is to play, from 0 to 100, on the very scale flat mazes are scored on (difficultyOf).
SolidEdgetypeThe edge between two cells: its two corners (indices into vertices) and the two cells it lies between.
SolidFrametypeWhere a solid is, as a picture of a given size: the turn, the zoom, and every corner and cell as it lands.
solidGeometryfunctionHow 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.
SolidGridtypeA surface cell graph, neighbouring faces, vertices, projected centres and shape geometry.
solidGridOffunctionThe 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.
SolidKindtypeA supported polyhedron, die or shaped surface for a maze.
SolidMazetypeA maze over a solid: what a flat maze has that is not flat.
SolidRecipetypeEverything that makes a maze over a solid.
solidRecipeCodefunctionA recipe as one short word, such as cube:6:prim:48213, and the other way (parseSolidRecipe).
SolidSizetypeA named small, medium, large, huge or colossal surface-maze collection.
solidSolutionOffunctionThe one way from the start to the goal, cell by cell.
stepTurnfunctionA turn about the viewer's own axes: right radians about the vertical (the solid's near side moves right) and down about the horizontal.
trackballPointfunctionThe 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.
Vec3typeA point or a direction in three dimensions.
@johnmorrisdotca/meikyuu/3d/playensureSolidStylefunctionPut the style of the solid in the page once, beside the board's.
mountSolidfunctionDraw a maze over a solid into host and play it.
SOLID_PLAY_STYLEconstantTHE 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.
SolidCellPlacetypeWhere a cell is on the picture, in pixels from the top left of the box.
SolidEventDetailtypeWhat every event tells of the board.
SolidMounttypeThe mounted surface maze, game, rotation/zoom controls, native progress and cleanup handle.
SolidMountOptionstypeA 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/levelsfindSolidLevelsfunctionAll surface levels in this entry matching the optional kind and size filters.
MEIKYUU_SOLID_LEVELSconstantEvery list this entry has: a solid, then a size.
MEIKYUU_SOLID_PER_LISTconstantHow many levels each size of each solid has: eight pages of eight.
MeikyuuSolidLeveltypeA 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_CUTSconstantHow many ways each solid is cut, for each size: small, medium, large, huge and colossal.
SOLID_FIRSTconstantTHE SOLIDS BY HOW THEY ARE MET.
SOLID_KINDSconstantTHE SURFACE OF A SOLID AS A CELL GRAPH: the one thing a maze over a solid is made on.
SOLID_SIZE_NAMESconstantTHE 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.
solidCellsOffunctionHow many cells a solid has at a size.
solidCutOffunctionThe cut of a solid at a size.
SolidKindtypeA supported polyhedron, die or shaped surface for a maze.
solidLevelOffunctionThe one-based surface level, or null when this entry has no such kind, size or number.
solidLevelsOffunctionThe native surface-level collection for this kind and size; empty when this entry has none.
SolidSizetypeA named small, medium, large, huge or colossal surface-maze collection.
@johnmorrisdotca/meikyuu/3d/levels/dicefindSolidLevelsfunctionAll surface levels in this entry matching the optional kind and size filters.
MEIKYUU_SOLID_LEVELSconstantEvery list this entry has: a solid, then a size.
MEIKYUU_SOLID_PER_LISTconstantHow many levels each size of each solid has: eight pages of eight.
MeikyuuSolidLeveltypeA 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_CUTSconstantHow many ways each solid is cut, for each size: small, medium, large, huge and colossal.
SOLID_KINDSconstantTHE SURFACE OF A SOLID AS A CELL GRAPH: the one thing a maze over a solid is made on.
SOLID_MORE_DICEconstantThe seven dice that came after the first five, and the six shapes.
SOLID_SIZE_NAMESconstantTHE 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.
solidCellsOffunctionHow many cells a solid has at a size.
solidCutOffunctionThe cut of a solid at a size.
SolidKindtypeA supported polyhedron, die or shaped surface for a maze.
solidLevelOffunctionThe one-based surface level, or null when this entry has no such kind, size or number.
solidLevelsOffunctionThe native surface-level collection for this kind and size; empty when this entry has none.
SolidSizetypeA named small, medium, large, huge or colossal surface-maze collection.
@johnmorrisdotca/meikyuu/3d/levels/shapesfindSolidLevelsfunctionAll surface levels in this entry matching the optional kind and size filters.
MEIKYUU_SOLID_LEVELSconstantEvery list this entry has: a solid, then a size.
MEIKYUU_SOLID_PER_LISTconstantHow many levels each size of each solid has: eight pages of eight.
MeikyuuSolidLeveltypeA 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_CUTSconstantHow many ways each solid is cut, for each size: small, medium, large, huge and colossal.
SOLID_KINDSconstantTHE SURFACE OF A SOLID AS A CELL GRAPH: the one thing a maze over a solid is made on.
SOLID_MORE_SHAPESconstantThe additional box, cross, ring, torus, star and heart surface families.
SOLID_SIZE_NAMESconstantTHE 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.
solidCellsOffunctionHow many cells a solid has at a size.
solidCutOffunctionThe cut of a solid at a size.
SolidKindtypeA supported polyhedron, die or shaped surface for a maze.
solidLevelOffunctionThe one-based surface level, or null when this entry has no such kind, size or number.
solidLevelsOffunctionThe native surface-level collection for this kind and size; empty when this entry has none.
SolidSizetypeA named small, medium, large, huge or colossal surface-maze collection.
@johnmorrisdotca/meikyuu/3d/levels/recipessolidLevelNumberOffunctionThe place (from 1) a recipe has among the levels of a solid at a size, or null when it is not one of them.
solidRecipesOffunctionThe 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/allfindSolidLevelsfunctionAll surface levels in this entry matching the optional kind and size filters.
isSolidDiefunctionWhether a solid is among the dice (the rest are shapes).
MEIKYUU_SOLID_LEVELSconstantEvery list: a solid, then a size.
MEIKYUU_SOLID_PER_LISTconstantHow many levels each size of each solid has: eight pages of eight.
MeikyuuSolidLeveltypeA 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_CUTSconstantHow many ways each solid is cut, for each size: small, medium, large, huge and colossal.
SOLID_DICEconstantThe dice, by how many sides, smallest first.
SOLID_DIE_SIDESconstantHow many sides a die has (what its name on a die is: d6).
SOLID_FIRSTconstantTHE SOLIDS BY HOW THEY ARE MET.
SOLID_KINDSconstantTHE SURFACE OF A SOLID AS A CELL GRAPH: the one thing a maze over a solid is made on.
SOLID_MORE_DICEconstantThe seven dice that came after the first five, and the six shapes.
SOLID_MORE_SHAPESconstantThe additional box, cross, ring, torus, star and heart surface families.
SOLID_SHAPESconstantThe shapes.
SOLID_SIZE_NAMESconstantTHE 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.
solidCellsOffunctionHow many cells a solid has at a size.
solidCutOffunctionThe cut of a solid at a size.
SolidKindtypeA supported polyhedron, die or shaped surface for a maze.
solidLevelOffunctionThe one-based surface level, or null when this entry has no such kind, size or number.
solidLevelsOffunctionThe native surface-level collection for this kind and size; empty when this entry has none.
SolidSizetypeA named small, medium, large, huge or colossal surface-maze collection.
@johnmorrisdotca/meikyuuArrowtypeOne arrow: its cells from tail to head (indexes into the board, row by row), and the way its head points.
ARROW_HEARTSconstantThe hearts a puzzle starts with.
ARROW_SHAPESconstantThe pictures an arrow board can be: the whole square, or one of the shapes cut from it.
ARROW_STEPSconstantThe up, right, down and left row/column increments of arrow directions.
ArrowBoardtypeThe native arrow recipe, shape mask, arrow paths and locked flags.
ArrowDirectiontypeWhich way an arrow's head points: up, right, down, left.
ArrowGametypeAN ARROW PUZZLE BEING PLAYED, as pure functions.
ArrowMeasuretypeHow hard an arrow puzzle is: the arrows to clear, the rounds of unblocking they take, and how many are blocked at the start.
ArrowRecipetypeEverything that makes an arrow puzzle.
arrowRecipeCodefunctionA 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.
ArrowShapetypeOne of the supported flat arrow-board masks.
arrowsLeftfunctionThe count of arrows still on the board.
ArrowTaptypeWhat a tap did.
autoTurnfunctionauto: turn a maze when that makes it bigger in the room there is.
belowfunctionA whole number in [0, n) from the stream.
blockedByfunctionThe arrows on the way out of id that are still on the board.
blockersOffunctionWhich arrows block others: for each arrow, the arrows whose cells lie on its way out.
boundaryCellsfunctionThe cells with a side on the edge of the shape: where a door in the outer wall can be.
BoxtypeA rectangle, in cells.
buildMazefunctionMake the maze a recipe names.
buildMixedfunctionBuild the maze and locked-arrow layers of one native mixed recipe.
canLayStonefunctionWhether a stone may be laid on a cell now, and if not, why not.
carveMazefunctionThe open neighbours of every cell, for a perfect maze of the grid made by this algorithm from this stream.
CellGraphtypeWhat a generator reads of a grid: how many cells there are and which are beside which.
cellsAlongfunctionThe 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.
centreCellfunctionThe cell whose middle is nearest the middle of the shape.
circleGridfunctionA circle maze: rings rings round a middle cell, cells running round each ring and out between the rings.
clearArrowsfunctionTake every arrow off by tapping only free ones, the way a test or a demo plays.
clearStonesfunctionEvery stone taken up, in one step Undo can put back.
COVER_FROMconstantWhere cover begins to rise and how far it rises: (mean - COVER_FROM) / COVER_SPAN.
COVER_SPANconstantThe native coverage span used by the geometry-aware score.
COVERAGE_FLOORconstantWhat the score is multiplied by at no cover at all.
coverageOffunctionHow much of a map an answer covers.
decodeRunfunctionThe 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_CEILINGSconstantThe count at which a term reaches its full weight, on its log scale.
DIFFICULTY_WEIGHTSconstantWhat each term is weighed by in the score; they add to 1.
difficultyOffunctionHow hard a maze is, from 0 to 100, and what that is made of.
difficultyOfGraphfunctionThe same for any maze, flat or over a solid, given how it lies in space (MazeGeometry).
DoortypeA door in the outer wall: the cell it is beside, and which of that cell's sides.
dragMazefunctionThe finger moved into a cell.
easyFloorAtfunctionWhat 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_LEASTconstantThe easiest effort a level is given a rating for, and the hardest: 1 and 100 are these.
EFFORT_MOSTconstantThe upper native effort bound used when converting effort to a rating.
encodeRunfunctionA 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.
GridtypeThe native flat cell graph with geometry, neighbour sides, bounds and point-to-cell lookup.
gridOffunctionA grid by name.
hasStonefunctionWhether a cell has a stone on it.
headOffunctionThe end of the line, or null while there is none.
heldByLocksfunctionWhether 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.
hexGridfunctionColumns by rows of hexagons, pointy side up, every odd row shifted half a cell right.
hintArrowfunctionThe arrow to tap next: one that is free now and keeps the most arrows waiting behind it, so it also frees the most others.
hintMazefunctionWhere 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.
isFreefunctionWhether an arrow can be tapped now and slide off: it is on the board, not locked, and nothing is in front of it.
isPerfectfunctionWhether the passages are a spanning tree of the grid: every cell reached, and exactly one way to each.
isTooEasyfunctionWhether 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).
layoutCellsfunctionHow 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).
layStonefunctionThe game with a stone laid on the cell; the same game when it may not be (canLayStone).
liftMazefunctionThe finger lifted.
lineToStepsfunctionA line, cell by cell from the start, as its steps.
LinkstypeEach cell's open neighbours.
makeArrowsfunctionThe arrows of a recipe, in the order they were added: the last one added is free from the start.
MasktypeTHE 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.
maskOffunctionThe outline a raster shape is cut with.
MazetypeA seeded flat maze with its cell graph, passages, doors, endpoints and optional keys.
MazeCoretypeWhat 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.
MazeCoveragetypeHOW MUCH OF THE MAP THE ANSWER COVERS (coverageOf): the second half of a maze's difficulty.
MazeDifficultytypeHOW HARD A MAZE IS TO PLAY, ON ONE SCALE FROM 0 TO 100 (difficultyOf).
MazeGametypeA 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.
MazeGeometrytypeHow 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).
MazeMeasuretypeHOW HARD A MAZE IS, measured from the maze alone (docs/MAZES.md says why each number is here).
mazeProgressfunctionHow far the line has got, for a progress line: cells drawn, keys, and whether it is solved.
MazeRecipetypeEverything that makes a maze.
measureArrowsfunctionMeasure the arrow count, cells, dependency rounds and native clearing effort.
measureMazefunctionMeasure a maze.
measureMixedfunctionHow hard it is: the arrows' effort and half the labyrinth's.
MEIKYUU_ALGORITHMSconstantTHE 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_EASY_PLACESconstantHow far up a size the easy third reaches: its first 86 places.
MEIKYUU_LEASTconstantThe 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_MODESconstantA 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_CELLSconstantThe most cells an arrow board may have: a little over twice the biggest level's (1,849).
MEIKYUU_MOST_CELLSconstantThe 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_KEYSconstantThe most keys a recipe may ask for: twice the most any level uses (five).
MEIKYUU_ORIENTATIONSconstantWHICH WAY UP A MAZE IS LOOKED AT.
MEIKYUU_SHAPESconstantEvery shape a maze can be made on.
MEIKYUU_STONE_REACH_MOSTconstantThe farthest a stone may be from the line: two cells.
MeikyuuAlgorithmtypeOne of the seven native maze-carving algorithms.
MeikyuuModetypeThe enter/leave, goal, centre-out or key-collecting native maze mode.
MeikyuuOrientationtypeThe native portrait, landscape or automatic board orientation.
MeikyuuShapetypeA supported flat grid geometry or cut-out mask.
MixedBoardtypeA native mixed recipe with its flat maze and arrow layers.
MixedGametypeThe current native maze and arrow states of one mixed puzzle.
MixedRecipetypeTHE MIXED PUZZLE: an arrow board with some arrows locked, and a labyrinth beside it with an unlock button hidden deep inside.
mixedRecipeCodefunctionEncode a native mixed maze/arrow recipe as reproducible text.
mixedSolvedfunctionWhether the puzzle is won: every arrow cleared.
newArrowGamefunctionCreate the native arrow state with all arrows present and a starting heart count.
newMazeGamefunctionA game of the maze, with nothing drawn, and, if given, the rules of its stones (stones.ts).
newMixedGamefunctionCreate the native game states for both layers of a mixed board.
parseArrowRecipefunctionA recipe's arrow board from its code, or null when it is not one, or names a board bigger than MEIKYUU_MOST_ARROW_CELLS.
parseMixedRecipefunctionRead native mixed-recipe text, or null for a malformed maze/arrow recipe.
parseRecipefunctionA 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.
passageCountfunctionHow many passages the maze has: one fewer than its cells, if it is perfect.
peelRoundsfunctionThe 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.
pickfunctionOne of the items, chosen from the stream.
playSolutionfunctionDraw 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.
PointtypeA point, [x, y], in cells.
pressMazefunctionA finger down on a cell: it begins a stroke if the cell is the start, the line's end, or on the line.
RandomtypeA number in [0, 1), like Math.random, from a stream a seed fixes.
ratingOffunctionAn effort as a rating from 1 to 100, on a scale where doubling the effort adds the same each time.
rayOffunctionThe cells in front of an arrow's head, out to the edge of the board, nearest first.
recipeCodefunctionA 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).
resolveTurnfunctionThe turn an orientation means for a maze, given the room when it is auto.
restartArrowsfunctionRestore every native arrow and the original hearts, clearing mistakes and removals.
restartMazefunctionEverything off the maze again.
ringCountsfunctionHow 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.
seededRandomfunctionA stream of numbers in [0, 1) fixed by a seed.
shuffledfunctionA copy of the list in a random order (Fisher–Yates); the list given is left alone.
SidetypeOne side of a cell: the cell across it (-1 for the edge of the shape) and the wall it is drawn with.
SOLID_ZONES_TOPconstantHow much of a solid's zones even a whole tour touches.
solutionOffunctionThe one way from the start to the goal, cell by cell, both ends included.
squareGridfunctionColumns by rows of square cells.
stepsToLinefunctionThe 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.
stoneLimitForfunctionHow 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).
StoneOptiontypeWhat the stones option of mountMeikyuu takes: true for the defaults, or any of the rules (limit: null for no limit).
StoneRulestypeSTONES: a marble laid on a cell of the maze that the line may not enter.
stoneRulesOffunctionThe rules an option means for a maze of cells cells, or null when the option is no stones.
stonesLeftfunctionHow many stones can still be laid: null for no limit, and nought for a game with none.
StoneVerdicttypeWhy a stone cannot be laid on a cell, or ok.
takeStonefunctionThe game with the stone on the cell taken up (and given back); the same game when there is none.
TALL_RATIOconstantThe ratio of a tall container, width over height: two to three.
TALL_SHAPESconstantThe shapes that are made tall.
TALL_WIDTHSconstantHow many cells across each size of the tall levels is.
tallDimensionsfunctionThe 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.
tapArrowfunctionAttempt to remove a native arrow and return the new game and removed/blocked/locked/ignored result.
tapMazefunctionA 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.
toDisplayfunctionA logical point as it is shown.
toggleStonefunctionA tap on a cell: a stone there is taken up, and otherwise one is laid.
toLogicalfunctionA point of the picture as the maze has it: the inverse of toDisplay.
triangleGridfunctionRows 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.
Turntype0 for a maze shown as it was made, 1 for a quarter turn counter-clockwise.
turnedBoxfunctionThe rectangle a logical rectangle takes when shown.
turnForfunctionWhether to turn a maze box (as made) for an orientation.
turnTransformfunctionThe SVG transform that shows a logical drawing turned, or none.
undoArrowfunctionPut the last arrow taken back, and give back no heart.
undoMazefunctionPut the whole line back as it was before the last stroke.
unlockArrowsfunctionLet the locked arrows be tapped.
unturnedBoxfunctionThe logical rectangle a shown rectangle covers: the inverse of turnedBox.
VERSIONconstantThe package's version.
walkfunctionHow far every cell is from from along the passages, and the cell before it on the way: -1 where unreachable.
WalltypeThe line a wall is drawn along, from a to b.
withArrowsfunctionThe arrows changed.
withMazefunctionThe labyrinth changed: when its button is reached, every locked arrow is unlocked.
withStoneRulesfunctionThe 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_REALconstantA 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_VISITconstantThe cells of the answer a zone must hold to be visited.
zonesAcrossfunctionHow 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.