@houstonp/rubiks-cube 1.1.1 → 1.2.0

package/src/animation.js

@@ -1,168 +0,0 @@
-import * as THREE from "three";
-import Cube from "./cube";
-
-export class AnimationQueue {
-  constructor(type = "exponential", factor = 1.3) {
-    /** @type {Animation[]} */
-    this.queue = [];
-    /** @type {Animation | undefined} */
-    this.currentAnimation = undefined;
-    /** @type {{type: "fast-forward" | "exponential", factor: number}} */
-    this.type = type;
-    this.factor = factor;
-  }
-
-  clear() {
-    this.queue = [];
-    if (this.currentAnimation) {
-      this.currentAnimation.fastforward = true;
-      this.currentAnimation.update();
-      this.currentAnimation = undefined;
-    }
-  }
-
-  /**
-   * @param {Animation} animation
-   */
-  add(animation) {
-    if (this.type === "fast-forward") {
-      this.fastForward();
-    } else if (this.type === "exponential") {
-      this.exponential();
-    }
-    this.queue.push(animation);
-  }
-
-  /* exponentially increases the animation speed with the depth of the queue */
-  exponential() {
-    let animations = [];
-    if (this.currentAnimation) animations.push(this.currentAnimation);
-    animations = animations.concat(this.queue);
-    for (let i = 0; i < animations.length; i++) {
-      animations[i].setSpeed(this.factor ** (animations.length - i - 1));
-    }
-  }
-
-  /* instantly completes any queued animations */
-  fastForward() {
-    if (this.currentAnimation) {
-      this.currentAnimation.setFastForward();
-    }
-    if (this.queue.length) {
-      for (const a of this.queue) {
-        a.setFastForward();
-      }
-    }
-  }
-
-  update() {
-    if (
-      this.currentAnimation === undefined ||
-      this.currentAnimation.finished()
-    ) {
-      this.currentAnimation = this.queue.shift();
-    }
-    if (this.currentAnimation === undefined) return;
-    this.currentAnimation.update();
-  }
-
-  finished() {
-    return this.currentAnimation?.finished();
-  }
-
-  /**
-   *
-   * @returns {THREE.Group | undefined}
-   */
-  getAnimationGroup() {
-    return this.currentAnimation?.getGroup();
-  }
-}
-
-export class Animation {
-  /**
-   *
-   * @param {Cube} cube
-   * @param {"x"|"y"|"z"} axis
-   * @param {(-1|0|1)[]} layers
-   * @param {1|-1|2|-2} direction
-   * @param {number} duration milliseconds
-   */
-  constructor(cube, axis, layers, direction, duration) {
-    this._cube = cube;
-    this._axis = axis;
-    this._layers = layers;
-    this._direction = direction;
-    this._duration = duration;
-    this._layerGroup = new THREE.Group();
-    this._finished = false;
-    this._lastUpdate = undefined;
-    this._totalRotation = 0;
-    this.fastforward = false;
-    this.speed = 1;
-  }
-
-  setFastForward(value = true) {
-    this.fastforward = value;
-  }
-
-  setSpeed(value = 1) {
-    this.speed = value;
-  }
-
-  init() {
-    this._lastUpdate = Date.now();
-    const layerObjects = this._cube.getRotationLayer(this._axis, this._layers);
-    this._layerGroup.add(...layerObjects);
-  }
-
-  teardown() {
-    this._finished = true;
-    this._layerGroup.children.forEach((piece) => {
-      piece.getWorldPosition(piece.position);
-      piece.getWorldQuaternion(piece.quaternion);
-      piece.userData.position.x = Math.round(piece.position.x);
-      piece.userData.position.y = Math.round(piece.position.y);
-      piece.userData.position.z = Math.round(piece.position.z);
-      piece.userData.rotation.x = piece.rotation.x;
-      piece.userData.rotation.y = piece.rotation.y;
-      piece.userData.rotation.z = piece.rotation.z;
-    });
-    this._cube.group.add(...this._layerGroup.children);
-  }
-
-  update() {
-    if (this._lastUpdate === undefined) {
-      this.init();
-    }
-
-    var interval = (Date.now() - this._lastUpdate) * this.speed;
-    this._lastUpdate = Date.now();
-    if (this.fastforward || interval + this._totalRotation > this._duration) {
-      interval = this._duration - this._totalRotation;
-    }
-    const rotationIncrement =
-      (Math.abs(this._direction) * ((interval / this._duration) * Math.PI)) / 2;
-    this._totalRotation += interval;
-    this._layerGroup.rotateOnWorldAxis(
-      new THREE.Vector3(
-        this._axis === "x" ? this._direction : 0,
-        this._axis === "y" ? this._direction : 0,
-        this._axis === "z" ? this._direction : 0
-      ).normalize(),
-      rotationIncrement
-    );
-
-    if (this._totalRotation >= this._duration) {
-      this.teardown();
-    }
-  }
-
-  getGroup() {
-    return this._layerGroup;
-  }
-
-  finished() {
-    return this._finished;
-  }
-}

