wca-scramble-to-matrix/444.js

wca-scramble-to-matrix is a JavaScript library that provides utility functions for generating matrix representations of various Rubik's Cubes. It supports cubes ranging from 2x2 to 7x7. Each cube-specific function takes a scramble as input and returns a m

get444imgmatrix = (scramble) => {
  let cube = {
    up: Array.from({ length: 4 }, () => Array.from({ length: 4 }, () => "w")),
    down: Array.from({ length: 4 }, () => Array.from({ length: 4 }, () => "y")),
    left: Array.from({ length: 4 }, () => Array.from({ length: 4 }, () => "o")),
    right: Array.from({ length: 4 }, () =>
      Array.from({ length: 4 }, () => "r")
    ),
    front: Array.from({ length: 4 }, () =>
      Array.from({ length: 4 }, () => "g")
    ),
    back: Array.from({ length: 4 }, () => Array.from({ length: 4 }, () => "b")),
  };

  rotate_face_clkwise = (face) => {
    current_face = structuredClone(face);

    for (let index = 0; index < 4; index++) {
      face[0][index] = current_face[3 - index][0];
    }

    for (let index = 0; index < 4; index++) {
      face[index][0] = current_face[3][index];
    }

    for (let index = 0; index < 4; index++) {
      face[3][index] = current_face[3 - index][3];
    }

    for (let index = 0; index < 4; index++) {
      face[index][3] = current_face[0][index];
    }

    for (let index = 1; index < 3; index++) {
      face[1][index] = current_face[3 - index][1];
    }

    for (let index = 1; index < 3; index++) {
      face[2][index] = current_face[3 - index][2];
    }

    return face;
  };

  rotate_face_anticlkwise = (face) => {
    rotate_face_clkwise(face);
    rotate_face_clkwise(face);
    rotate_face_clkwise(face);
  };

  u_move = () => {
    front_top_layer = cube.front[0];

    cube.front[0] = cube.right[0];
    cube.right[0] = cube.back[0];
    cube.back[0] = cube.left[0];
    cube.left[0] = front_top_layer;

    rotate_face_clkwise(cube.up);
  };

  uw_move = () => {
    front_2nd_layer = cube.front[1];

    cube.front[1] = cube.right[1];
    cube.right[1] = cube.back[1];
    cube.back[1] = cube.left[1];
    cube.left[1] = front_2nd_layer;

    u_move();
  };

  rotate_cube_X_clkwise = () => {
    current_cube = structuredClone(cube);

    rotate_face_clkwise(current_cube.right);
    cube.right = current_cube.right;

    rotate_face_anticlkwise(current_cube.left);
    cube.left = current_cube.left;

    cube.front = current_cube.down;

    cube.up = current_cube.front;

    rotate_face_clkwise(current_cube.up);
    rotate_face_clkwise(current_cube.up);
    cube.back = current_cube.up;

    rotate_face_clkwise(current_cube.back);
    rotate_face_clkwise(current_cube.back);
    cube.down = current_cube.back;
  };

  rotate_cube_X_anticlkwise = () => {
    rotate_cube_X_clkwise();
    rotate_cube_X_clkwise();
    rotate_cube_X_clkwise();
  };

  rotate_cube_Z_clkwise = () => {
    current_cube = structuredClone(cube);

    rotate_face_clkwise(current_cube.front);
    cube.front = current_cube.front;

    rotate_face_anticlkwise(current_cube.back);
    cube.back = current_cube.back;

    rotate_face_clkwise(current_cube.up);
    cube.right = current_cube.up;

    rotate_face_clkwise(current_cube.right);
    cube.down = current_cube.right;

    rotate_face_clkwise(current_cube.down);
    cube.left = current_cube.down;

    rotate_face_clkwise(current_cube.left);
    cube.up = current_cube.left;
  };

  rotate_cube_Z_anticlkwise = () => {
    rotate_cube_Z_clkwise();
    rotate_cube_Z_clkwise();
    rotate_cube_Z_clkwise();
  };

  f_move = () => {
    rotate_cube_X_clkwise();
    u_move();
    rotate_cube_X_anticlkwise();
  };

  r_move = () => {
    rotate_cube_Z_anticlkwise();
    u_move();
    rotate_cube_Z_clkwise();
  };

  l_move = () => {
    rotate_cube_Z_clkwise();
    u_move();
    rotate_cube_Z_anticlkwise();
  };

  d_move = () => {
    rotate_cube_X_clkwise();
    rotate_cube_X_clkwise();
    u_move();
    rotate_cube_X_anticlkwise();
    rotate_cube_X_anticlkwise();
  };

  b_move = () => {
    rotate_cube_X_anticlkwise();
    u_move();
    rotate_cube_X_clkwise();
  };

  fw_move = () => {
    rotate_cube_X_clkwise();
    uw_move();
    rotate_cube_X_anticlkwise();
  };

  rw_move = () => {
    rotate_cube_Z_anticlkwise();
    uw_move();
    rotate_cube_Z_clkwise();
  };

  lw_move = () => {
    rotate_cube_Z_clkwise();
    uw_move();
    rotate_cube_Z_anticlkwise();
  };

  dw_move = () => {
    rotate_cube_X_clkwise();
    rotate_cube_X_clkwise();
    uw_move();
    rotate_cube_X_anticlkwise();
    rotate_cube_X_anticlkwise();
  };

  bw_move = () => {
    rotate_cube_X_anticlkwise();
    uw_move();
    rotate_cube_X_clkwise();
  };

  u_prime_move = () => {
    u_move();
    u_move();
    u_move();
  };

  f_prime_move = () => {
    f_move();
    f_move();
    f_move();
  };

  d_prime_move = () => {
    d_move();
    d_move();
    d_move();
  };

  l_prime_move = () => {
    l_move();
    l_move();
    l_move();
  };

  b_prime_move = () => {
    b_move();
    b_move();
    b_move();
  };

  r_prime_move = () => {
    r_move();
    r_move();
    r_move();
  };

  uw_prime_move = () => {
    uw_move();
    uw_move();
    uw_move();
  };

  fw_prime_move = () => {
    fw_move();
    fw_move();
    fw_move();
  };

  dw_prime_move = () => {
    dw_move();
    dw_move();
    dw_move();
  };

  lw_prime_move = () => {
    lw_move();
    lw_move();
    lw_move();
  };

  bw_prime_move = () => {
    bw_move();
    bw_move();
    bw_move();
  };

  rw_prime_move = () => {
    rw_move();
    rw_move();
    rw_move();
  };

  scramble_simplifier = () => {
    let simplified_scramble_arr = [];
    let scramble_arr = scramble.split(" ");

    scramble_arr.forEach((element) => {
      if (element.includes("2")) {
        simplified_scramble_arr.push(element.replace("2", ""));
        simplified_scramble_arr.push(element.replace("2", ""));
      } else {
        simplified_scramble_arr.push(element);
      }
    });
    return simplified_scramble_arr;
  };

  img_matrix_gen = () => {
    let simplified_scramble = scramble_simplifier(scramble);
    simplified_scramble.forEach((move) => {
      switch (move) {
        case "R":
          r_move();
          break;
        case "R'":
          r_prime_move();
          break;
        case "L":
          l_move();
          break;
        case "L'":
          l_prime_move();
          break;
        case "U":
          u_move();
          break;
        case "U'":
          u_prime_move();
          break;
        case "D":
          d_move();
          break;
        case "D'":
          d_prime_move();
          break;
        case "F":
          f_move();
          break;
        case "F'":
          f_prime_move();
          break;
        case "B":
          b_move();
          break;
        case "B'":
          b_prime_move();
          break;
        case "Uw":
          uw_move();
          break;
        case "Uw'":
          uw_prime_move();
          break;
        case "Fw":
          fw_move();
          break;
        case "Fw'":
          fw_prime_move();
          break;
        case "Dw":
          dw_move();
          break;
        case "Dw'":
          dw_prime_move();
          break;
        case "Lw":
          lw_move();
          break;
        case "Lw'":
          lw_prime_move();
          break;
        case "Bw":
          bw_move();
          break;
        case "Bw'":
          bw_prime_move();
          break;
        case "Rw":
          rw_move();
          break;
        case "Rw'":
          rw_prime_move();
          break;
        default:
          break;
      }
    });
  };
  img_matrix_gen();

  return cube;
};

module.exports = {
  get444imgmatrix,
};