cubing 0.22.0 → 0.24.0-pre2

package/src/cubing/kpuzzle/parser/parser-peggy.peggy

@@ -1,72 +0,0 @@
-{
-  function fixPermutation(permutation) {
-    return permutation.map(x => x - 1);
-  }
-
-  function fixMoves(def) {
-    for (const moveName in def.moves) {
-      const move = def.moves[moveName] ;
-      for (const orbitName in def.orbits) {
-        const moveOrbit = move[orbitName] ;
-        const oldOrientation = moveOrbit.orientation ;
-        const perm = moveOrbit.permutation ;
-        const newOrientation = new Array(oldOrientation.length) ;
-        for (let i = 0; i < perm.length; i++) {
-          newOrientation[i] = oldOrientation[perm[i]] ;
-        }
-        moveOrbit.orientation = newOrientation ;
-      }
-    }
-    return def;
-  }
-}
-
-start = def:DEFINITION_FILE { return fixMoves(def); }
-
-IDENTIFIER = characters:([A-Za-z0-9<>]+) { return characters.join(""); }
-// IDENTIFIER = characters:(([1-9][0-9]*)(([1-9][0-9]*)*)?)*(([A-Za-z]+)|(\<[A-Za-z]+(_[A-Za-z]+)*\>)) { return characters.join(); }
-SET_IDENTIFIER = first:[A-Za-z] rest:[A-Za-z0-9]* { return [first].concat(rest).join(""); }
-NUMBER = characters:[0-9]+ { return parseInt(characters.join(""), 10); }
-SPACE = " "
-
-NAME = "Name" SPACE identifier:IDENTIFIER { return identifier; }
-
-ORBIT= "Set" SPACE set_identifier:SET_IDENTIFIER SPACE num_pieces:NUMBER SPACE num_orientations:NUMBER {
-        return [set_identifier, {numPieces: num_pieces, orientations: num_orientations}];
-       }
-
-ORBITS
-  = orbit:ORBIT NEWLINE orbits:ORBITS { orbits[orbit[0]] = orbit[1]; return orbits; }
-  // TODO: Can we make sure orbits are added in order? (Most JS engines preserve map order.)
-  / orbit:ORBIT { const orbits = {}; orbits[orbit[0]] = orbit[1]; return orbits;  }
-
-NEWLINE = "\n"
-NEWLINES = "\n"+
-OPTIONAL_NEWLINES = "\n"*
-
-NUMBERS = num:NUMBER SPACE nums:NUMBERS { return [num].concat(nums); }
-        / num:NUMBER { return [num]; }
-
-PERMUTATION = nums:NUMBERS { return fixPermutation(nums) }
-
-DEFINITION  = set_identifier:SET_IDENTIFIER NEWLINE permutation:PERMUTATION NEWLINE nums:NUMBERS {
-                return [set_identifier, {permutation: permutation, orientation: nums}];
-              }
-              / set_identifier:SET_IDENTIFIER NEWLINE permutation:PERMUTATION   {
-                return [set_identifier, {permutation: permutation, orientation: new Array(permutation.length).fill(0)}];
-              }
-
-DEFINITIONS
-  = definition:DEFINITION NEWLINE definitions:DEFINITIONS { definitions[definition[0]] = definition[1]; return definitions; }
-  / definition:DEFINITION { const definitions = {}; definitions[definition[0]] = definition[1]; return definitions; }
-
-START_PIECES = "Solved" NEWLINE definitions:DEFINITIONS NEWLINE "End" { return definitions; }
-
-MOVE = "Move" SPACE identifier:IDENTIFIER NEWLINE definitions:DEFINITIONS NEWLINE "End" { return [identifier, definitions]; }
-
-MOVES = move:MOVE NEWLINES moves:MOVES { moves[move[0]] = move[1]; return moves; }
-      / move:MOVE { const moves = {}; moves[move[0]] = move[1]; return moves; }
-
-DEFINITION_FILE = name:NAME NEWLINES orbits:ORBITS NEWLINES start_pieces:START_PIECES NEWLINES moves:MOVES OPTIONAL_NEWLINES {
-                    return {name: name, orbits: orbits, moves: moves, startPieces: start_pieces};
-                  }

package/src/cubing/kpuzzle/parser/parser-shim.ts

@@ -1,11 +0,0 @@
-// Note: this file exists so that `parse` doesn't show up for autocompletion (by
-// avoiding a `parser-pegjs.d.ts` file that exports `parse`.)
-
-import type { KPuzzleDefinition } from "../definition_types";
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
-import { parse } from "./parser-peggy";
-
-const pegParseKPuzzleDefinition: (s: string) => KPuzzleDefinition = parse;
-
-export { pegParseKPuzzleDefinition };