package/src/center.js

@@ -1,23 +0,0 @@
-import * as THREE from "three";
-/**
- * @param {THREE.Geometry} sticker
- * @param {THREE.Material} frontMaterial
- * @param {THREE.Material} topMaterial
- * @param {THREE.Material} coreMaterial
- * @returns {{group: THREE.Group, frontSticker: THREE.Mesh, topSticker:THREE.Mesh}}
- */
-export default function newCenter(sticker, frontMaterial, coreMaterial) {
-  const group = new THREE.Group();
-  const boxGeom = new THREE.BoxGeometry(1, 1, 1);
-  const boxMesh = new THREE.Mesh(boxGeom, coreMaterial);
-  boxMesh.userData = { type: "piece" };
-  group.add(boxMesh);
-
-  const frontSticker = new THREE.Mesh(sticker, frontMaterial);
-  frontSticker.userData = { type: "sticker" };
-  frontSticker.position.set(0, 0, 0.5);
-  frontSticker.rotation.set(0, 0, 0);
-  group.add(frontSticker);
-
-  return { group, frontSticker };
-}

package/src/corner.js

@@ -1,45 +0,0 @@
-import * as THREE from "three";
-/**
- * @param {THREE.Geometry} sticker
- * @param {THREE.Material} frontMaterial
- * @param {THREE.Material} rightMaterial
- * @param {THREE.Material} topMaterial
- * @param {THREE.Material} coreMaterial
- * @returns {{group: THREE.Group, frontSticker: THREE.Mesh, rightSticker:THREE.Mesh, topSticker:THREE.Mesh}}
- */
-export default function newCorner(
-  sticker,
-  frontMaterial,
-  rightMaterial,
-  topMaterial,
-  coreMaterial
-) {
-  const group = new THREE.Group();
-  const boxGeom = new THREE.BoxGeometry(1, 1, 1);
-  const boxMesh = new THREE.Mesh(boxGeom, coreMaterial);
-  boxMesh.userData = { type: "piece" };
-  group.add(boxMesh);
-
-  // front
-  const frontSticker = new THREE.Mesh(sticker, frontMaterial);
-  frontSticker.userData = { type: "sticker" };
-  frontSticker.position.set(0, 0, 0.5);
-  frontSticker.rotation.set(0, 0, 0);
-  group.add(frontSticker);
-
-  //right
-  const rightSticker = new THREE.Mesh(sticker, rightMaterial);
-  rightSticker.userData = { type: "sticker" };
-  rightSticker.position.set(0.5, 0, 0);
-  rightSticker.rotation.set(Math.PI / 2, Math.PI / 2, 0);
-  group.add(rightSticker);
-
-  //white/yellow
-  const topSticker = new THREE.Mesh(sticker, topMaterial);
-  topSticker.userData = { type: "sticker" };
-  topSticker.position.set(0, 0.5, 0);
-  topSticker.rotation.set(-Math.PI / 2, 0, -Math.PI / 2);
-  group.add(topSticker);
-
-  return { group, frontSticker, rightSticker, topSticker };
-}

