cubing 0.20.2 → 0.21.0-pre12

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

@@ -1,50 +1,179 @@
-export function parseoptions(
-  argv: string[],
-  optionlist: Array<string | boolean | number | Array<string>>,
-): number {
+import { parsePuzzleDescription, PuzzleDescription } from "./PuzzleGeometry";
+
+export function parseOptions(argv: string[]): {
+  puzzleDescription: PuzzleDescription | null;
+  options: PuzzleGeometryOptions;
+} {
   let argp = 0;
+  const options: PuzzleGeometryOptions = {};
   while (argp < argv.length && argv[argp][0] === "-") {
     const option = argv[argp++];
     if (option === "--rotations") {
-      optionlist.push("rotations", true);
+      options.addRotations = true;
     } else if (option === "--allmoves") {
-      optionlist.push("allmoves", true);
+      options.allMoves = true;
     } else if (option === "--outerblockmoves") {
-      optionlist.push("outerblockmoves", true);
+      options.outerBlockMoves = true;
     } else if (option === "--vertexmoves") {
-      optionlist.push("vertexmoves", true);
+      options.vertexMoves = true;
     } else if (option === "--nocorners") {
-      optionlist.push("cornersets", false);
+      options.includeCornerOrbits = false;
     } else if (option === "--noedges") {
-      optionlist.push("edgesets", false);
+      options.includeEdgeOrbits = false;
     } else if (option === "--noorientation") {
-      optionlist.push("killorientation", true);
+      options.fixedOrientation = true;
     } else if (option === "--nocenters") {
-      optionlist.push("centersets", false);
+      options.includeCenterOrbits = false;
     } else if (option === "--omit") {
-      optionlist.push("omit", argv[argp].split(","));
+      options.excludeOrbits = argv[argp].split(",");
       argp++;
     } else if (option === "--moves") {
-      optionlist.push("movelist", argv[argp].split(","));
+      options.moveList = argv[argp].split(",");
       argp++;
     } else if (option === "--optimize") {
-      optionlist.push("optimize", true);
+      options.optimizeOrbits = true;
     } else if (option === "--scramble") {
-      optionlist.push("scramble", 100);
+      options.scrambleAmount = 100;
     } else if (option === "--fixcorner") {
-      optionlist.push("fix", "v");
+      options.fixedPieceType = "v";
     } else if (option === "--fixedge") {
-      optionlist.push("fix", "e");
+      options.fixedPieceType = "e";
     } else if (option === "--fixcenter") {
-      optionlist.push("fix", "f");
+      options.fixedPieceType = "f";
     } else if (option === "--orientcenters") {
-      optionlist.push("orientcenters", true);
+      options.orientCenters = true;
     } else if (option === "--puzzleorientation") {
-      optionlist.push("puzzleorientation", argv[argp]);
+      options.puzzleOrientation = JSON.parse(argv[argp]); // TODO: Validate input.
       argp++;
     } else {
       throw new Error("Bad option: " + option);
     }
   }
-  return argp;
+  const puzzleDescription = parsePuzzleDescription(argv.slice(argp).join(" "));
+  return { puzzleDescription, options };
+}
+
+type FaceName = string;
+type OrientationDirection = [number, number, number];
+export type FaceBasedOrientationDescription = [
+  [FaceName, OrientationDirection],
+  [FaceName, OrientationDirection],
+];
+export type BaseFaceCount = 4 | 6 | 8 | 12 | 20;
+export type FaceBasedOrientationDescriptionLookup = Record<
+  BaseFaceCount,
+  FaceBasedOrientationDescription
+>;
+
+function asstructured(v: any): any {
+  if (typeof v === "string") {
+    return JSON.parse(v);
+  }
+  return v;
+}
+function asboolean(v: any): boolean {
+  if (typeof v === "string") {
+    if (v === "false") {
+      return false;
+    }
+    return true;
+  } else {
+    return v ? true : false;
+  }
+}
+
+export class PuzzleGeometryFullOptions {
+  verbosity: number = 0; // verbosity (console.log)
+
+  allMoves: boolean = false; // generate all slice moves in ksolve
+  outerBlockMoves: boolean; // generate outer block moves
+  vertexMoves: boolean = false; // generate vertex moves
+  addRotations: boolean = false; // add symmetry information to ksolve output
+  moveList: string[] | null = null; // move list to generate
+
+  fixedOrientation: boolean = false; // eliminate any orientations
+  fixedPieceType: null | "e" | "v" | "f" = null; // fix a piece?
+  orientCenters: boolean = false; // orient centers?
+
+  // TODO: Group these into a single object?
+  includeCornerOrbits: boolean = true; // include corner orbits
+  includeCenterOrbits: boolean = true; // include center orbits
+  includeEdgeOrbits: boolean = true; // include edge orbits
+  // Overrides the previous options.
+  excludeOrbits: string[] = []; // exclude these orbits
+  optimizeOrbits: boolean = false; // optimize PermOri
+
+  grayCorners: boolean = false; // make corner sets gray
+  grayCenters: boolean = false; // make center sets gray
+  grayEdges: boolean = false; // make edge sets gray
+
+  puzzleOrientation: FaceBasedOrientationDescription | null = null; // single puzzle orientation from options
+  puzzleOrientations: FaceBasedOrientationDescriptionLookup | null = null; // puzzle orientation override object from options // TODO: is this needed?
+
+  scrambleAmount: number = 0; // scramble?
+
+  constructor(options: PuzzleGeometryOptions = {}) {
+    Object.assign(this, options);
+  }
+}
+
+export type PuzzleGeometryOptions = Partial<PuzzleGeometryFullOptions>;
+
+export function parsePGOptionList(optionlist?: any[]): PuzzleGeometryOptions {
+  const options: PuzzleGeometryOptions = {};
+  if (optionlist !== undefined) {
+    if (optionlist.length % 2 !== 0) {
+      throw new Error("Odd length in option list?");
+    }
+    for (let i = 0; i < optionlist.length; i += 2) {
+      if (optionlist[i] === "verbose") {
+        options.verbosity = (options.verbosity ?? 0) + 1;
+      } else if (optionlist[i] === "quiet") {
+        options.verbosity = 0;
+      } else if (optionlist[i] === "allmoves") {
+        options.allMoves = asboolean(optionlist[i + 1]);
+      } else if (optionlist[i] === "outerblockmoves") {
+        options.outerBlockMoves = asboolean(optionlist[i + 1]);
+      } else if (optionlist[i] === "vertexmoves") {
+        options.vertexMoves = asboolean(optionlist[i + 1]);
+      } else if (optionlist[i] === "rotations") {
+        options.addRotations = asboolean(optionlist[i + 1]);
+      } else if (optionlist[i] === "cornersets") {
+        options.includeCornerOrbits = asboolean(optionlist[i + 1]);
+      } else if (optionlist[i] === "centersets") {
+        options.includeCenterOrbits = asboolean(optionlist[i + 1]);
+      } else if (optionlist[i] === "edgesets") {
+        options.includeEdgeOrbits = asboolean(optionlist[i + 1]);
+      } else if (optionlist[i] === "omit") {
+        options.excludeOrbits = optionlist[i + 1];
+      } else if (optionlist[i] === "graycorners") {
+        options.grayCorners = asboolean(optionlist[i + 1]);
+      } else if (optionlist[i] === "graycenters") {
+        options.grayCenters = asboolean(optionlist[i + 1]);
+      } else if (optionlist[i] === "grayedges") {
+        options.grayEdges = asboolean(optionlist[i + 1]);
+      } else if (optionlist[i] === "movelist") {
+        options.moveList = asstructured(optionlist[i + 1]);
+      } else if (optionlist[i] === "killorientation") {
+        options.fixedOrientation = asboolean(optionlist[i + 1]);
+      } else if (optionlist[i] === "optimize") {
+        options.optimizeOrbits = asboolean(optionlist[i + 1]);
+      } else if (optionlist[i] === "scramble") {
+        options.scrambleAmount = optionlist[i + 1];
+      } else if (optionlist[i] === "fix") {
+        options.fixedPieceType = optionlist[i + 1];
+      } else if (optionlist[i] === "orientcenters") {
+        options.orientCenters = asboolean(optionlist[i + 1]);
+      } else if (optionlist[i] === "puzzleorientation") {
+        options.puzzleOrientation = asstructured(optionlist[i + 1]);
+      } else if (optionlist[i] === "puzzleorientations") {
+        options.puzzleOrientations = asstructured(optionlist[i + 1]);
+      } else {
+        throw new Error(
+          "Bad option while processing option list " + optionlist[i],
+        );
+      }
+    }
+  }
+  return options;
 }

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

@@ -1,10 +1,6 @@
 import { getPuzzleGeometryByDesc } from ".";
 import { PGPuzzles } from "./PGPuzzles";
-import {
-  KPuzzleDefinition,
-  transformationOrder,
-  Transformation,
-} from "../kpuzzle";
+import { transformationOrder, Transformation } from "../kpuzzle";
 import { TreeAlgIndexer, KSolvePuzzle } from "../twisty";
 import { Alg, Move } from "../alg";
 /**
@@ -32,9 +28,9 @@ const expectedData: { [nam: string]: string } = {
   "skewb": "skewb, 6, 5, 14, 3, 8, 9",
   "master skewb": "master skewb, 6, 13, 50, 6, 12, 2520",
   "professor skewb": "professor skewb, 6, 25, 110, 11, 16, 360",
-  "compy cube": "compy cube, 6, 9, 27, 4, 12, 42",
+  "compy cube": "compy cube, 6, 9, 26, 4, 12, 42",
   "helicopter": "helicopter, 6, 8, 32, 2, 18, 18",
-  "curvy copter": "curvy copter, 6, 13, 51, 4, 18, 18",
+  "curvy copter": "curvy copter, 6, 13, 50, 4, 18, 18",
   "dino": "dino, 6, 4, 12, 1, 12, 7",
   "little chop": "little chop, 6, 4, 24, 1, 12, 5",
   "pyramorphix": "pyramorphix, 4, 4, 8, 2, 6, 3",
@@ -46,7 +42,7 @@ const expectedData: { [nam: string]: string } = {
   "professor pyraminx": "professor pyraminx, 4, 25, 54, 7, 20, 90",
   "professor tetraminx": "professor tetraminx, 4, 22, 50, 6, 16, 90",
   "Jing pyraminx": "Jing pyraminx, 4, 7, 14, 3, 8, 45",
-  "master pyramorphix": "master pyramorphix, 4, 10, 27, 8, 9, 6",
+  "master pyramorphix": "master pyramorphix, 4, 10, 26, 8, 9, 6",
   "megaminx": "megaminx, 12, 11, 62, 3, 18, 702",
   "gigaminx": "gigaminx, 12, 31, 242, 6, 30, 18181800",
   "teraminx": "teraminx, 12, 61, 542, 11, 42, 18181800",
@@ -57,7 +53,7 @@ const expectedData: { [nam: string]: string } = {
   "pentultimate": "pentultimate, 12, 6, 32, 2, 12, 132",
   "master pentultimate": "master pentultimate, 12, 16, 122, 4, 18, 1741740",
   "elite pentultimate": "elite pentultimate, 12, 31, 272, 6, 24, 6832980",
-  "starminx": "starminx, 12, 11, 63, 3, 30, 48",
+  "starminx": "starminx, 12, 11, 62, 3, 30, 48",
   "starminx 2": "starminx 2, 12, 11, 102, 3, 18, 158340",
   "pyraminx crystal": "pyraminx crystal, 12, 10, 50, 2, 18, 9828",
   "chopasaurus": "chopasaurus, 12, 11, 92, 3, 20, 115710",
@@ -73,7 +69,7 @@ const expectedData: { [nam: string]: string } = {
   "icosahedron 2": "icosahedron 2, 20, 9, 102, 3, 18, 12240",
   "icosahedron 3": "icosahedron 3, 20, 18, 360, 6, 48, 2162160",
   "icosahedron static faces":
-    "icosahedron static faces, 20, 7, 63, 3, 18, 6300",
+    "icosahedron static faces, 20, 7, 62, 3, 18, 6300",
   "icosahedron moving faces":
     "icosahedron moving faces, 20, 7, 62, 3, 18, 107100",
   "Eitan's star": "Eitan's star, 20, 13, 152, 4, 30, 384560",
@@ -88,9 +84,8 @@ const expectedData: { [nam: string]: string } = {
 describe("PuzzleGeometry-Puzzles", () => {
   it("testpuzzles", () => {
     for (const [name, desc] of Object.entries(PGPuzzles)) {
-      const options: string[] = [];
-      const pg = getPuzzleGeometryByDesc(desc, options);
-      const kpuzzledef = pg.writekpuzzle(false) as KPuzzleDefinition;
+      const pg = getPuzzleGeometryByDesc(desc, {});
+      const kpuzzledef = pg.writekpuzzle(false);
       const sep = ", ";
       const seq = Object.getOwnPropertyNames(kpuzzledef.moves).sort().join(" ");
       let algo = Alg.fromString(seq);
@@ -106,21 +101,22 @@ describe("PuzzleGeometry-Puzzles", () => {
       const tai = new TreeAlgIndexer(ksp, algo);
       const tr = tai.transformAtIndex(tai.numAnimatedLeaves());
       const o = transformationOrder(kpuzzledef, tr as Transformation);
-      let dat =
-        name +
-        sep +
-        pg.baseplanerot.length +
-        sep +
-        pg.stickersperface +
-        sep +
-        pg.cubies.length +
-        sep +
-        Object.getOwnPropertyNames(kpuzzledef.orbits).length +
-        sep +
-        Object.getOwnPropertyNames(kpuzzledef.moves).length +
-        sep +
-        o;
-      let exp = expectedData[name];
+      const dat = [
+        name,
+        sep,
+        pg.baseplanerot.length,
+        sep,
+        pg.stickersperface,
+        sep,
+        pg.cubies.length,
+        sep,
+        Object.getOwnPropertyNames(kpuzzledef.orbits).length,
+        sep,
+        Object.getOwnPropertyNames(kpuzzledef.moves).length,
+        sep,
+        o,
+      ].join("");
+      const exp = expectedData[name];
       expect(dat).toBe(exp);
     }
   });