package/src/cubing/kpuzzle/prunetable.spec.ts

@@ -1,19 +0,0 @@
-import { getPuzzleGeometryByName } from "../puzzle-geometry";
-import { Canonicalizer } from "./canonicalize";
-import { PruningTable } from "./pruningtable";
-import { Alg } from "../alg";
-describe("PruneTable", () => {
-  it("solve 2x2x2", () => {
-    const pg = getPuzzleGeometryByName("2x2x2", {});
-    const def = pg.writekpuzzle(false);
-    const canon = new Canonicalizer(def);
-    const a1 = "L' D L2 D' L2 F R' F R' L' F D L2 F2 R' F U B'";
-    const ss1 = canon.sequenceToSearchSequence(
-      Alg.fromString(a1),
-      def.startPieces,
-    );
-    const pt = new PruningTable(canon);
-    const sol = pt.solve(ss1.trans);
-    expect(sol).toBe("F L D2 F' D' F2 U F2 L' D2");
-  });
-});

package/src/cubing/kpuzzle/pruningtable.ts

@@ -1,99 +0,0 @@
-import { Canonicalizer, CanonicalSequenceIterator } from "./canonicalize";
-import type { KPuzzleDefinition, Transformation } from ".";
-import { areStatesEquivalent } from "./transformations";
-const mask = 0x7fffffff;
-function hash(def: KPuzzleDefinition, s: Transformation): number {
-  let r = 0;
-  for (const orbitName in def.orbits) {
-    const oDef = def.orbits[orbitName];
-    const o = s[orbitName];
-    for (let idx = 0; idx < oDef.numPieces; idx++) {
-      r =
-        (37 * r + oDef.orientations * o.permutation[idx] + o.orientation[idx]) &
-        mask;
-    }
-  }
-  return r;
-}
-export class PruningTable {
-  private tab: Uint8Array;
-  private population: number = 0;
-  private lookups: number = 0;
-  private def: KPuzzleDefinition;
-  private filled: number = -1;
-  constructor(
-    public canon: Canonicalizer,
-    public memsize: number = 16 * 1024 * 1024,
-  ) {
-    this.def = canon.def;
-    this.tab = new Uint8Array(memsize);
-    for (let i = 0; i < memsize; i++) {
-      this.tab[i] = 255;
-    }
-    this.filllevel();
-  }
-
-  public solve(s: Transformation): string {
-    for (let d = 0; ; d++) {
-      if (
-        this.lookups > this.population &&
-        this.population * 3 < this.memsize
-      ) {
-        this.filllevel();
-      }
-      const gen = new CanonicalSequenceIterator(this.canon, s).genSequenceTree(
-        [],
-      );
-      let rval = 0;
-      // eslint-disable-next-line no-constant-condition
-      while (true) {
-        const t = gen.next(rval);
-        if (t.value === null) {
-          break;
-        }
-        const dep = this.lookup(t.value.trans);
-        if (
-          dep === 0 &&
-          areStatesEquivalent(this.def, t.value.trans, this.def.startPieces)
-        ) {
-          return t.value.getSequenceAsString();
-        }
-        if (t.value.moveseq.length + dep > d) {
-          rval = 1;
-        } else {
-          rval = 0;
-        }
-      }
-    }
-  }
-
-  private filllevel(): void {
-    this.filled++;
-    const gen = new CanonicalSequenceIterator(
-      this.canon,
-      this.def.startPieces,
-    ).genSequence(this.filled, []);
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      const t = gen.next();
-      if (t.value === null) {
-        break;
-      }
-      const off = hash(this.def, t.value.trans) % this.memsize;
-      if (this.tab[off] === 255) {
-        this.tab[off] = this.filled;
-        this.population++;
-      }
-    }
-  }
-
-  private lookup(s: Transformation): number {
-    this.lookups++;
-    const v = this.tab[hash(this.def, s) % this.memsize];
-    if (v === 255) {
-      return this.filled + 1;
-    } else {
-      return v;
-    }
-  }
-}

package/src/cubing/kpuzzle/puzzle-orientation.ts