package/src/cube.js

@@ -1,333 +0,0 @@
-import * as THREE from "three";
-import Materials from "./materials";
-import Stickers from "./stickers";
-import newCorner from "./corner";
-import newEdge from "./edge";
-import newCenter from "./center";
-import { newCubeState } from "./cubeState";
-
-export default class Cube {
-  constructor() {
-    this.group = new THREE.Group();
-    const core = this.createCore();
-    core.userData = {
-      position: { x: 0, y: 0, z: 0 },
-      rotation: { x: 0, y: 0, z: 0 },
-      initialPosition: { x: 0, y: 0, z: 0 },
-      initialRotation: { x: 0, y: 0, z: 0 },
-      type: "core",
-    };
-    this.group.add(core);
-
-    for (const state of newCubeState()) {
-      const piece = this.createPiece(state.position, state.type);
-      piece.position.set(
-        state.position.x * 1.04,
-        state.position.y * 1.04,
-        state.position.z * 1.04
-      );
-      piece.rotation.set(state.rotation.x, state.rotation.y, state.rotation.z);
-      piece.userData = {
-        position: Object.assign({}, state.position),
-        rotation: Object.assign({}, state.rotation),
-        initialPosition: Object.assign({}, state.position),
-        initialRotation: Object.assign({}, state.rotation),
-        type: state.type,
-      };
-      this.group.add(piece);
-    }
-  }
-
-  reset() {
-    this.group.children.forEach((piece) => {
-      const { x, y, z } = piece.userData.initialPosition;
-      const { x: u, y: v, z: w } = piece.userData.initialRotation;
-      piece.position.set(x * 1.04, y * 1.04, z * 1.04);
-      piece.rotation.set(u, v, w);
-      piece.userData.position.x = x
-      piece.userData.position.y = y
-      piece.userData.position.z = z
-      piece.userData.rotation.x = u
-      piece.userData.rotation.y = v
-      piece.userData.rotation.z = w
-    });
-  }
-  /**
-   * @param {"x"|"y"|"z"} axis
-   * @param {{-1|0|1}[]} layers
-   * @returns {THREE.Object3D[]}
-   */
-  getRotationLayer(axis, layers) {
-    if (layers.length === 0) {
-      return [...this.group.children];
-    }
-    return this.group.children.filter((piece) => {
-      if (axis === "x") {
-        return layers.includes(Math.round(piece.userData.position.x));
-      } else if (axis === "y") {
-        return layers.includes(Math.round(piece.userData.position.y));
-      } else if (axis === "z") {
-        return layers.includes(Math.round(piece.userData.position.z));
-      }
-      return false;
-    });
-  }
-
-  getStickerState() {
-    const state = {
-      up: [[], [], []],
-      down: [[], [], []],
-      front: [[], [], []],
-      back: [[], [], []],
-      left: [[], [], []],
-      right: [[], [], []],
-    };
-    this.group.children.forEach((piece) => {
-      if (piece.userData.type === "core") {
-        return;
-      }
-      piece.children.forEach((mesh) => {
-        if (mesh.userData.type === "sticker") {
-          const piecepos = new THREE.Vector3();
-          piecepos.copy(piece.position);
-          piecepos.round();
-          const stickerpos = new THREE.Vector3();
-          mesh.getWorldPosition(stickerpos);
-          stickerpos.sub(piecepos);
-          stickerpos.multiplyScalar(2);
-          stickerpos.round();
-          if (stickerpos.x === 1) {
-            state.right[1 - Math.round(piece.position.y)][
-              1 - Math.round(piece.position.z)
-            ] = mesh.material.userData.face;
-          } else if (stickerpos.x === -1) {
-            state.left[1 - Math.round(piece.position.y)][
-              1 + Math.round(piece.position.z)
-            ] = mesh.material.userData.face;
-          } else if (stickerpos.y === 1) {
-            state.up[1 + Math.round(piece.position.z)][
-              1 + Math.round(piece.position.x)
-            ] = mesh.material.userData.face;
-          } else if (stickerpos.y === -1) {
-            state.down[1 - Math.round(piece.position.z)][
-              1 + Math.round(piece.position.x)
-            ] = mesh.material.userData.face;
-          } else if (stickerpos.z === 1) {
-            state.front[1 - Math.round(piece.position.y)][
-              1 + Math.round(piece.position.x)
-            ] = mesh.material.userData.face;
-          } else if (stickerpos.z === -1) {
-            state.back[1 - Math.round(piece.position.y)][
-              1 - Math.round(piece.position.x)
-            ] = mesh.material.userData.face;
-          }
-        }
-      });
-    });
-    return state;
-  }
-
-  /**
-   * @param {{x:number,y:number,z:number}} position
-   * @param {"corner | edge | center"} type
-   * @returns {THREE.Group}
-   */
-  createPiece(position, type) {
-    if (type === "corner") {
-      return this.createCorner(position).group;
-    } else if (type === "edge") {
-      return this.createEdge(position).group;
-    } else if (type === "center") {
-      return this.createCenter(position).group;
-    } else {
-      throw new Error("Invalid type: " + type);
-    }
-  }
-  /**
-   * @param {{x:number,y:number,z:number}} position
-   * @returns {THREE.Group}
-   */
-  createCorner(position) {
-    if (position.x == 1 && position.y == 1 && position.z == 1) {
-      return newCorner(
-        Stickers.corner,
-        Materials.front,
-        Materials.right,
-        Materials.up,
-        Materials.core
-      );
-    } else if (position.x == 1 && position.y == 1 && position.z == -1) {
-      return newCorner(
-        Stickers.corner,
-        Materials.right,
-        Materials.back,
-        Materials.up,
-        Materials.core
-      );
-    } else if (position.x == 1 && position.y == -1 && position.z == 1) {
-      return newCorner(
-        Stickers.corner,
-        Materials.right,
-        Materials.front,
-        Materials.down,
-        Materials.core
-      );
-    } else if (position.x == 1 && position.y == -1 && position.z == -1) {
-      return newCorner(
-        Stickers.corner,
-        Materials.back,
-        Materials.right,
-        Materials.down,
-        Materials.core
-      );
-    } else if (position.x == -1 && position.y == 1 && position.z == 1) {
-      return newCorner(
-        Stickers.corner,
-        Materials.left,
-        Materials.front,
-        Materials.up,
-        Materials.core
-      );
-    } else if (position.x == -1 && position.y == 1 && position.z == -1) {
-      return newCorner(
-        Stickers.corner,
-        Materials.back,
-        Materials.left,
-        Materials.up,
-        Materials.core
-      );
-    } else if (position.x == -1 && position.y == -1 && position.z == 1) {
-      return newCorner(
-        Stickers.corner,
-        Materials.front,
-        Materials.left,
-        Materials.down,
-        Materials.core
-      );
-    } else if (position.x == -1 && position.y == -1 && position.z == -1) {
-      return newCorner(
-        Stickers.corner,
-        Materials.left,
-        Materials.back,
-        Materials.down,
-        Materials.core
-      );
-    } else {
-      throw new Error("Invalid corner position: " + position);
-    }
-  }
-  /**
-   * @param {{x:number,y:number,z:number}} position
-   * @returns {THREE.Group}
-   */
-  createEdge(position) {
-    if (position.x == 1 && position.y == 1 && position.z == 0) {
-      return newEdge(
-        Stickers.edge,
-        Materials.right,
-        Materials.up,
-        Materials.core
-      );
-    } else if (position.x == 1 && position.y == -1 && position.z == 0) {
-      return newEdge(
-        Stickers.edge,
-        Materials.right,
-        Materials.down,
-        Materials.core
-      );
-    } else if (position.x == 1 && position.y == 0 && position.z == 1) {
-      return newEdge(
-        Stickers.edge,
-        Materials.front,
-        Materials.right,
-        Materials.core
-      );
-    } else if (position.x == 1 && position.y == 0 && position.z == -1) {
-      return newEdge(
-        Stickers.edge,
-        Materials.right,
-        Materials.back,
-        Materials.core
-      );
-    } else if (position.x == -1 && position.y == 1 && position.z == 0) {
-      return newEdge(
-        Stickers.edge,
-        Materials.left,
-        Materials.up,
-        Materials.core
-      );
-    } else if (position.x == -1 && position.y == -1 && position.z == 0) {
-      return newEdge(
-        Stickers.edge,
-        Materials.left,
-        Materials.down,
-        Materials.core
-      );
-    } else if (position.x == -1 && position.y == 0 && position.z == 1) {
-      return newEdge(
-        Stickers.edge,
-        Materials.front,
-        Materials.left,
-        Materials.core
-      );
-    } else if (position.x == -1 && position.y == 0 && position.z == -1) {
-      return newEdge(
-        Stickers.edge,
-        Materials.left,
-        Materials.back,
-        Materials.core
-      );
-    } else if (position.x == 0 && position.y == 1 && position.z == 1) {
-      return newEdge(
-        Stickers.edge,
-        Materials.front,
-        Materials.up,
-        Materials.core
-      );
-    } else if (position.x == 0 && position.y == 1 && position.z == -1) {
-      return newEdge(
-        Stickers.edge,
-        Materials.up,
-        Materials.back,
-        Materials.core
-      );
-    } else if (position.x == 0 && position.y == -1 && position.z == 1) {
-      return newEdge(
-        Stickers.edge,
-        Materials.down,
-        Materials.front,
-        Materials.core
-      );
-    } else if (position.x == 0 && position.y == -1 && position.z == -1) {
-      return newEdge(
-        Stickers.edge,
-        Materials.back,
-        Materials.down,
-        Materials.core
-      );
-    } else {
-      throw new Error("Invalid edge position: " + position);
-    }
-  }
-  /**
-   * @param {{x:number,y:number,z:number}} position
-   * @returns {THREE.Group}
-   */
-  createCenter(position) {
-    var centerColor = Materials.up;
-    if (position.x !== 0) {
-      centerColor = position.x > 0 ? Materials.right : Materials.left;
-    } else if (position.y !== 0) {
-      centerColor = position.y > 0 ? Materials.up : Materials.down;
-    } else if (position.z !== 0) {
-      centerColor = position.z > 0 ? Materials.front : Materials.back;
-    }
-    return newCenter(Stickers.center, centerColor, Materials.core);
-  }
-  /**
-   * @returns {THREE.Group}
-   */
-  createCore() {
-    return new THREE.Mesh(new THREE.SphereGeometry(1.55), Materials.core);
-  }
-}

