# Bloxorz

> A free browser reimplementation of Bloxorz, the block-rolling puzzle game Damien Clarke published
> as a Flash game in 2007. A 1x1x2 block stands on a floating 15x10 grid of tiles; the arrow keys
> roll it, and the stage ends when it drops, standing upright, into the square hole. Bridges are
> worked by octagonal soft switches and X-shaped hard switches, orange tiles crumble under a
> standing block, and a bracket switch splits the block into two cubes steered one at a time with
> the space bar. 33 stages, each with a six-digit passcode. Drawn in real 3D with WebGL2. There is
> no AI lane, no sign-in, no API and nothing metered: the page is free and runs entirely in the
> browser.

## What it does

- Rolls a 1x1x2 block over a fixed 15 by 10 board with the arrow keys. Standing, it covers one tile;
  lying, it covers two. Roll off the edge and the stage restarts - there are no lives.
- Ends a stage only when the block falls into the square hole **standing upright**. Nothing rests on
  the hole, so a lying block left across it drops through.
- Orange fragile tiles hold a lying block or a lone cube and give way under a standing one.
- Octagonal soft switches fire under any tile the block covers, standing or lying, and under a lone
  cube. X-marked hard switches fire only under a standing block. Each switch opens a bridge, closes
  one, or toggles it, and one press can do both to different bridges. Bridges may start open.
- A bracket-marked split switch teleports the block away as two 1x1x1 cubes on two pads; space swaps
  which you steer; they rejoin as a lying block when they come to rest side by side. A cube can work
  soft switches but not hard ones and can never finish a stage.
- 33 stages, each with a six-digit passcode shown in the top right corner of the board, and a
  passcode box in Stage select. Deep links such as https://bloxorz.skillsafe.ai/#stage-7 open a
  stage directly.
- Progress, per-stage best move counts and times, totals and the stage in progress are stored in
  this browser only.
- Optional extras, all off by default and all labelled on the page as not being in the original:
  undo, a par readout, a hint that plays one move from an optimal route computed live, sound, and a
  reduced-motion mode.

## How to use it

Open https://bloxorz.skillsafe.ai/ and press the arrow keys. Space swaps cubes while split, R
restarts the stage, and on a touch screen there is an on-screen pad and swipe control. Stage select
takes a six-digit passcode.

## Stages, par and how they are verified

The 33 stage layouts are **original work by this page**, not the layouts of the 2007 original, which
are Damien Clarke's creative work and are not reproduced. They follow the original's documented
order of teaching, read from the original's own level data: plain boards at 1, 3 and 6; the whole
switch-and-bridge system at 2; orange tiles at 4; bridges that start open at 5; a lone hard switch
at 7; the split switch alone at 8 and 9; everything combined at 10; and no new vocabulary after 15.

Each stage ships a **par**, its true optimal move count. Par is established by three methods that
have to agree: a solver written from the raw stage text with its own implementation of the rules and
no access to the game engine; a replay of that solver's exact route through the engine; and a second
breadth-first search over the engine's own state space. Each stage is also checked so that it cannot
be finished with any of its switches disabled - or, for a switch meant to be routed around, that
removing it makes the optimum strictly shorter - and so that every field of fragile tiles genuinely
constrains the route. Pars run from 9 moves on stage 1 to 57 on stage 33.

Passcodes are this page's own, because the stages are: `100000 + (mix32(n) mod 900000)`, with
`mix32` the 32-bit xor-shift-multiply finalizer that `mulberry32` ends with. The original's published
codes do not work here and the page says so.

## Sources and attribution

Bloxorz was created by Damien Clarke under the label DX Interactive and first published in 2007 as
an Adobe Flash game. This page is an independent reimplementation and is not affiliated with or
endorsed by him or by any portal that hosts the original. No code, art, sound, level data or
passcode from the original is reused. Rules and presentation were established from the author's own
instruction text (preserved on Coolmath Games' 2009 page in the Internet Archive) and from the
original SWF archived at archive.org/details/flash_bloxorz. Full detail, including the one rule that
could not be sourced and is marked reconstructed, is in https://bloxorz.skillsafe.ai/CREDITS.txt.

## Technical

- Static page, no build step, no framework, no third-party script. WebGL2 for the board: a
  hand-written renderer with a 4x4 matrix stack, a perspective camera fixed high over the board,
  per-face lighting, real depth testing and chamfered geometry generated in code.
- The engine (js/bloxorz.js) is pure and deterministic: no DOM, no timers, no storage, no mutation.
- Licence: MIT, https://bloxorz.skillsafe.ai/LICENSE.txt