@@ -1,34 +0,0 @@
-import { experimentalNormalizePuzzleOrientation as normalize3x3x3Orientation } from "../protocol";
-import type { Transformation } from "./definition_types";
-import { cube3x3x3KPuzzle as def } from "./3x3x3/3x3x3.kpuzzle.json";
-import {
-  areOrbitTransformationsEquivalent,
-  areTransformationsEquivalent,
-} from "./transformations";
-
-// The `options` argument is required for now, because we haven't yet come up
-// with a general way to specify different kinds of solved for the same puzle.
-export function experimentalIs3x3x3Solved(
-  transformation: Transformation,
-  options: { ignoreCenterOrientation: boolean },
-): boolean {
-  const normalized = normalize3x3x3Orientation(transformation);
-  if (options.ignoreCenterOrientation) {
-    return (
-      areOrbitTransformationsEquivalent(
-        def,
-        "EDGES",
-        normalized,
-        def.startPieces,
-      ) &&
-      areOrbitTransformationsEquivalent(
-        def,
-        "CORNERS",
-        normalized,
-        def.startPieces,
-      )
-    );
-  } else {
-    return areTransformationsEquivalent(def, normalized, def.startPieces);
-  }
-}

package/src/cubing/kpuzzle/svg.ts

@@ -1,290 +0,0 @@
-import type {
-  FaceletMeshAppearance,
-  PuzzleAppearance,
-} from "../puzzles/stickerings/appearance"; // TODO
-import type { KPuzzleDefinition, Transformation } from "./definition_types";
-import type { KPuzzle } from "./kpuzzle";
-
-const xmlns = "http://www.w3.org/2000/svg";
-
-// Unique ID mechanism to keep SVG gradient element IDs unique. TODO: Is there
-// something more performant, and that can't be broken by other elements of the
-// page? (And also doesn't break if this library is run in parallel.)
-let svgCounter = 0;
-function nextSVGID(): string {
-  svgCounter += 1;
-  return "svg" + svgCounter.toString();
-}
-
-// TODO: This is hardcoded to 3x3x3 SVGs
-const colorMaps: Partial<
-  Record<FaceletMeshAppearance, Record<string, string>>
-> = {
-  dim: {
-    "white": "#dddddd",
-    "orange": "#884400",
-    "limegreen": "#008800",
-    "red": "#660000",
-    "rgb(34, 102, 255)": "#000088", // TODO
-    "yellow": "#888800",
-  },
-  oriented: {
-    "white": "#ff88ff",
-    "orange": "#ff88ff",
-    "limegreen": "#ff88ff",
-    "red": "#ff88ff",
-    "rgb(34, 102, 255)": "#ff88ff", // TODO
-    "yellow": "#ff88ff",
-  },
-  ignored: {
-    "white": "#444444",
-    "orange": "#444444",
-    "limegreen": "#444444",
-    "red": "#444444",
-    "rgb(34, 102, 255)": "#444444", // TODO
-    "yellow": "#444444",
-  },
-  invisible: {
-    "white": "#00000000",
-    "orange": "#00000000",
-    "limegreen": "#00000000",
-    "red": "#00000000",
-    "rgb(34, 102, 255)": "#00000000", // TODO
-    "yellow": "#00000000",
-  },
-};
-
-export class KPuzzleSVGWrapper {
-  public element: HTMLElement;
-  public gradientDefs: SVGDefsElement;
-  private originalColors: { [type: string]: string } = {};
-  private gradients: { [type: string]: SVGGradientElement } = {};
-  private svgID: string;
-  constructor(
-    public kPuzzleDefinition: KPuzzleDefinition,
-    svgSource: string,
-    experimentalAppearance?: PuzzleAppearance,
-  ) {
-    if (!svgSource) {
-      throw new Error(
-        `No SVG definition for puzzle type: ${kPuzzleDefinition.name}`,
-      );
-    }
-
-    this.svgID = nextSVGID();
-
-    this.element = document.createElement("div");
-    this.element.classList.add("svg-wrapper");
-    // TODO: Sanitization.
-    this.element.innerHTML = svgSource;
-
-    const svgElem = this.element.querySelector("svg");
-    if (!svgElem) {
-      throw new Error("Could not get SVG element");
-    }
-    if (xmlns !== svgElem.namespaceURI) {
-      throw new Error("Unexpected XML namespace");
-    }
-    svgElem.style.maxWidth = "100%";
-    svgElem.style.maxHeight = "100%";
-    this.gradientDefs = document.createElementNS(xmlns, "defs");
-    svgElem.insertBefore(this.gradientDefs, svgElem.firstChild);
-
-    for (const orbitName in kPuzzleDefinition.orbits) {
-      const orbitDefinition = kPuzzleDefinition.orbits[orbitName];
-
-      for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {
-        for (
-          let orientation = 0;
-          orientation < orbitDefinition.orientations;
-          orientation++
-        ) {
-          const id = this.elementID(orbitName, idx, orientation);
-          const elem = this.elementByID(id);
-          let originalColor: string = elem.style.fill;
-          /// TODO: Allow setting appearance dynamically.
-          if (experimentalAppearance) {
-            (() => {
-              // TODO: dedup with Cube3D,,factor out fallback calculations
-              const a = experimentalAppearance.orbits;
-              if (!a) {
-                return;
-              }
-              const orbitAppearance = a[orbitName];
-              if (!orbitAppearance) {
-                return;
-              }
-              const pieceAppearance = orbitAppearance.pieces[idx];
-              if (!pieceAppearance) {
-                return;
-              }
-              const faceletAppearance = pieceAppearance.facelets[orientation];
-              if (!faceletAppearance) {
-                return;
-              }
-              const appearance =
-                typeof faceletAppearance === "string"
-                  ? faceletAppearance
-                  : faceletAppearance?.appearance;
-              const colorMap = colorMaps[appearance];
-              if (colorMap) {
-                originalColor = colorMap[originalColor];
-              }
-            })();
-          } else {
-            originalColor = elem.style.fill;
-          }
-          this.originalColors[id] = originalColor;
-          this.gradients[id] = this.newGradient(id, originalColor);
-          this.gradientDefs.appendChild(this.gradients[id]);
-          elem.setAttribute("style", `fill: url(#grad-${this.svgID}-${id})`);
-        }
-      }
-    }
-  }
-
-  public drawKPuzzle(
-    kpuzzle: KPuzzle,
-    nextState?: Transformation,
-    fraction?: number,
-  ): void {
-    this.draw(kpuzzle.definition, kpuzzle.state, nextState, fraction);
-  }
-
-  // TODO: save definition in the constructor?
-  public draw(
-    definition: KPuzzleDefinition,
-    state: Transformation,
-    nextState?: Transformation,
-    fraction?: number,
-  ): void {
-    for (const orbitName in definition.orbits) {
-      const orbitDefinition = definition.orbits[orbitName];
-
-      const curOrbitState = state[orbitName];
-      const nextOrbitState = nextState ? nextState[orbitName] : null;
-      for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {
-        for (
-          let orientation = 0;
-          orientation < orbitDefinition.orientations;
-          orientation++
-        ) {
-          const id = this.elementID(orbitName, idx, orientation);
-          const fromCur = this.elementID(
-            orbitName,
-            curOrbitState.permutation[idx],
-            (orbitDefinition.orientations -
-              curOrbitState.orientation[idx] +
-              orientation) %
-              orbitDefinition.orientations,
-          );
-          let singleColor = false;
-          if (nextOrbitState) {
-            const fromNext = this.elementID(
-              orbitName,
-              nextOrbitState.permutation[idx],
-              (orbitDefinition.orientations -
-                nextOrbitState.orientation[idx] +
-                orientation) %
-                orbitDefinition.orientations,
-            );
-            if (fromCur === fromNext) {
-              singleColor = true; // TODO: Avoid redundant work during move.
-            }
-            fraction = fraction || 0; // TODO Use the type system to tie this to nextState?
-            const easedBackwardsPercent =
-              100 * (1 - fraction * fraction * (2 - fraction * fraction)); // TODO: Move easing up the stack.
-            this.gradients[id].children[0].setAttribute(
-              "stop-color",
-              this.originalColors[fromCur],
-            );
-            this.gradients[id].children[1].setAttribute(
-              "stop-color",
-              this.originalColors[fromCur],
-            );
-            this.gradients[id].children[1].setAttribute(
-              "offset",
-              `${Math.max(easedBackwardsPercent - 5, 0)}%`,
-            );
-            this.gradients[id].children[2].setAttribute(
-              "offset",
-              `${Math.max(easedBackwardsPercent - 5, 0)}%`,
-            );
-            this.gradients[id].children[3].setAttribute(
-              "offset",
-              `${easedBackwardsPercent}%`,
-            );
-            this.gradients[id].children[4].setAttribute(
-              "offset",
-              `${easedBackwardsPercent}%`,
-            );
-            this.gradients[id].children[4].setAttribute(
-              "stop-color",
-              this.originalColors[fromNext],
-            );
-            this.gradients[id].children[5].setAttribute(
-              "stop-color",
-              this.originalColors[fromNext],
-            );
-          } else {
-            singleColor = true; // TODO: Avoid redundant work during move.
-          }
-          if (singleColor) {
-            this.gradients[id].children[0].setAttribute(
-              "stop-color",
-              this.originalColors[fromCur],
-            );
-            this.gradients[id].children[1].setAttribute(
-              "stop-color",
-              this.originalColors[fromCur],
-            );
-            this.gradients[id].children[1].setAttribute("offset", `100%`);
-            this.gradients[id].children[2].setAttribute("offset", `100%`);
-            this.gradients[id].children[3].setAttribute("offset", `100%`);
-            this.gradients[id].children[4].setAttribute("offset", `100%`);
-          }
-          // this.gradients[id]
-          // this.elementByID(id).style.fill = this.originalColors[from];
-        }
-      }
-    }
-  }
-
-  private newGradient(id: string, originalColor: string): SVGGradientElement {
-    const grad = document.createElementNS(
-      xmlns,
-      "radialGradient",
-    ) as SVGGradientElement;
-    grad.setAttribute("id", `grad-${this.svgID}-${id}`);
-    grad.setAttribute("r", `70.7107%`); // TODO: Adapt to puzzle.
-    const stopDefs = [
-      { offset: 0, color: originalColor },
-      { offset: 0, color: originalColor },
-      { offset: 0, color: "black" },
-      { offset: 0, color: "black" },
-      { offset: 0, color: originalColor },
-      { offset: 100, color: originalColor },
-    ];
-    for (const stopDef of stopDefs) {
-      const stop = document.createElementNS(xmlns, "stop");
-      stop.setAttribute("offset", `${stopDef.offset}%`);
-      stop.setAttribute("stop-color", stopDef.color);
-      stop.setAttribute("stop-opacity", "1");
-      grad.appendChild(stop);
-    }
-    return grad;
-  }
-
-  private elementID(
-    orbitName: string,
-    idx: number,
-    orientation: number,
-  ): string {
-    return orbitName + "-l" + idx + "-o" + orientation;
-  }
-
-  private elementByID(id: string): HTMLElement {
-    // TODO: Use classes and scope selector to SVG element.
-    return this.element.querySelector("#" + id) as HTMLElement;
-  }
-}

