@houstonp/rubiks-cube 2.1.0 → 3.0.0

package/src/cube/cubeState.js

@@ -1,337 +0,0 @@
-// @ts-check
-/**
- * @typedef {{x: number,y: number,z: number}} vector
- */
-
-import { CubeTypes, Faces } from '../core';
-import { defaultStickerState } from './stickerState';
-
-/** @typedef {{cubeType: import('../core').CubeType, layers: number[], pieceSize: number, coreSize: number,initialStickerState: import('./stickerState').StickerState, outerLayerMultiplier: number, corners: state[], edges: state[], centers: state[]}} CubeInfo */
-/**
- * @param {import("../core").CubeType} cubeType
- * @return {CubeInfo}
- */
-export function getCubeInfo(cubeType) {
-    return {
-        cubeType: cubeType,
-        layers: getMiddleLayers(cubeType),
-        pieceSize: pieceSize(cubeType),
-        coreSize: coreSize(cubeType),
-        initialStickerState: defaultStickerState(cubeType),
-        outerLayerMultiplier: outlerLayerMultiplier(cubeType),
-        corners: corners,
-        edges: edges(getMiddleLayers(cubeType)),
-        centers: centers(getMiddleLayers(cubeType)),
-    };
-}
-
-export const FaceColors = {
-    [Faces.B]: 'blue',
-    [Faces.D]: 'yellow',
-    [Faces.F]: '#2cbf13',
-    [Faces.L]: '#fc9a05',
-    [Faces.R]: 'red',
-    [Faces.U]: 'white',
-};
-
-/**
- * @param {import('three').ColorRepresentation} color
- * @return {import('../core').Face}
- * */
-export const ColorToFace = (color) => {
-    const face = Object.values(Faces).find((face) => FaceColors[face] === color);
-    if (!face) {
-        throw new Error(`Invalid color: ${color}`);
-    }
-    return face;
-};
-
-/**
- * @param {import("../core").CubeType} cubeType
- * @return {number} core size
- */
-export const outlerLayerMultiplier = (cubeType) => {
-    switch (cubeType) {
-        case CubeTypes.Two:
-            return 1;
-        case CubeTypes.Three:
-            return 1;
-        case CubeTypes.Four:
-            return 1.1;
-        case CubeTypes.Five:
-            return 1.2;
-        case CubeTypes.Six:
-            return 1.3;
-        case CubeTypes.Seven:
-            return 1.35;
-        default:
-            throw new Error(`Unsupported cube type: ${cubeType}`);
-    }
-};
-
-/**
- * @param {import("../core").CubeType} cubeType
- * @return {number} core size
- */
-export const coreSize = (cubeType) => {
-    switch (cubeType) {
-        case CubeTypes.Two:
-            return 2;
-        case CubeTypes.Three:
-            return 1.53;
-        case CubeTypes.Four:
-            return 1.36;
-        case CubeTypes.Five:
-            return 1.3;
-        case CubeTypes.Six:
-            return 1.22;
-        case CubeTypes.Seven:
-            return 1.21;
-        default:
-            throw new Error(`Unsupported cube type: ${cubeType}`);
-    }
-};
-
-/**
- * @param {import("../core").CubeType} cubeType
- */
-export const getMiddleLayers = (cubeType) => {
-    switch (cubeType) {
-        case CubeTypes.Two:
-            return [];
-        case CubeTypes.Three:
-            return [0];
-        case CubeTypes.Four:
-            return [-1 / 3, 1 / 3];
-        case CubeTypes.Five:
-            return [-1 / 2, 0, 1 / 2];
-        case CubeTypes.Six:
-            return [-3 / 5, -1 / 5, 1 / 5, 3 / 5];
-        case CubeTypes.Seven:
-            return [-2 / 3, -1 / 3, 0, 1 / 3, 2 / 3];
-        default:
-            throw new Error(`Unsupported cube type: ${cubeType}`);
-    }
-};
-
-/**
- * @param {import("../core").CubeType} cubeType
- */
-export const getAllLayers = (cubeType) => {
-    return [-1, ...getMiddleLayers(cubeType), 1];
-};
-
-/**
- * @param {import("../core").CubeType} cubeType
- * @return {number} piece size
- */
-export const pieceSize = (cubeType) => {
-    switch (cubeType) {
-        case CubeTypes.Two:
-            return 2;
-        case CubeTypes.Three:
-            return 1;
-        case CubeTypes.Four:
-            return 2 / 3;
-        case CubeTypes.Five:
-            return 1 / 2;
-        case CubeTypes.Six:
-            return 2 / 5;
-        case CubeTypes.Seven:
-            return 1 / 3;
-        default:
-            throw new Error(`Unsupported cube type: ${cubeType}`);
-    }
-};
-
-/**
- * @typedef {{position: vector, rotation: vector}} state
- */
-
-/** @type {state[]} */
-export 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 },
-    },
-];
-
-/**
- * @param {number[]} layers
- * @return {state[]}
- */
-export const centers = (layers) => [
-    //right
-    ...layers.flatMap((layer1) =>
-        layers.map((layer2) => {
-            return {
-                position: { x: 1, y: layer1, z: layer2 },
-                rotation: { x: 0, y: Math.PI / 2, z: 0 },
-            };
-        }),
-    ),
-    //up
-    ...layers.flatMap((layer1) =>
-        layers.map((layer2) => {
-            return {
-                position: { x: layer1, y: 1, z: layer2 },
-                rotation: { x: -Math.PI / 2, y: 0, z: 0 },
-            };
-        }),
-    ),
-    //front
-    ...layers.flatMap((layer1) =>
-        layers.map((layer2) => {
-            return {
-                position: { x: layer1, y: layer2, z: 1 },
-                rotation: { x: 0, y: 0, z: 0 },
-            };
-        }),
-    ),
-    //back
-    ...layers.flatMap((layer1) =>
-        layers.map((layer2) => {
-            return {
-                position: { x: layer1, y: layer2, z: -1 },
-                rotation: { x: 0, y: Math.PI, z: 0 },
-            };
-        }),
-    ),
-    //down
-    ...layers.flatMap((layer1) =>
-        layers.map((layer2) => {
-            return {
-                position: { x: layer1, y: -1, z: layer2 },
-                rotation: { x: Math.PI / 2, y: 0, z: 0 },
-            };
-        }),
-    ),
-    //left
-    ...layers.flatMap((layer1) =>
-        layers.map((layer2) => {
-            return {
-                position: { x: -1, y: layer1, z: layer2 },
-                rotation: { x: 0, y: -Math.PI / 2, z: 0 },
-            };
-        }),
-    ),
-];
-
-/**
- * @param {number[]} layers
- * @return {state[]}
- */
-export const edges = (layers) => [
-    // RU
-    ...layers.map((layer) => {
-        return {
-            position: { x: 1, y: 1, z: layer },
-            rotation: { x: 0, y: Math.PI / 2, z: 0 },
-        };
-    }),
-    // RF
-    ...layers.map((layer) => {
-        return {
-            position: { x: 1, y: layer, z: 1 },
-            rotation: { x: 0, y: 0, z: -Math.PI / 2 },
-        };
-    }),
-    // RB
-    ...layers.map((layer) => {
-        return {
-            position: { x: 1, y: layer, z: -1 },
-            rotation: { x: 0, y: Math.PI / 2, z: -Math.PI / 2 },
-        };
-    }),
-    // RD
-    ...layers.map((layer) => {
-        return {
-            position: { x: 1, y: -1, z: layer },
-            rotation: { x: Math.PI, y: Math.PI / 2, z: 0 },
-        };
-    }),
-    // UF
-    ...layers.map((layer) => {
-        return {
-            position: { x: layer, y: 1, z: 1 },
-            rotation: { x: 0, y: 0, z: 0 },
-        };
-    }),
-    // UB
-    ...layers.map((layer) => {
-        return {
-            position: { x: layer, y: 1, z: -1 },
-            rotation: { x: -Math.PI / 2, y: 0, z: 0 },
-        };
-    }),
-    // DF
-    ...layers.map((layer) => {
-        return {
-            position: { x: layer, y: -1, z: 1 },
-            rotation: { x: Math.PI / 2, y: 0, z: 0 },
-        };
-    }),
-    // DB
-    ...layers.map((layer) => {
-        return {
-            position: { x: layer, y: -1, z: -1 },
-            rotation: { x: Math.PI, y: 0, z: 0 },
-        };
-    }),
-    // LU
-    ...layers.map((layer) => {
-        return {
-            position: { x: -1, y: 1, z: layer },
-            rotation: { x: 0, y: -Math.PI / 2, z: 0 },
-        };
-    }),
-    // LF
-    ...layers.map((layer) => {
-        return {
-            position: { x: -1, y: layer, z: 1 },
-            rotation: { x: 0, y: 0, z: Math.PI / 2 },
-        };
-    }),
-    // LB
-    ...layers.map((layer) => {
-        return {
-            position: { x: -1, y: layer, z: -1 },
-            rotation: { x: 0, y: -Math.PI / 2, z: Math.PI / 2 },
-        };
-    }),
-    // LD
-    ...layers.map((layer) => {
-        return {
-            position: { x: -1, y: -1, z: layer },
-            rotation: { x: 0, y: -Math.PI / 2, z: Math.PI },
-        };
-    }),
-];

