cube-state-engine 1.1.0 → 1.3.0

package/README.md

@@ -18,12 +18,14 @@ A core state manager designed to integrate with custom 3D cube models. This engi
 | `isSolved()`                                     | Checks if the cube is solved.                                                                            | `boolean`           |
 | `state()`                                        | Returns the current state of the cube as an object representing each face.                               | `object`            |
 | `getMoves(asString?: boolean)`                   | Returns the history of all movements; as string if `true` (default), or as array if `false`.             | `string / string[]` |
-| `applyMoves(sequence: string, options?: {record?: boolean})` | Applies a sequence of moves (supports U, D, L, R, F, x, y, z, M, Dw, Uw, Rw, Lw with ', 2). | `void`              |
+| `reset()`                                        | Resets the cube to the solved state and clears the move history.                                         | `void`              |
+| `applyMoves(sequence: string, options?: {record?: boolean})` | Applies a sequence of moves (supports U, D, L, R, F, B, x, y, z, M, Dw, Uw, Rw, Lw with ', 2). | `void`              |
 | `rotateU(clockwise?: boolean)`                   | Rotates the **Upper** layer clockwise or counterclockwise.                                               | `void`              |
 | `rotateD(clockwise?: boolean)`                   | Rotates the **Down** layer clockwise or counterclockwise.                                                | `void`              |
 | `rotateL(clockwise?: boolean)`                   | Rotates the **Left** layer clockwise or counterclockwise.                                                | `void`              |
 | `rotateR(clockwise?: boolean)`                   | Rotates the **Right** layer clockwise or counterclockwise.                                               | `void`              |
 | `rotateF(clockwise?: boolean)`                   | Rotates the **Front** layer clockwise or counterclockwise.                                               | `void`              |
+| `rotateB(clockwise?: boolean)`                   | Rotates the **Back** layer clockwise or counterclockwise.                                                | `void`              |
 | `rotateX(clockwise?: boolean)`                   | Rotates the cube along the **X-axis** clockwise or counterclockwise.                                     | `void`              |
 | `rotateY(clockwise?: boolean)`                   | Rotates the cube along the **Y-axis** clockwise or counterclockwise.                                     | `void`              |
 | `rotateZ(clockwise?: boolean)`                   | Rotates the cube along the **Z-axis** clockwise or counterclockwise.                                     | `void`              |
@@ -74,6 +76,11 @@ console.log(cube.state());
 console.log(cube.getMoves(true));  // "U Dw Dw' M2 ..."
 console.log(cube.getMoves(false)); // ["U", "Dw", "Dw'", "M", "M"]
 
+// Reset the cube to solved state and clear history
+cube.reset();
+console.log(cube.isSolved());      // true
+console.log(cube.getMoves(false)); // []
+
 // Rotate the cube along the Y-axis
 cube.rotateY(false);
 ```

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 class CubeEngine {
   MOVES = [];
 
-  constructor(initialScramble) {
+  constructor(initialScramble = "") {
     // If an initial scramble string is provided, apply it without recording moves
     if (typeof initialScramble === "string" && initialScramble.trim().length > 0) {
       this.#applyMovesFromString(initialScramble, false);
@@ -116,6 +116,33 @@ class CubeEngine {
     }
   }
 
+  /**
+   * Rotates the (BACK) layer clockwise or counterclockwise.
+   */
+  rotateB(clockwise = true) {
+    if (clockwise) {
+      this.#rotateB(true);
+      this.MOVES.push("B");
+    } else {
+      this.#rotateB(false);
+      this.MOVES.push("B'");
+    }
+  }
+
+  #rotateB(clockwise = true) {
+    // Implement B as y2 F y2
+    // Clockwise/counterclockwise direction is preserved through y2 conjugation
+    this.#rotateY(true);
+    this.#rotateY(true);
+    if (clockwise) {
+      this.#rotateF(true);
+    } else {
+      this.#rotateF(false);
+    }
+    this.#rotateY(false);
+    this.#rotateY(false);
+  }
+
   /**
    * Rotates the (RIGHT) layer clockwise or counterclockwise.
    */
@@ -513,6 +540,45 @@ class CubeEngine {
     return asString ? this.MOVES.join(" ") : this.MOVES;
   }
 
+  /**
+   * Resets the cube to the solved state and clears the move history.
+   */
+  reset() {
+    this.STATES = {
+      UPPER: [
+        [COLOR.W[0], COLOR.W[1], COLOR.W[2]],
+        [COLOR.W[3], COLOR.W[4], COLOR.W[5]],
+        [COLOR.W[6], COLOR.W[7], COLOR.W[8]],
+      ],
+      LEFT: [
+        [COLOR.O[0], COLOR.O[1], COLOR.O[2]],
+        [COLOR.O[3], COLOR.O[4], COLOR.O[5]],
+        [COLOR.O[6], COLOR.O[7], COLOR.O[8]],
+      ],
+      FRONT: [
+        [COLOR.G[0], COLOR.G[1], COLOR.G[2]],
+        [COLOR.G[3], COLOR.G[4], COLOR.G[5]],
+        [COLOR.G[6], COLOR.G[7], COLOR.G[8]],
+      ],
+      RIGHT: [
+        [COLOR.R[0], COLOR.R[1], COLOR.R[2]],
+        [COLOR.R[3], COLOR.R[4], COLOR.R[5]],
+        [COLOR.R[6], COLOR.R[7], COLOR.R[8]],
+      ],
+      BACK: [
+        [COLOR.B[0], COLOR.B[1], COLOR.B[2]],
+        [COLOR.B[3], COLOR.B[4], COLOR.B[5]],
+        [COLOR.B[6], COLOR.B[7], COLOR.B[8]],
+      ],
+      DOWN: [
+        [COLOR.Y[0], COLOR.Y[1], COLOR.Y[2]],
+        [COLOR.Y[3], COLOR.Y[4], COLOR.Y[5]],
+        [COLOR.Y[6], COLOR.Y[7], COLOR.Y[8]],
+      ],
+    };
+    this.MOVES = [];
+  }
+
   /**
    * Applies a sequence of moves provided as a string.
    * Supports: U, D, L, R, F, x, y, z; slice moves: M; and wide moves: Dw, Uw, Rw, Lw with optional ' for counterclockwise and 2 for double turns.
@@ -623,6 +689,12 @@ class CubeEngine {
             () => (record ? this.rotateF(false) : this.#rotateF(false))
           );
           break;
+        case 'B':
+          exec(
+            () => (record ? this.rotateB(true) : this.#rotateB(true)),
+            () => (record ? this.rotateB(false) : this.#rotateB(false))
+          );
+          break;
         case 'x':
           exec(
             () => (record ? this.rotateX(true) : this.#rotateX(true)),

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 class CubeEngine {
   MOVES = [];
 
-  constructor(initialScramble) {
+  constructor(initialScramble = "") {
     // If an initial scramble string is provided, apply it without recording moves
     if (typeof initialScramble === "string" && initialScramble.trim().length > 0) {
       this.#applyMovesFromString(initialScramble, false);
@@ -116,6 +116,33 @@ class CubeEngine {
     }
   }
 
+  /**
+   * Rotates the (BACK) layer clockwise or counterclockwise.
+   */
+  rotateB(clockwise = true) {
+    if (clockwise) {
+      this.#rotateB(true);
+      this.MOVES.push("B");
+    } else {
+      this.#rotateB(false);
+      this.MOVES.push("B'");
+    }
+  }
+
+  #rotateB(clockwise = true) {
+    // Implement B as y2 F y2
+    // Clockwise/counterclockwise direction is preserved through y2 conjugation
+    this.#rotateY(true);
+    this.#rotateY(true);
+    if (clockwise) {
+      this.#rotateF(true);
+    } else {
+      this.#rotateF(false);
+    }
+    this.#rotateY(false);
+    this.#rotateY(false);
+  }
+
   /**
    * Rotates the (RIGHT) layer clockwise or counterclockwise.
    */
@@ -513,6 +540,45 @@ class CubeEngine {
     return asString ? this.MOVES.join(" ") : this.MOVES;
   }
 
+  /**
+   * Resets the cube to the solved state and clears the move history.
+   */
+  reset() {
+    this.STATES = {
+      UPPER: [
+        [COLOR.W[0], COLOR.W[1], COLOR.W[2]],
+        [COLOR.W[3], COLOR.W[4], COLOR.W[5]],
+        [COLOR.W[6], COLOR.W[7], COLOR.W[8]],
+      ],
+      LEFT: [
+        [COLOR.O[0], COLOR.O[1], COLOR.O[2]],
+        [COLOR.O[3], COLOR.O[4], COLOR.O[5]],
+        [COLOR.O[6], COLOR.O[7], COLOR.O[8]],
+      ],
+      FRONT: [
+        [COLOR.G[0], COLOR.G[1], COLOR.G[2]],
+        [COLOR.G[3], COLOR.G[4], COLOR.G[5]],
+        [COLOR.G[6], COLOR.G[7], COLOR.G[8]],
+      ],
+      RIGHT: [
+        [COLOR.R[0], COLOR.R[1], COLOR.R[2]],
+        [COLOR.R[3], COLOR.R[4], COLOR.R[5]],
+        [COLOR.R[6], COLOR.R[7], COLOR.R[8]],
+      ],
+      BACK: [
+        [COLOR.B[0], COLOR.B[1], COLOR.B[2]],
+        [COLOR.B[3], COLOR.B[4], COLOR.B[5]],
+        [COLOR.B[6], COLOR.B[7], COLOR.B[8]],
+      ],
+      DOWN: [
+        [COLOR.Y[0], COLOR.Y[1], COLOR.Y[2]],
+        [COLOR.Y[3], COLOR.Y[4], COLOR.Y[5]],
+        [COLOR.Y[6], COLOR.Y[7], COLOR.Y[8]],
+      ],
+    };
+    this.MOVES = [];
+  }
+
   /**
    * Applies a sequence of moves provided as a string.
    * Supports: U, D, L, R, F, x, y, z; slice moves: M; and wide moves: Dw, Uw, Rw, Lw with optional ' for counterclockwise and 2 for double turns.
@@ -623,6 +689,12 @@ class CubeEngine {
             () => (record ? this.rotateF(false) : this.#rotateF(false))
           );
           break;
+        case 'B':
+          exec(
+            () => (record ? this.rotateB(true) : this.#rotateB(true)),
+            () => (record ? this.rotateB(false) : this.#rotateB(false))
+          );
+          break;
         case 'x':
           exec(
             () => (record ? this.rotateX(true) : this.#rotateX(true)),

package/dist/index.js

@@ -45,9 +45,9 @@ __export(src_exports, {
   CubeEngine: () => CubeEngine
 });
 module.exports = __toCommonJS(src_exports);
-var _CubeEngine_instances, rotateU_fn, rotateF_fn, rotateR_fn, rotateL_fn, rotateD_fn, rotateDw_fn, rotateUw_fn, rotateRw_fn, rotateLw_fn, rotateM_fn, rotateX_fn, rotateZ_fn, rotateY_fn, switchMatrix_fn, specialFlip_fn, applyMovesFromString_fn;
+var _CubeEngine_instances, rotateU_fn, rotateF_fn, rotateB_fn, rotateR_fn, rotateL_fn, rotateD_fn, rotateDw_fn, rotateUw_fn, rotateRw_fn, rotateLw_fn, rotateM_fn, rotateX_fn, rotateZ_fn, rotateY_fn, switchMatrix_fn, specialFlip_fn, applyMovesFromString_fn;
 var CubeEngine = class {
-  constructor(initialScramble) {
+  constructor(initialScramble = "") {
     __privateAdd(this, _CubeEngine_instances);
     __publicField(this, "MOVES", []);
     // States object for the rotation
@@ -118,6 +118,18 @@ var CubeEngine = class {
       this.MOVES.push("F'");
     }
   }
+  /**
+   * Rotates the (BACK) layer clockwise or counterclockwise.
+   */
+  rotateB(clockwise = true) {
+    if (clockwise) {
+      __privateMethod(this, _CubeEngine_instances, rotateB_fn).call(this, true);
+      this.MOVES.push("B");
+    } else {
+      __privateMethod(this, _CubeEngine_instances, rotateB_fn).call(this, false);
+      this.MOVES.push("B'");
+    }
+  }
   /**
    * Rotates the (RIGHT) layer clockwise or counterclockwise.
    */
@@ -281,6 +293,44 @@ var CubeEngine = class {
   getMoves(asString = true) {
     return asString ? this.MOVES.join(" ") : this.MOVES;
   }
+  /**
+   * Resets the cube to the solved state and clears the move history.
+   */
+  reset() {
+    this.STATES = {
+      UPPER: [
+        [COLOR.W[0], COLOR.W[1], COLOR.W[2]],
+        [COLOR.W[3], COLOR.W[4], COLOR.W[5]],
+        [COLOR.W[6], COLOR.W[7], COLOR.W[8]]
+      ],
+      LEFT: [
+        [COLOR.O[0], COLOR.O[1], COLOR.O[2]],
+        [COLOR.O[3], COLOR.O[4], COLOR.O[5]],
+        [COLOR.O[6], COLOR.O[7], COLOR.O[8]]
+      ],
+      FRONT: [
+        [COLOR.G[0], COLOR.G[1], COLOR.G[2]],
+        [COLOR.G[3], COLOR.G[4], COLOR.G[5]],
+        [COLOR.G[6], COLOR.G[7], COLOR.G[8]]
+      ],
+      RIGHT: [
+        [COLOR.R[0], COLOR.R[1], COLOR.R[2]],
+        [COLOR.R[3], COLOR.R[4], COLOR.R[5]],
+        [COLOR.R[6], COLOR.R[7], COLOR.R[8]]
+      ],
+      BACK: [
+        [COLOR.B[0], COLOR.B[1], COLOR.B[2]],
+        [COLOR.B[3], COLOR.B[4], COLOR.B[5]],
+        [COLOR.B[6], COLOR.B[7], COLOR.B[8]]
+      ],
+      DOWN: [
+        [COLOR.Y[0], COLOR.Y[1], COLOR.Y[2]],
+        [COLOR.Y[3], COLOR.Y[4], COLOR.Y[5]],
+        [COLOR.Y[6], COLOR.Y[7], COLOR.Y[8]]
+      ]
+    };
+    this.MOVES = [];
+  }
   /**
    * Applies a sequence of moves provided as a string.
    * Supports: U, D, L, R, F, x, y, z; slice moves: M; and wide moves: Dw, Uw, Rw, Lw with optional ' for counterclockwise and 2 for double turns.
@@ -327,6 +377,17 @@ rotateF_fn = function(clockwise = true) {
     __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
   }
 };
+rotateB_fn = function(clockwise = true) {
+  __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
+  __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
+  if (clockwise) {
+    __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, true);
+  } else {
+    __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, false);
+  }
+  __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
+  __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
+};
 rotateR_fn = function(clockwise = true) {
   if (clockwise) {
     __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
@@ -596,6 +657,12 @@ applyMovesFromString_fn = function(sequence, record = true) {
           () => record ? this.rotateF(false) : __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, false)
         );
         break;
+      case "B":
+        exec(
+          () => record ? this.rotateB(true) : __privateMethod(this, _CubeEngine_instances, rotateB_fn).call(this, true),
+          () => record ? this.rotateB(false) : __privateMethod(this, _CubeEngine_instances, rotateB_fn).call(this, false)
+        );
+        break;
       case "x":
         exec(
           () => record ? this.rotateX(true) : __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true),

package/dist/index.mjs

@@ -23,9 +23,9 @@ var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
 // src/index.js
-var _CubeEngine_instances, rotateU_fn, rotateF_fn, rotateR_fn, rotateL_fn, rotateD_fn, rotateDw_fn, rotateUw_fn, rotateRw_fn, rotateLw_fn, rotateM_fn, rotateX_fn, rotateZ_fn, rotateY_fn, switchMatrix_fn, specialFlip_fn, applyMovesFromString_fn;
+var _CubeEngine_instances, rotateU_fn, rotateF_fn, rotateB_fn, rotateR_fn, rotateL_fn, rotateD_fn, rotateDw_fn, rotateUw_fn, rotateRw_fn, rotateLw_fn, rotateM_fn, rotateX_fn, rotateZ_fn, rotateY_fn, switchMatrix_fn, specialFlip_fn, applyMovesFromString_fn;
 var CubeEngine = class {
-  constructor(initialScramble) {
+  constructor(initialScramble = "") {
     __privateAdd(this, _CubeEngine_instances);
     __publicField(this, "MOVES", []);
     // States object for the rotation
@@ -96,6 +96,18 @@ var CubeEngine = class {
       this.MOVES.push("F'");
     }
   }
+  /**
+   * Rotates the (BACK) layer clockwise or counterclockwise.
+   */
+  rotateB(clockwise = true) {
+    if (clockwise) {
+      __privateMethod(this, _CubeEngine_instances, rotateB_fn).call(this, true);
+      this.MOVES.push("B");
+    } else {
+      __privateMethod(this, _CubeEngine_instances, rotateB_fn).call(this, false);
+      this.MOVES.push("B'");
+    }
+  }
   /**
    * Rotates the (RIGHT) layer clockwise or counterclockwise.
    */
@@ -259,6 +271,44 @@ var CubeEngine = class {
   getMoves(asString = true) {
     return asString ? this.MOVES.join(" ") : this.MOVES;
   }
+  /**
+   * Resets the cube to the solved state and clears the move history.
+   */
+  reset() {
+    this.STATES = {
+      UPPER: [
+        [COLOR.W[0], COLOR.W[1], COLOR.W[2]],
+        [COLOR.W[3], COLOR.W[4], COLOR.W[5]],
+        [COLOR.W[6], COLOR.W[7], COLOR.W[8]]
+      ],
+      LEFT: [
+        [COLOR.O[0], COLOR.O[1], COLOR.O[2]],
+        [COLOR.O[3], COLOR.O[4], COLOR.O[5]],
+        [COLOR.O[6], COLOR.O[7], COLOR.O[8]]
+      ],
+      FRONT: [
+        [COLOR.G[0], COLOR.G[1], COLOR.G[2]],
+        [COLOR.G[3], COLOR.G[4], COLOR.G[5]],
+        [COLOR.G[6], COLOR.G[7], COLOR.G[8]]
+      ],
+      RIGHT: [
+        [COLOR.R[0], COLOR.R[1], COLOR.R[2]],
+        [COLOR.R[3], COLOR.R[4], COLOR.R[5]],
+        [COLOR.R[6], COLOR.R[7], COLOR.R[8]]
+      ],
+      BACK: [
+        [COLOR.B[0], COLOR.B[1], COLOR.B[2]],
+        [COLOR.B[3], COLOR.B[4], COLOR.B[5]],
+        [COLOR.B[6], COLOR.B[7], COLOR.B[8]]
+      ],
+      DOWN: [
+        [COLOR.Y[0], COLOR.Y[1], COLOR.Y[2]],
+        [COLOR.Y[3], COLOR.Y[4], COLOR.Y[5]],
+        [COLOR.Y[6], COLOR.Y[7], COLOR.Y[8]]
+      ]
+    };
+    this.MOVES = [];
+  }
   /**
    * Applies a sequence of moves provided as a string.
    * Supports: U, D, L, R, F, x, y, z; slice moves: M; and wide moves: Dw, Uw, Rw, Lw with optional ' for counterclockwise and 2 for double turns.
@@ -305,6 +355,17 @@ rotateF_fn = function(clockwise = true) {
     __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
   }
 };
+rotateB_fn = function(clockwise = true) {
+  __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
+  __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
+  if (clockwise) {
+    __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, true);
+  } else {
+    __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, false);
+  }
+  __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
+  __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
+};
 rotateR_fn = function(clockwise = true) {
   if (clockwise) {
     __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
@@ -574,6 +635,12 @@ applyMovesFromString_fn = function(sequence, record = true) {
           () => record ? this.rotateF(false) : __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, false)
         );
         break;
+      case "B":
+        exec(
+          () => record ? this.rotateB(true) : __privateMethod(this, _CubeEngine_instances, rotateB_fn).call(this, true),
+          () => record ? this.rotateB(false) : __privateMethod(this, _CubeEngine_instances, rotateB_fn).call(this, false)
+        );
+        break;
       case "x":
         exec(
           () => record ? this.rotateX(true) : __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cube-state-engine",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "An efficient representation in memory for tracking the Rubik's cube state on each movement.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",