package/src/cubing/kpuzzle/transformations.spec.ts

@@ -1,75 +0,0 @@
-import type { KPuzzleDefinition } from ".";
-import { Alg } from "../alg";
-import { puzzles } from "../puzzles";
-import type { Transformation } from "./definition_types";
-import { KPuzzle } from "./kpuzzle";
-import {
-  areOrbitTransformationsEquivalent,
-  areTransformationsEquivalent,
-} from "./transformations";
-
-function isEquivalentTranformationIgnoringOrientationForCENTERS(
-  def: KPuzzleDefinition,
-  t1: Transformation,
-  t2: Transformation,
-): boolean {
-  for (const orbitName in def.orbits) {
-    if (
-      !areOrbitTransformationsEquivalent(def, orbitName, t1, t2, {
-        ignoreOrientation: orbitName === "CENTERS",
-      })
-    ) {
-      return false;
-    }
-  }
-  return true;
-}
-
-describe("tranformations", () => {
-  it("correctly compares orbits", async () => {
-    const def = await puzzles["3x3x3"].def();
-    const kpuzzle1 = new KPuzzle(def);
-    kpuzzle1.applyAlg(Alg.fromString(""));
-    const kpuzzle2 = new KPuzzle(def);
-    kpuzzle2.applyAlg(Alg.fromString("(R' U' R U')5"));
-
-    expect(
-      areOrbitTransformationsEquivalent(
-        def,
-        "CENTERS",
-        kpuzzle1.state,
-        kpuzzle2.state,
-      ),
-    ).toBe(false);
-
-    expect(
-      areOrbitTransformationsEquivalent(
-        def,
-        "CENTERS",
-        kpuzzle1.state,
-        kpuzzle2.state,
-        { ignoreOrientation: true },
-      ),
-    ).toBe(true);
-  });
-
-  it("correctly compares transformations", async () => {
-    const def = await puzzles["3x3x3"].def();
-    const kpuzzle1 = new KPuzzle(def);
-    kpuzzle1.applyAlg(Alg.fromString(""));
-    const kpuzzle2 = new KPuzzle(def);
-    kpuzzle2.applyAlg(Alg.fromString("(R' U' R U')5"));
-
-    expect(
-      areTransformationsEquivalent(def, kpuzzle1.state, kpuzzle2.state),
-    ).toBe(false);
-
-    expect(
-      isEquivalentTranformationIgnoringOrientationForCENTERS(
-        def,
-        kpuzzle1.state,
-        kpuzzle2.state,
-      ),
-    ).toBe(true);
-  });
-});