cubing 0.20.2 → 0.21.0-pre12

package/src/cubing/puzzle-geometry/Quat.ts

@@ -6,22 +6,6 @@
 
 const eps = 1e-9; // TODO: Deduplicate with `PuzzleGeometry`?
 
-export function expandfaces(rots: Quat[], faces: Quat[][]): Quat[][] {
-  // given a set of faces, expand by rotation set
-  const nfaces = [];
-  for (let i = 0; i < rots.length; i++) {
-    for (let k = 0; k < faces.length; k++) {
-      const face = faces[k];
-      const nface = [];
-      for (let j = 0; j < face.length; j++) {
-        nface.push(face[j].rotateplane(rots[i]));
-      }
-      nfaces.push(nface);
-    }
-  }
-  return nfaces;
-}
-
 export function centermassface(face: Quat[]): Quat {
   // calculate a center of a face by averaging points
   let s = new Quat(0, 0, 0, 0);
@@ -31,17 +15,6 @@ export function centermassface(face: Quat[]): Quat {
   return s.smul(1.0 / face.length);
 }
 
-export function random(): Quat {
-  // generate a random quat
-  const q = new Quat(
-    Math.random() * 2 - 1,
-    Math.random() * 2 - 1,
-    Math.random() * 2 - 1,
-    Math.random() * 2 - 1,
-  );
-  return q.smul(1 / q.len());
-}
-
 export function solvethreeplanes(
   p1: number,
   p2: number,
@@ -69,41 +42,6 @@ export function solvethreeplanes(
   return p;
 }
 
-export class FaceTree {
-  constructor(
-    public face: Quat[],
-    public left?: FaceTree,
-    public right?: FaceTree,
-  ) {}
-
-  public split(q: Quat): FaceTree {
-    const t = q.cutface(this.face);
-    if (t !== null) {
-      if (this.left === undefined) {
-        this.left = new FaceTree(t[0]);
-        this.right = new FaceTree(t[1]);
-      } else {
-        this.left = this.left?.split(q);
-        this.right = this.right?.split(q);
-      }
-    }
-    return this;
-  }
-
-  public collect(arr: Quat[][], leftfirst: boolean): Quat[][] {
-    if (this.left === undefined) {
-      arr.push(this.face);
-    } else if (leftfirst) {
-      this.left?.collect(arr, false);
-      this.right?.collect(arr, true);
-    } else {
-      this.right?.collect(arr, false);
-      this.left?.collect(arr, true);
-    }
-    return arr;
-  }
-}
-
 export class Quat {
   constructor(
     public a: number,
@@ -123,7 +61,7 @@ export class Quat {
   }
 
   public toString(): string {
-    return "Q[" + this.a + "," + this.b + "," + this.c + "," + this.d + "]";
+    return `Q[${this.a},${this.b},${this.c},${this.d}]`;
   }
 
   public dist(q: Quat): number {
@@ -270,11 +208,6 @@ export class Quat {
     return face.map((_: Quat) => _.rotatepoint(this));
   }
 
-  public rotatecubie(cubie: Quat[][]): Quat[][] {
-    // rotate a cubie by this Q.
-    return cubie.map((_: Quat[]) => this.rotateface(_));
-  }
-
   public intersect3(p2: Quat, p3: Quat): Quat | false {
     // intersect three planes if there is one
     const det = this.det3x3(

package/src/cubing/puzzle-geometry/SchreierSims.ts

@@ -35,7 +35,7 @@ class FactoredNumber {
         }
         r += i;
         if (this.mult[i] > 1) {
-          r += "^" + this.mult[i];
+          r += `^${this.mult[i]}`;
         }
       }
     }
@@ -135,18 +135,7 @@ export function schreierSims(g: Perm[], disp: (s: string) => void): number {
         sollen += avg;
       }
       disp(
-        "" +
-          i +
-          ": sz " +
-          sz +
-          " T " +
-          tks +
-          " sol " +
-          sollen +
-          " none " +
-          none +
-          " mults " +
-          mults,
+        `${i}: sz ${sz} T ${tks} sol ${sollen} none ${none} mults ${mults.toString()}`,
       );
     }
     return sz;

package/src/cubing/puzzle-geometry/index.ts

@@ -1,19 +1,10 @@
-export { Perm } from "./Perm";
-export {
-  Orbit,
-  OrbitDef,
-  OrbitsDef,
-  Transformation,
-  VisibleState,
-} from "./PermOriSet";
 export {
   getpuzzle,
   getPuzzleGeometryByDesc,
   getPuzzleGeometryByName,
   getpuzzles,
-  parsedesc,
+  parsePuzzleDescription,
   PuzzleGeometry,
-  useNewFaceNames,
 } from "./PuzzleGeometry";
 export type {
   StickerDat,
@@ -21,6 +12,6 @@ export type {
   StickerDatFace,
   StickerDatSticker,
 } from "./PuzzleGeometry";
-export { parseoptions } from "./Options";
+export { parseOptions } from "./Options";
 export { Quat } from "./Quat";
 export { schreierSims } from "./SchreierSims";

package/src/cubing/puzzle-geometry/interfaces.ts

@@ -1,32 +1,6 @@
-//   We don't want to introduce dependencies from alg or kpuzzle or other
-//   tools into puzzle geometry, but we do want to interoperate with them.
-//   This file contains interface declarations for some of the things we
-//   use interoperably.  These definitions are not identical to those in
-//   the corresponding classes but they are interoperable.
-
 import type { Move } from "../alg";
+import type { Transformation } from "../kpuzzle";
 
 export interface MoveNotation {
   lookupMove(move: Move): Transformation | undefined;
 }
-
-export interface PGVendoredOrbitTransformation {
-  permutation: number[];
-  orientation: number[];
-}
-
-export type Transformation = Record<string, PGVendoredOrbitTransformation>;
-
-export interface PGVendoredOrbitDefinition {
-  numPieces: number;
-  orientations: number;
-}
-
-export interface PGVendoredKPuzzleDefinition {
-  name: string;
-  orbits: { [key: string]: PGVendoredOrbitDefinition };
-  startPieces: Transformation;
-  moves: { [key: string]: Transformation };
-  svg?: string;
-  moveNotation?: MoveNotation;
-}

package/src/cubing/puzzle-geometry/orientcenters.spec.ts

@@ -7,53 +7,47 @@ import { getPuzzleGeometryByName, schreierSims } from ".";
  */
 describe("PuzzleGeometry-OrientCenters", () => {
   it("testcenterorientation", () => {
-    let options = [
-      "orientcenters",
-      "true",
-      "movelist",
-      '["2U","2R","2F"]',
-      "edgesets",
-      "false",
-      "cornersets",
-      "false",
-    ];
-    let pg = getPuzzleGeometryByName("3x3x3", options);
+    let pg = getPuzzleGeometryByName("3x3x3", {
+      orientCenters: true,
+      moveList: ["2U", "2R", "2F"],
+      includeEdgeOrbits: false,
+      includeCornerOrbits: false,
+    });
     let os = pg.getOrbitsDef(false);
     let ss = schreierSims(
-      os.moveops.map((_: any) => _.toPerm()),
+      os.moveops.map((_) => _.toPerm()),
       (_) => null,
     );
     expect(ss).toBe(768);
-    options = ["orientcenters", "true", "cornersets", "false"];
-    pg = getPuzzleGeometryByName("skewb", options);
+    pg = getPuzzleGeometryByName("skewb", {
+      orientCenters: true,
+      includeCornerOrbits: false,
+    });
     os = pg.getOrbitsDef(false);
     ss = schreierSims(
-      os.moveops.map((_: any) => _.toPerm()),
+      os.moveops.map((_) => _.toPerm()),
       (_) => null,
     );
     expect(ss).toBe(11520);
-    options = [
-      "orientcenters",
-      "true",
-      "cornersets",
-      "false",
-      "edgesets",
-      "false",
-      "allmoves",
-      "true",
-    ];
-    pg = getPuzzleGeometryByName("starminx", options);
+    pg = getPuzzleGeometryByName("starminx", {
+      orientCenters: true,
+      includeCornerOrbits: false,
+      includeEdgeOrbits: false,
+      allMoves: true,
+    });
     os = pg.getOrbitsDef(false);
     ss = schreierSims(
-      os.moveops.map((_: any) => _.toPerm()),
+      os.moveops.map((_) => _.toPerm()),
       (_) => null,
     );
     expect(ss).toBe(60);
-    options = ["orientcenters", "true", "cornersets", "false"];
-    pg = getPuzzleGeometryByName("pentultimate", options);
+    pg = getPuzzleGeometryByName("pentultimate", {
+      orientCenters: true,
+      includeCornerOrbits: false,
+    });
     os = pg.getOrbitsDef(false);
     ss = schreierSims(
-      os.moveops.map((_: any) => _.toPerm()),
+      os.moveops.map((_) => _.toPerm()),
       (_) => null,
     );
     expect(ss).toBe(58471875000000000);

package/src/cubing/puzzles/PuzzleLoader.ts

@@ -5,7 +5,7 @@ import type { PuzzleAppearance } from "./stickerings/appearance";
 
 export interface PuzzleLoader {
   id: string;
-  // shortname?: string;
+  // shortName?: string;
   fullName: string;
   inventedBy?: string[];
   inventionYear?: number; // TODO: date?

package/src/cubing/puzzles/async/async-pg3d.ts

@@ -11,14 +11,11 @@ export async function asyncGetPuzzleGeometry(
   puzzleName: string,
 ): Promise<PuzzleGeometry> {
   const puzzleGeometry = await import("../../puzzle-geometry");
-  return puzzleGeometry.getPuzzleGeometryByName(puzzleName, [
-    "allmoves",
-    "true",
-    "orientcenters",
-    "true",
-    "rotations",
-    "true",
-  ]);
+  return puzzleGeometry.getPuzzleGeometryByName(puzzleName, {
+    allMoves: true,
+    orientCenters: true,
+    addRotations: true,
+  });
 }
 
 // TODO: can we cache the puzzleGeometry to avoid duplicate calls, without

package/src/cubing/puzzles/customPGPuzzleLoader.ts

@@ -0,0 +1,60 @@
+import type { KPuzzleDefinition } from "../kpuzzle";
+import type { PuzzleGeometry } from "../puzzle-geometry";
+import type { PuzzleDescriptionString } from "../puzzle-geometry/PGPuzzles";
+import type { PuzzleLoader } from "./PuzzleLoader";
+
+// TODO: modify this to handle TwistyPlayer options
+export async function descAsyncGetPuzzleGeometry(
+  desc: PuzzleDescriptionString,
+): Promise<PuzzleGeometry> {
+  const puzzleGeometry = await import("../puzzle-geometry");
+  return puzzleGeometry.getPuzzleGeometryByDesc(desc, {
+    allMoves: true,
+    orientCenters: true,
+    addRotations: true,
+  });
+}
+
+// TODO: can we cache the puzzleGeometry to avoid duplicate calls, without
+// wasting memory? Maybe just save the latest one for successive calls about the
+// same puzzle?
+export async function dsecAsyncGetDef(
+  desc: PuzzleDescriptionString,
+): Promise<KPuzzleDefinition> {
+  return (await descAsyncGetPuzzleGeometry(desc)).writekpuzzle(true);
+}
+
+// TODO: Can we avoid relying on IDs to deduplicate work at higher levels?
+let nextCustomID = 1;
+
+export function customPGPuzzleLoader(
+  desc: PuzzleDescriptionString,
+  info?: {
+    fullName?: string;
+    inventedBy?: string[];
+    inventionYear?: number;
+  },
+): PuzzleLoader {
+  const customID = nextCustomID++;
+  const puzzleLoader: PuzzleLoader = {
+    id: `custom-${customID}`,
+    fullName: info?.fullName ?? `Custom Puzzle (instance #${customID})`,
+    def: async () => {
+      return dsecAsyncGetDef(desc);
+    },
+    svg: async () => {
+      const pg = await descAsyncGetPuzzleGeometry(desc);
+      return pg.generatesvg();
+    },
+    pg: async () => {
+      return descAsyncGetPuzzleGeometry(desc);
+    },
+  };
+  if (info?.inventedBy) {
+    puzzleLoader.inventedBy = info.inventedBy;
+  }
+  if (info?.inventionYear) {
+    puzzleLoader.inventionYear = info.inventionYear;
+  }
+  return puzzleLoader;
+}

package/src/cubing/puzzles/implementations/2x2x2/index.ts

@@ -11,7 +11,7 @@ export const cube2x2x2: PuzzleLoader = {
   id: "2x2x2",
   fullName: "2×2×2 Cube",
   def: async () => {
-    return (await import("./2x2x2.kpuzzle.json_")).cube2x2x2KPuzzle;
+    return (await import("./2x2x2.kpuzzle.json")).cube2x2x2KPuzzle;
   },
   svg: async () => {
     return (await import("./2x2x2.kpuzzle.svg")).default;

package/src/cubing/puzzles/implementations/3x3x3/index.ts

@@ -1,3 +1,5 @@
+// Include 3x3x3 in the main bundle for better performance.
+import { experimentalCube3x3x3KPuzzle as cube3x3x3KPuzzle } from "../../../kpuzzle";
 import type { ExperimentalStickering } from "../../../twisty";
 import { asyncGetPuzzleGeometry } from "../../async/async-pg3d";
 import type { PuzzleLoader } from "../../PuzzleLoader";
@@ -7,9 +9,6 @@ import {
   cubeStickerings,
 } from "../../stickerings/cube-stickerings";
 
-// Include 3x3x3 in the main bundle for better performance.
-import { cube3x3x3KPuzzle } from "./3x3x3.kpuzzle.json_";
-
 export const cube3x3x3: PuzzleLoader = {
   id: "3x3x3",
   fullName: "3×3×3 Cube",

package/src/cubing/puzzles/implementations/clock/index.ts

@@ -6,7 +6,7 @@ export const clock: PuzzleLoader = {
   inventedBy: ["Christopher C. Wiggs", "Christopher J. Taylor"],
   inventionYear: 1988, // Patent application year: https://www.jaapsch.net/puzzles/patents/us4869506.pdf
   def: async () => {
-    return (await import("./clock.kpuzzle.json_")).clockKPuzzle;
+    return (await import("./clock.kpuzzle.json")).clockKPuzzle;
   },
   svg: async () => {
     return (await import("./clock.kpuzzle.svg")).default;

package/src/cubing/puzzles/implementations/fto/index.ts

@@ -1,20 +1,28 @@
+import type { PuzzleLoader } from "../..";
 import type { ExperimentalStickering } from "../../../twisty";
-import { genericPGPuzzleLoader } from "../../async/async-pg3d";
+import { asyncGetDef, asyncGetPuzzleGeometry } from "../../async/async-pg3d";
 import type { PuzzleAppearance } from "../../stickerings/appearance";
 import {
   ftoStickering,
   ftoStickerings,
 } from "../../stickerings/fto-stickerings";
 
-const fto = genericPGPuzzleLoader("FTO", "Face-Turning Octahedron", {
+export const fto: PuzzleLoader = {
+  id: "fto",
+  fullName: "Face-Turning Octahedron",
   inventedBy: ["Karl Rohrbach", "David Pitcher"], // http://twistypuzzles.com/cgi-bin/puzzle.cgi?pkey=1663
   inventionYear: 1983, // http://twistypuzzles.com/cgi-bin/puzzle.cgi?pkey=1663
-});
-
-// TODO: loading the stickering code async.
-fto.appearance = (
-  stickering: ExperimentalStickering,
-): Promise<PuzzleAppearance> => ftoStickering(fto, stickering);
-fto.stickerings = ftoStickerings;
-
-export { fto };
+  def: async () => {
+    return asyncGetDef("FTO");
+  },
+  svg: async () => {
+    const pg = await asyncGetPuzzleGeometry("FTO");
+    return pg.generatesvg();
+  },
+  pg: async () => {
+    return asyncGetPuzzleGeometry("FTO");
+  },
+  appearance: (stickering: ExperimentalStickering): Promise<PuzzleAppearance> =>
+    ftoStickering(fto, stickering),
+  stickerings: ftoStickerings,
+};

package/src/cubing/puzzles/implementations/square1/index.ts

@@ -6,8 +6,7 @@ export const square1: PuzzleLoader = {
   inventedBy: ["Karel Hršel", "Vojtech Kopský"],
   inventionYear: 1990, // Czech patent application year: http://spisy.upv.cz/Patents/FullDocuments/277/277266.pdf
   def: async () => {
-    return (await import("./sq1-hyperorbit.kpuzzle.json_"))
-      .sq1HyperOrbitKPuzzle;
+    return (await import("./sq1-hyperorbit.kpuzzle.json")).sq1HyperOrbitKPuzzle;
   },
   svg: async () => {
     return (await import("./sq1-hyperorbit.kpuzzle.svg")).default;

package/src/cubing/puzzles/index.ts

@@ -1,6 +1,9 @@
-export { cube3x3x3KPuzzle as experimentalCube3x3x3KPuzzle } from "./implementations/3x3x3/3x3x3.kpuzzle.json_";
+export { customPGPuzzleLoader as experimentalCustomPGPuzzleLoader } from "./customPGPuzzleLoader";
+export { experimentalCube3x3x3KPuzzle as experimentalCube3x3x3KPuzzle } from "../kpuzzle";
 
-import type { PuzzleID } from "../twisty/dom/TwistyPlayerConfig";
+export { cubeAppearance as experimentalCubeAppearance } from "./stickerings/cube-stickerings";
+
+import type { PuzzleID } from "../twisty/old/dom/TwistyPlayerConfig";
 import { cubePGPuzzleLoader, genericPGPuzzleLoader } from "./async/async-pg3d";
 import { cube2x2x2 } from "./implementations/2x2x2";
 import { cube3x3x3 } from "./implementations/3x3x3";
@@ -59,24 +62,31 @@ export type {
   PuzzleAppearance as ExperimentalPuzzleAppearance,
 } from "./stickerings/appearance";
 
-const wcaEvents: Record<string, PuzzleID> = {
-  "333": "3x3x3",
-  "222": "2x2x2",
-  "444": "4x4x4",
-  "555": "5x5x5",
-  "666": "6x6x6",
-  "777": "7x7x7",
-  "333bf": "3x3x3",
-  "333fm": "3x3x3",
-  "333oh": "3x3x3",
-  "clock": "clock",
-  "minx": "megaminx",
-  "pyram": "pyraminx",
-  "skewb": "skewb",
-  "sq1": "square1",
-  "444bf": "4x4x4",
-  "555bf": "5x5x5",
+interface WCAEventInfo {
+  puzzleID: PuzzleID;
+  eventName: string;
+}
+
+const wcaEvents: Record<string, WCAEventInfo> = {
+  "333": { puzzleID: "3x3x3", eventName: "3x3x3 Cube" },
+  "222": { puzzleID: "2x2x2", eventName: "2x2x2 Cube" },
+  "444": { puzzleID: "4x4x4", eventName: "4x4x4 Cube" },
+  "555": { puzzleID: "5x5x5", eventName: "5x5x5 Cube" },
+  "666": { puzzleID: "6x6x6", eventName: "6x6x6 Cube" },
+  "777": { puzzleID: "7x7x7", eventName: "7x7x7 Cube" },
+  "333bf": { puzzleID: "3x3x3", eventName: "3x3x3 Blindfolded" },
+  "333fm": { puzzleID: "3x3x3", eventName: "3x3x3 Fewest Moves" },
+  "333oh": { puzzleID: "3x3x3", eventName: "3x3x3 One-Handed" },
+  "clock": { puzzleID: "clock", eventName: "Clock" },
+  "minx": { puzzleID: "megaminx", eventName: "Megaminx" },
+  "pyram": { puzzleID: "pyraminx", eventName: "Pyraminx" },
+  "skewb": { puzzleID: "skewb", eventName: "Skewb" },
+  "sq1": { puzzleID: "square1", eventName: "Square-1" },
+  "444bf": { puzzleID: "4x4x4", eventName: "4x4x4 Blindfolded" },
+  "555bf": { puzzleID: "5x5x5", eventName: "5x5x5 Blindfolded" },
+  "333mb": { puzzleID: "3x3x3", eventName: " 3x3x3 Multi-Blind" },
 };
+
 export function puzzleIDForWCAEvent(event: string): PuzzleID | null {
-  return wcaEvents[event] ?? null;
+  return wcaEvents[event]?.puzzleID ?? null;
 }

package/src/cubing/puzzles/stickerings/appearance.ts

@@ -57,16 +57,17 @@ export function getFaceletAppearance(
   return faceletAppearance.appearance;
 }
 
+// TODO: Revert this to a normal enum, or write a standard to codify the names?
 export enum PieceStickering {
-  Regular,
-  Dim,
-  Ignored,
-  OrientationStickers,
-  Invisible,
-  Ignoriented,
-  IgnoreNonPrimary,
-  PermuteNonPrimary,
-  OrientationWithoutPermutation,
+  Regular = "Regular",
+  Dim = "Dim",
+  Ignored = "Ignored",
+  OrientationStickers = "OrientationStickers",
+  Invisible = "Invisible",
+  Ignoriented = "Ignoriented",
+  IgnoreNonPrimary = "IgnoreNonPrimary",
+  PermuteNonPrimary = "PermuteNonPrimary",
+  OrientationWithoutPermutation = "OrientationWithoutPermutation",
 }
 
 export class PieceAnnotation<T> {

package/src/cubing/puzzles/stickerings/cube-stickerings.ts

@@ -7,6 +7,7 @@ import {
   PieceSet,
   PieceStickering,
 } from "./appearance";
+import { useGlobalCustomStickerer } from "./global-custom-stickering-hack";
 
 // TODO: cache calculations?
 export async function cubeAppearance(
@@ -236,6 +237,11 @@ export async function cubeAppearance(
     case "centers-only":
       puzzleStickering.set(m.not(CENTERS()), PieceStickering.Ignored);
       break;
+    case "experimental-global-custom-1":
+    // fallthrough
+    case "experimental-global-custom-2":
+      useGlobalCustomStickerer(puzzleStickering, m);
+      break;
     default:
       console.warn(
         `Unsupported stickering for ${puzzleLoader.id}: ${stickering}. Setting all pieces to dim.`,
@@ -274,5 +280,7 @@ export async function cubeStickerings(): Promise<ExperimentalStickering[]> {
     "picture",
     "invisible",
     "centers-only",
+    "experimental-global-custom-1",
+    "experimental-global-custom-2",
   ];
 }

package/src/cubing/puzzles/stickerings/fto-stickerings.ts

@@ -39,6 +39,7 @@ export async function ftoStickering(
       m.or([
         m.and([m.move("F"), m.move("BL")]),
         m.and([m.move("F"), m.move("BR")]),
+        m.and([m.move("BL"), m.move("BR")]),
       ]),
     );
 
@@ -56,24 +57,31 @@ export async function ftoStickering(
         m.not(experimentalFTO_F2T()),
         PieceStickering.Ignored,
       );
+      puzzleStickering.set(experimentalFTO_FC(), PieceStickering.Dim);
       break;
     case "experimental-fto-sc":
       puzzleStickering.set(
         m.not(experimentalFTO_SC()),
         PieceStickering.Ignored,
       );
+      puzzleStickering.set(experimentalFTO_F2T(), PieceStickering.Dim);
       break;
     case "experimental-fto-l2c":
       puzzleStickering.set(
         m.not(experimentalFTO_L2C()),
         PieceStickering.Ignored,
       );
+      puzzleStickering.set(experimentalFTO_SC(), PieceStickering.Dim);
       break;
     case "experimental-fto-lbt":
       puzzleStickering.set(
         m.not(experimentalFTO_LBT()),
         PieceStickering.Ignored,
       );
+      puzzleStickering.set(experimentalFTO_L2C(), PieceStickering.Dim);
+      break;
+    case "experimental-fto-l3t":
+      puzzleStickering.set(experimentalFTO_LBT(), PieceStickering.Dim);
       break;
     default:
       console.warn(
@@ -92,5 +100,6 @@ export async function ftoStickerings(): Promise<ExperimentalStickering[]> {
     "experimental-fto-sc",
     "experimental-fto-l2c",
     "experimental-fto-lbt",
+    "experimental-fto-l3t",
   ];
 }