package/src/cube/stickerState.js

@@ -1,188 +0,0 @@
-// @ts-check
-/** @typedef {{ up: import('../core').Face[][], down: import('../core').Face[][], front: import('../core').Face[][], back: import('../core').Face[][], left: import('../core').Face[][], right: import('../core').Face[][] }} StickerState*/
-
-import { CubeTypes, Faces } from '../core';
-
-/**
- *
- * @param {import('../core').CubeType} cubeType
- * @return {StickerState}
- */
-export const defaultStickerState = (cubeType) => {
-    const length = 0;
-    switch (cubeType) {
-        case CubeTypes.Two:
-            return initialStickerState(2);
-        case CubeTypes.Three:
-            return initialStickerState(3);
-        case CubeTypes.Four:
-            return initialStickerState(4);
-        case CubeTypes.Five:
-            return initialStickerState(5);
-        case CubeTypes.Six:
-            return initialStickerState(6);
-        case CubeTypes.Seven:
-            return initialStickerState(7);
-        default:
-            throw new Error(`Unsupported cube type: ${cubeType}`);
-    }
-};
-
-/**
- *
- * @param {number} layerCount
- * @returns {StickerState}
- */
-const initialStickerState = (layerCount) => {
-    const state = {
-        right: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.R)),
-        up: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.U)),
-        front: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.F)),
-        back: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.B)),
-        down: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.D)),
-        left: Array.from({ length: layerCount }, () => Array.from({ length: layerCount }, () => Faces.L)),
-    };
-    return state;
-};
-
-/**
- *
- * @param {import('../core').CubeType} cubeType
- * @return {StickerState}
- */
-export const getEmptyStickerState = (cubeType) => {
-    const length = 0;
-    switch (cubeType) {
-        case CubeTypes.Two:
-            return emptyStickerState(2);
-        case CubeTypes.Three:
-            return emptyStickerState(3);
-        case CubeTypes.Four:
-            return emptyStickerState(4);
-        case CubeTypes.Five:
-            return emptyStickerState(5);
-        case CubeTypes.Six:
-            return emptyStickerState(6);
-        case CubeTypes.Seven:
-            return emptyStickerState(7);
-        default:
-            throw new Error(`Unsupported cube type: ${cubeType}`);
-    }
-};
-/**
- *
- * @param {number} layerCount
- * @returns {StickerState}
- */
-const emptyStickerState = (layerCount) => {
-    const state = {
-        right: Array.from({ length: layerCount }, () => []),
-        up: Array.from({ length: layerCount }, () => []),
-        front: Array.from({ length: layerCount }, () => []),
-        back: Array.from({ length: layerCount }, () => []),
-        down: Array.from({ length: layerCount }, () => []),
-        left: Array.from({ length: layerCount }, () => []),
-    };
-    return state;
-};
-
-/**
- * @param {StickerState} stickerState
- * @returns {string}
- */
-export function toKociemba(stickerState) {
-    return `${stickerState.up.flat().join('')}${stickerState.right.flat().join('')}${stickerState.front.flat().join('')}${stickerState.down.flat().join('')}${stickerState.left.flat().join('')}${stickerState.back.flat().join('')}`;
-}
-
-/**
- * @param {string} kociembaString
- * @param {import('../core').CubeType} cubeType
- * @returns {StickerState | undefined} stickerState
- */
-export function fromKociemba(kociembaString, cubeType) {
-    const length = kociembaString.length;
-    switch (cubeType) {
-        case CubeTypes.Two:
-            if (length != 6 * 2 ** 2) {
-                console.error('Invalid state string length. Length must be 24 for 2x2 cubes.');
-                return;
-            }
-            return fromKociembaWithLayerCount(kociembaString, 2);
-        case CubeTypes.Three:
-            if (length != 6 * 3 ** 2) {
-                console.error('Invalid state string length. Length must be 54 for 3x3 cubes.');
-                return;
-            }
-            return fromKociembaWithLayerCount(kociembaString, 3);
-        case CubeTypes.Four:
-            if (length != 6 * 4 ** 2) {
-                console.error('Invalid state string length. Length must be 96 for 4x4 cubes.');
-                return;
-            }
-            return fromKociembaWithLayerCount(kociembaString, 4);
-        case CubeTypes.Five:
-            if (length != 6 * 5 ** 2) {
-                console.error('Invalid state string length. Length must be 150 for 5x5 cubes.');
-                return;
-            }
-            return fromKociembaWithLayerCount(kociembaString, 5);
-        case CubeTypes.Six:
-            if (length != 6 * 6 ** 2) {
-                console.error('Invalid state string length. Length must be 216 for 6x6 cubes.');
-                return;
-            }
-            return fromKociembaWithLayerCount(kociembaString, 6);
-        case CubeTypes.Seven:
-            if (length != 6 * 7 ** 2) {
-                console.error('Invalid state string length. Length must be 294 for 7x7 cubes.');
-                return;
-            }
-            return fromKociembaWithLayerCount(kociembaString, 7);
-        default:
-            undefined;
-    }
-}
-
-/**
- * @param {string} kociembaString
- * @param {number} layerCount
- * @returns {StickerState | undefined } stickerState
- */
-function fromKociembaWithLayerCount(kociembaString, layerCount) {
-    let stickerState = emptyStickerState(layerCount);
-    for (let i = 0; i < 6; i++) {
-        const faceString = kociembaString.slice(i * layerCount ** 2, (i + 1) * layerCount ** 2);
-        for (let j = 0; j < layerCount; j++) {
-            const rowString = faceString.slice(j * layerCount, (j + 1) * layerCount);
-            for (let k = 0; k < layerCount; k++) {
-                const face = Object.values(Faces).find((face) => rowString[k] === face);
-                if (!face) {
-                    return undefined;
-                }
-                switch (i) {
-                    case 0:
-                        stickerState.up[j][k] = face;
-                        break;
-                    case 1:
-                        stickerState.right[j][k] = face;
-                        break;
-                    case 2:
-                        stickerState.front[j][k] = face;
-                        break;
-                    case 3:
-                        stickerState.down[j][k] = face;
-                        break;
-                    case 4:
-                        stickerState.left[j][k] = face;
-                        break;
-                    case 5:
-                        stickerState.back[j][k] = face;
-                        break;
-                    default:
-                        throw new Error(`Invalid value for i - [${i}]. i should be between [0,5] inclusive.`);
-                }
-            }
-        }
-    }
-    return stickerState;
-}