package/src/cubeState.js

@@ -1,128 +0,0 @@
-/**
- * @typedef {{x: number,y: number,z: number}} vector
- */
-
-/**
- * @type {vector[]}
- */
-const corners = [
-  { position: { x: 1, y: 1, z: 1 }, rotation: { x: 0, y: 0, z: 0 } },
-  { position: { x: 1, y: 1, z: -1 }, rotation: { x: 0, y: Math.PI / 2, z: 0 } },
-  {
-    position: { x: 1, y: -1, z: 1 },
-    rotation: { x: 0, y: Math.PI / 2, z: Math.PI },
-  },
-  {
-    position: { x: 1, y: -1, z: -1 },
-    rotation: { x: 0, y: Math.PI, z: Math.PI },
-  },
-
-  {
-    position: { x: -1, y: 1, z: 1 },
-    rotation: { x: 0, y: -Math.PI / 2, z: 0 },
-  },
-  { position: { x: -1, y: 1, z: -1 }, rotation: { x: 0, y: Math.PI, z: 0 } },
-  { position: { x: -1, y: -1, z: 1 }, rotation: { x: 0, y: 0, z: Math.PI } },
-  {
-    position: { x: -1, y: -1, z: -1 },
-    rotation: { x: 0, y: -Math.PI / 2, z: Math.PI },
-  },
-];
-
-/**
- * @type {vector[]}
- */
-const edges = [
-  { position: { x: 1, y: 1, z: 0 }, rotation: { x: 0, y: Math.PI / 2, z: 0 } },
-  {
-    position: { x: 1, y: 0, z: 1 },
-    rotation: { x: 0, y: 0, z: -Math.PI / 2 },
-  },
-  {
-    position: { x: 1, y: 0, z: -1 },
-    rotation: { x: 0, y: Math.PI / 2, z: -Math.PI / 2 },
-  },
-  {
-    position: { x: 1, y: -1, z: 0 },
-    rotation: { x: Math.PI, y: Math.PI / 2, z: 0 },
-  },
-  { position: { x: 0, y: 1, z: 1 }, rotation: { x: 0, y: 0, z: 0 } },
-  {
-    position: { x: 0, y: 1, z: -1 },
-    rotation: { x: -Math.PI / 2, y: 0, z: 0 },
-  },
-  { position: { x: 0, y: -1, z: 1 }, rotation: { x: Math.PI / 2, y: 0, z: 0 } },
-  { position: { x: 0, y: -1, z: -1 }, rotation: { x: Math.PI, y: 0, z: 0 } },
-  {
-    position: { x: -1, y: 1, z: 0 },
-    rotation: { x: 0, y: -Math.PI / 2, z: 0 },
-  },
-  { position: { x: -1, y: 0, z: 1 }, rotation: { x: 0, y: 0, z: Math.PI / 2 } },
-  {
-    position: { x: -1, y: 0, z: -1 },
-    rotation: { x: 0, y: -Math.PI / 2, z: Math.PI / 2 },
-  },
-  {
-    position: { x: -1, y: -1, z: 0 },
-    rotation: { x: 0, y: -Math.PI / 2, z: Math.PI },
-  },
-];
-
-/**
- * @type {vector[]}
- */
-const centers = [
-  { position: { x: 1, y: 0, z: 0 }, rotation: { x: 0, y: Math.PI / 2, z: 0 } },
-  { position: { x: 0, y: 1, z: 0 }, rotation: { x: -Math.PI / 2, y: 0, z: 0 } },
-  { position: { x: 0, y: 0, z: 1 }, rotation: { x: 0, y: 0, z: 0 } },
-  { position: { x: 0, y: 0, z: -1 }, rotation: { x: 0, y: Math.PI, z: 0 } },
-  { position: { x: 0, y: -1, z: 0 }, rotation: { x: Math.PI / 2, y: 0, z: 0 } },
-  {
-    position: { x: -1, y: 0, z: 0 },
-    rotation: { x: 0, y: -Math.PI / 2, z: 0 },
-  },
-];
-
-/**
- * @typedef {Object} state
- * @property {string} type
- * @property {vector} initialPosition
- * @property {vector} initialRotation
- * @property {vector} position
- * @property {vector} rotation
- */
-
-/**
- *  @returns {state[]}
- */
-export function newCubeState() {
-  let cubeState = [];
-  corners.forEach(({ position, rotation }) => {
-    cubeState.push({
-      type: "corner",
-      initialPosition: position,
-      initialRotation: rotation,
-      position: position,
-      rotation: rotation,
-    });
-  });
-  edges.forEach(({ position, rotation }) => {
-    cubeState.push({
-      type: "edge",
-      initialPosition: position,
-      initialRotation: rotation,
-      position: position,
-      rotation: rotation,
-    });
-  });
-  centers.forEach(({ position, rotation }) => {
-    cubeState.push({
-      type: "center",
-      initialPosition: position,
-      initialRotation: rotation,
-      position: position,
-      rotation: rotation,
-    });
-  });
-  return cubeState;
-}