@wodzik/cubecore 0.1.5 → 0.1.7

package/bluetooth/rotations.d.ts

@@ -60,9 +60,19 @@ export declare function heldMove(move: string, grip: Grip): string;
  * y2, y y' = nothing), and slices / wide moves read from face moves with
  * the core's rotation.
  */
-export declare function heldTokens(moves: readonly TimedMove[], startRotation: string, rotations: readonly RotationRecord[]): HeldToken[];
+export interface HeldOptions {
+    /**
+     * Wide moves to read from one face turn and the core's rotation — the rest
+     * stay a face turn and a rotation. Default r, l, f, b: a u or d is almost
+     * always a U / D turn and a y regrip. Slices (both faces of an axis) are
+     * always read.
+     */
+    wide?: readonly string[];
+}
+export declare const DEFAULT_WIDE: readonly string[];
+export declare function heldTokens(moves: readonly TimedMove[], startRotation: string, rotations: readonly RotationRecord[], options?: HeldOptions): HeldToken[];
 /** A rotation and the face moves around it that make a slice / wide move → that move. */
-export declare function mergeSlicesAndWides(tokens: readonly HeldToken[]): HeldToken[];
+export declare function mergeSlicesAndWides(tokens: readonly HeldToken[], allowed?: ReadonlySet<string>): HeldToken[];
 export interface GripEvent {
     /** Moves the session had reported before it (its stream position). */
     after: number;

package/bluetooth/rotations.js

@@ -28,34 +28,32 @@ export function heldMove(move, grip) {
     const canonical = Object.keys(grip.face).find((c) => grip.face[c] === face);
     return canonical ? canonical + move.slice(1) : move;
 }
-/**
- * The moves as the solver saw them: re-lettered for the grip each was made
- * in (`startRotation` from white top / green front — U up, F front — then
- * the rotations), rotations between them (back-to-back ones combined: y y =
- * y2, y y' = nothing), and slices / wide moves read from face moves with
- * the core's rotation.
- */
-export function heldTokens(moves, startRotation, rotations) {
+export const DEFAULT_WIDE = ["r", "l", "f", "b"];
+export function heldTokens(moves, startRotation, rotations, options = {}) {
+    const allowed = new Set(options.wide ?? DEFAULT_WIDE);
     let grip = rotateGrip(IDENTITY_GRIP, startRotation);
-    const rots = snapToSlices(moves, grip, [...rotations].sort((a, b) => a.after - b.after || a.t - b.t));
+    const rots = snapToSlices(moves, grip, [...rotations].sort((a, b) => a.after - b.after || a.t - b.t), allowed);
     const tokens = [];
     let r = 0;
     for (let i = 0; i <= moves.length; i++) {
         let target = grip;
-        let t = 0;
+        // Several at one place (a peek at the back and back: x x' x) are one net
+        // rotation — timed by the first: that's when it began (a slice's rotation
+        // then still sits with its face moves).
+        let t = null;
         while (r < rots.length && rots[r].after <= i) {
             target = rotateGrip(target, rots[r].move);
-            t = rots[r].t;
+            t ??= rots[r].t;
             r++;
         }
         const net = rotationBetween(grip, target);
         if (net)
-            tokens.push({ kind: "rotation", move: net, t, after: i });
+            tokens.push({ kind: "rotation", move: net, t: t ?? 0, after: i });
         grip = target;
         if (i < moves.length)
             tokens.push({ kind: "move", move: heldMove(moves[i].move, grip), t: moves[i].t, index: i });
     }
-    return mergeSlicesAndWides(tokens);
+    return mergeSlicesAndWides(tokens, allowed);
 }
 // ─── slices and wide moves ──────────────────────────────────────────────
 /** A slice / wide move's face moves and its rotation, reported this far apart (ms), are one move. */
@@ -71,12 +69,13 @@ const AXIS_FACES = { x: ["R", "L"], y: ["U", "D"], z: ["F", "B"] };
 const SLICE_WIDE = ["M", "E", "S", "r", "l", "u", "d", "f", "b"].flatMap((f) => [f, `${f}'`, `${f}2`]);
 const effect = (alg) => applyMoves(solvedState(), alg).join();
 const SLICE_WIDE_EFFECT = new Map();
-/** The slice / wide move the group (held letters and a rotation) amounts to, or null. */
-function sliceOrWide(group) {
+/** The slice (or an `allowed` wide move) the group (held letters and a rotation) amounts to, or null. */
+function sliceOrWide(group, allowed) {
     if (SLICE_WIDE_EFFECT.size === 0)
         for (const m of SLICE_WIDE)
             SLICE_WIDE_EFFECT.set(effect(m), m);
-    return SLICE_WIDE_EFFECT.get(effect(group.join(" "))) ?? null;
+    const m = SLICE_WIDE_EFFECT.get(effect(group.join(" ")));
+    return m && ("MES".includes(m[0]) || allowed.has(m[0])) ? m : null;
 }
 /**
  * The consecutive run (up to MAX_GROUP) of moves on the axis nearest to
@@ -108,7 +107,7 @@ function axisRun(moves, from, dir, onAxis, t) {
  * slice's signature (both faces of the axis) is trusted: one face and a
  * rotation could as well be a face turn and a real regrip.
  */
-function snapToSlices(moves, startGrip, rotations) {
+function snapToSlices(moves, startGrip, rotations, allowed) {
     let grip = startGrip;
     const out = rotations.map((r) => ({ ...r }));
     for (const r of out) {
@@ -130,7 +129,7 @@ function snapToSlices(moves, startGrip, rotations) {
                 const far = idx.some((j) => Math.abs(moves[j].t - r.t) > SNAP_MS);
                 if (far && new Set(idx.map((j) => moves[j].move[0])).size < 2)
                     continue;
-                if (sliceOrWide([...letters(idx), r.move])) {
+                if (sliceOrWide([...letters(idx), r.move], allowed)) {
                     r.after = after;
                     // It happened with those moves: its time is theirs.
                     r.t = moves[after > idx[0] ? idx.at(-1) : idx[0]].t;
@@ -143,7 +142,7 @@ function snapToSlices(moves, startGrip, rotations) {
     return out.sort((a, b) => a.after - b.after || a.t - b.t);
 }
 /** A rotation and the face moves around it that make a slice / wide move → that move. */
-export function mergeSlicesAndWides(tokens) {
+export function mergeSlicesAndWides(tokens, allowed = new Set(DEFAULT_WIDE)) {
     const out = [...tokens];
     for (let k = 0; k < out.length; k++) {
         const rot = out[k];
@@ -162,7 +161,7 @@ export function mergeSlicesAndWides(tokens) {
             const groupMoves = group.filter((t) => t.kind === "move");
             if (groupMoves.length !== group.length - 1 || groupMoves.some((m) => Math.abs(m.t - rot.t) > SAME_MOMENT_MS))
                 continue;
-            const merged = sliceOrWide(group.map((t) => t.move));
+            const merged = sliceOrWide(group.map((t) => t.move), allowed);
             if (!merged)
                 continue;
             const first = groupMoves[0];

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "A 3×3×3 cube library for the web, built around smart (Bluetooth) cubes: state, notation, methods, solvers and scrambles, a three.js renderer with skins, pictures, web components, React bindings.",
   "license": "MPL-2.0",
   "author": "Tomasz Wodzikowski <wodziszczakow@gmail.com>",

package/render/layers.js

@@ -7,11 +7,12 @@
  * switches to S·m with nothing rotated. The two pictures coincide, so there is
  * no pop — and the scene never has to track which physical cubie is where.
  */
-import { FAMILY, amountQuarters } from "../core/index.js";
+import { FAMILY, writtenQuarters } from "../core/index.js";
 export function layerTurn(move) {
     const def = FAMILY[move.family];
-    // A family's clockwise turn is `def.q` CCW quarters about +axis; the amount multiplies it.
-    const quarters = def.q * (move.amount === -1 ? -1 : move.amount === 2 ? 2 : 1);
+    // A family's clockwise turn is `def.q` CCW quarters about +axis; the turn as written multiplies it
+    // (U2' goes the other way than U2 — the state is the same, the hands aren't).
+    const quarters = def.q * writtenQuarters(move);
     return {
         axis: def.axis,
         angle: (quarters * Math.PI) / 2,
@@ -20,5 +21,6 @@ export function layerTurn(move) {
 }
 /** Default animation length for a move, scaled by how far it turns (half turns take longer). */
 export function defaultDuration(move, quarterMs = 120) {
-    return amountQuarters(move.amount) === 2 ? quarterMs * 1.5 : quarterMs;
+    const q = Math.abs(writtenQuarters(move));
+    return q === 1 ? quarterMs : quarterMs * (1 + 0.5 * (q - 1));
 }