cubing 0.22.0 → 0.24.0-pre2

package/src/cubing/bluetooth/smart-puzzle/giiker.ts

@@ -1,277 +0,0 @@
-/* tslint:disable no-bitwise */
-
-import { Move } from "../../alg";
-import type { Transformation } from "../../kpuzzle";
-import {
-  BluetoothConfig,
-  BluetoothPuzzle,
-  PuzzleState,
-} from "./bluetooth-puzzle";
-import { debugLog } from "../debug";
-
-const MESSAGE_LENGTH = 20;
-
-const UUIDs = {
-  cubeService: "0000aadb-0000-1000-8000-00805f9b34fb",
-  cubeCharacteristic: "0000aadc-0000-1000-8000-00805f9b34fb",
-};
-
-// TODO: Expose for testing.
-function giikerMoveToAlgMove(face: number, amount: number): Move {
-  switch (amount) {
-    case 3:
-      amount = -1;
-      break;
-    case 9:
-      debugLog("Encountered 9", face, amount);
-      amount = -2;
-      break;
-  }
-
-  const family = ["?", "B", "D", "L", "U", "R", "F"][face];
-  return new Move(family, amount);
-}
-
-export { giikerMoveToAlgMove as giikerMoveToAlgMoveForTesting };
-
-function giikerStateStr(giikerState: number[]): string {
-  let str = "";
-  str += giikerState.slice(0, 8).join(".");
-  str += "\n";
-  str += giikerState.slice(8, 16).join(".");
-  str += "\n";
-  str += giikerState.slice(16, 28).join(".");
-  str += "\n";
-  str += giikerState.slice(28, 32).join(".");
-  str += "\n";
-  str += giikerState.slice(32, 40).join(".");
-  return str;
-}
-
-// TODO
-// const Reid333Orbits = {
-//   "EDGES":   {"numPieces": 12, "orientations": 2},
-//   "CORNERS": {"numPieces": 8,  "orientations": 3},
-//   "CENTERS": {"numPieces": 6,  "orientations": 4}
-// };
-
-const Reid333SolvedCenters = {
-  permutation: [0, 1, 2, 3, 4, 5],
-  orientation: [0, 0, 0, 0, 0, 0],
-};
-
-const epGiiKERtoReid333: number[] = [4, 8, 0, 9, 5, 1, 3, 7, 6, 10, 2, 11];
-const epReid333toGiiKER: number[] = [2, 5, 10, 6, 0, 4, 8, 7, 1, 3, 9, 11];
-
-const preEO: number[] = [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0];
-const postEO: number[] = [1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0];
-
-const cpGiiKERtoReid333: number[] = [4, 0, 3, 5, 7, 1, 2, 6];
-const cpReid333toGiiKER: number[] = [1, 5, 6, 2, 0, 3, 7, 4];
-
-const preCO: number[] = [1, 2, 1, 2, 2, 1, 2, 1];
-const postCO: number[] = [2, 1, 2, 1, 1, 2, 1, 2];
-
-const coFlip: number[] = [-1, 1, -1, 1, 1, -1, 1, -1];
-
-function getNibble(val: Uint8Array, i: number): number {
-  if (i % 2 === 1) {
-    return val[(i / 2) | 0] % 16;
-  }
-  return 0 | (val[(i / 2) | 0] / 16);
-}
-
-function probablyEncrypted(data: Uint8Array): boolean {
-  return data[18] === 0xa7;
-}
-
-const lookup = [
-  176, 81, 104, 224, 86, 137, 237, 119, 38, 26, 193, 161, 210, 126, 150, 81, 93,
-  13, 236, 249, 89, 235, 88, 24, 113, 81, 214, 131, 130, 199, 2, 169, 39, 165,
-  171, 41,
-];
-
-function decryptState(data: Uint8Array): Uint8Array {
-  const offset1 = getNibble(data, 38);
-  const offset2 = getNibble(data, 39);
-  const output = new Uint8Array(MESSAGE_LENGTH);
-  for (let i = 0; i < MESSAGE_LENGTH; i++) {
-    output[i] = data[i] + lookup[offset1 + i] + lookup[offset2 + i];
-  }
-  return output;
-}
-
-// TODO: Support caching which decoding strategy worked last time.
-async function decodeState(data: Uint8Array): Promise<Uint8Array> {
-  if (!probablyEncrypted(data)) {
-    return data;
-  }
-  return decryptState(data);
-  // TODO: Check that the decrypted state is a valid staet.
-}
-
-export class GiiKERCube extends BluetoothPuzzle {
-  public static async connect(
-    server: BluetoothRemoteGATTServer,
-  ): Promise<GiiKERCube> {
-    const cubeService = await server.getPrimaryService(UUIDs.cubeService);
-    debugLog("Service:", cubeService);
-
-    const cubeCharacteristic = await cubeService.getCharacteristic(
-      UUIDs.cubeCharacteristic,
-    );
-    debugLog("Characteristic:", cubeCharacteristic);
-
-    // TODO: Can we safely save the async promise instead of waiting for the response?
-
-    const originalValue = await decodeState(
-      new Uint8Array((await cubeCharacteristic.readValue()).buffer),
-    );
-    debugLog("Original value:", originalValue);
-    const cube = new GiiKERCube(server, cubeCharacteristic, originalValue);
-
-    await cubeCharacteristic.startNotifications();
-    cubeCharacteristic.addEventListener(
-      "characteristicvaluechanged",
-      cube.onCubeCharacteristicChanged.bind(cube),
-    );
-
-    return cube;
-  }
-
-  private constructor(
-    private server: BluetoothRemoteGATTServer,
-    private cubeCharacteristic: BluetoothRemoteGATTCharacteristic,
-    private originalValue?: Uint8Array | null,
-  ) {
-    super();
-  }
-
-  public name(): string | undefined {
-    return this.server.device.name;
-  }
-
-  disconnect(): void {
-    this.server.disconnect();
-  }
-
-  public async getState(): Promise<PuzzleState> {
-    return this.toReid333(
-      new Uint8Array((await this.cubeCharacteristic.readValue()).buffer),
-    );
-  }
-
-  private getBit(val: Uint8Array, i: number): number {
-    const n = (i / 8) | 0;
-    const shift = 7 - (i % 8);
-    return (val[n] >> shift) & 1;
-  }
-
-  private toReid333(val: Uint8Array): Transformation {
-    const state = {
-      EDGES: {
-        permutation: new Array(12),
-        orientation: new Array(12),
-      },
-      CORNERS: {
-        permutation: new Array(8),
-        orientation: new Array(8),
-      },
-      CENTERS: Reid333SolvedCenters,
-    };
-
-    for (let i = 0; i < 12; i++) {
-      const gi = epReid333toGiiKER[i];
-      state.EDGES.permutation[i] =
-        epGiiKERtoReid333[getNibble(val, gi + 16) - 1];
-      state.EDGES.orientation[i] =
-        this.getBit(val, gi + 112) ^
-        preEO[state.EDGES.permutation[i]] ^
-        postEO[i];
-    }
-    for (let i = 0; i < 8; i++) {
-      const gi = cpReid333toGiiKER[i];
-      state.CORNERS.permutation[i] = cpGiiKERtoReid333[getNibble(val, gi) - 1];
-      state.CORNERS.orientation[i] =
-        (getNibble(val, gi + 8) * coFlip[gi] +
-          preCO[state.CORNERS.permutation[i]] +
-          postCO[i]) %
-        3;
-    }
-    return state;
-  }
-
-  private async onCubeCharacteristicChanged(event: any): Promise<void> {
-    const val = await decodeState(new Uint8Array(event.target.value.buffer));
-    debugLog(val);
-    debugLog(val);
-
-    if (this.isRepeatedInitialValue(val)) {
-      debugLog("Skipping repeated initial value.");
-      return;
-    }
-
-    const giikerState = [];
-    for (let i = 0; i < MESSAGE_LENGTH; i++) {
-      giikerState.push(Math.floor(val[i] / 16));
-      giikerState.push(val[i] % 16);
-    }
-    debugLog(giikerState);
-    const str = giikerStateStr(giikerState);
-    debugLog(str);
-
-    this.dispatchMove({
-      latestMove: giikerMoveToAlgMove(giikerState[32], giikerState[33]),
-      timeStamp: event.timeStamp,
-      debug: {
-        stateStr: str,
-      },
-      state: this.toReid333(val),
-    });
-  }
-
-  private isRepeatedInitialValue(val: Uint8Array): boolean {
-    if (typeof this.originalValue === "undefined") {
-      // TODO: Test this branch.
-      throw new Error("GiiKERCube has uninitialized original value.");
-    }
-
-    if (this.originalValue === null) {
-      return false;
-    }
-
-    const originalValue = this.originalValue;
-    // Reset the value here, so we can return early below.
-    this.originalValue = null;
-
-    debugLog("Comparing against original value.");
-    for (let i = 0; i < MESSAGE_LENGTH - 2; i++) {
-      if (originalValue[i] !== val[i]) {
-        debugLog("Different at index ", i);
-        return false;
-      }
-    }
-    return true;
-  }
-}
-
-// TODO: Move this into a factory?
-export const giiKERConfig: BluetoothConfig<BluetoothPuzzle> = {
-  connect: GiiKERCube.connect.bind(GiiKERCube),
-  prefixes: ["Gi", ""], // Hack
-  filters: [
-    // Known prefixes: GiC, GiS (3x3x3), Gi2 (2x2x2)
-    // Suspected prefixes GiY, Gi3
-    { namePrefix: "Gi" },
-    { services: ["0000aadb-0000-1000-8000-00805f9b34fb"] },
-    { services: ["0000aaaa-0000-1000-8000-00805f9b34fb"] },
-    { services: ["0000fe95-0000-1000-8000-00805f9b34fb"] },
-  ],
-  optionalServices: [
-    // "00001530-1212-efde-1523-785feabcd123",
-    // "0000aaaa-0000-1000-8000-00805f9b34fb",
-    UUIDs.cubeService,
-    // "0000180f-0000-1000-8000-00805f9b34fb",
-    // "0000180a-0000-1000-8000-00805f9b34fb"
-  ],
-};

package/src/cubing/bluetooth/smart-puzzle/gocube.ts

@@ -1,167 +0,0 @@
-import { Quaternion } from "three";
-import { Alg, experimentalAppendMove, Move } from "../../alg";
-import { debugLog } from "../debug";
-import { BluetoothConfig, BluetoothPuzzle } from "./bluetooth-puzzle";
-
-const UUIDs = {
-  goCubeService: "6e400001-b5a3-f393-e0a9-e50e24dcca9e",
-  goCubeStateCharacteristic: "6e400003-b5a3-f393-e0a9-e50e24dcca9e",
-};
-
-// https://stackoverflow.com/a/40031979
-function buf2hex(buffer: ArrayBuffer): string {
-  // buffer is an ArrayBuffer
-  return (
-    Array.prototype.map.call(new Uint8Array(buffer), (x: number) =>
-      ("00" + x.toString(16)).slice(-2),
-    ) as string[]
-  ).join(" ");
-}
-
-function bufferToString(buffer: ArrayBuffer): string {
-  const byteView = new Uint8Array(buffer);
-  let str = "";
-  for (const charCode of byteView) {
-    str += String.fromCharCode(charCode);
-  }
-  return str;
-}
-
-const moveMap: Move[] = [
-  new Move("B", 1),
-  new Move("B", -1),
-  new Move("F", 1),
-  new Move("F", -1),
-  new Move("U", 1),
-  new Move("U", -1),
-  new Move("D", 1),
-  new Move("D", -1),
-  new Move("R", 1),
-  new Move("R", -1),
-  new Move("L", 1),
-  new Move("L", -1),
-];
-
-export class GoCube extends BluetoothPuzzle {
-  // We have to perform async operations before we call the constructor.
-  public static async connect(
-    server: BluetoothRemoteGATTServer,
-  ): Promise<GoCube> {
-    const service = await server.getPrimaryService(UUIDs.goCubeService);
-    debugLog({ service });
-    const goCubeStateCharacteristic = await service.getCharacteristic(
-      UUIDs.goCubeStateCharacteristic,
-    );
-    debugLog({ goCubeStateCharacteristic });
-
-    const cube = new GoCube(server, goCubeStateCharacteristic);
-
-    await goCubeStateCharacteristic.startNotifications();
-    goCubeStateCharacteristic.addEventListener(
-      "characteristicvaluechanged",
-      cube.onCubeCharacteristicChanged.bind(cube),
-    );
-
-    return cube;
-  }
-
-  // public async getState(): Promise<PuzzleState> {
-  //   return new Promise((resolve, reject) => {
-  //     this.resolve = (value: any) => {
-  //       resolve(buf2hex(value.buffer) as any);
-  //     };
-  //     this.goCubeStateCharacteristic.startNotifications();
-  //   });
-  // }
-
-  private recorded: any[][] = [];
-
-  private homeQuatInverse: Quaternion | null = null;
-  private lastRawQuat: Quaternion = new Quaternion(0, 0, 0, 1);
-  private currentQuat: Quaternion = new Quaternion(0, 0, 0, 1);
-  private lastTarget: Quaternion = new Quaternion(0, 0, 0, 1);
-  private alg: Alg = new Alg();
-
-  private constructor(
-    private server: BluetoothRemoteGATTServer,
-    public goCubeStateCharacteristic: BluetoothRemoteGATTCharacteristic,
-  ) {
-    super();
-  }
-
-  disconnect(): void {
-    this.server.disconnect();
-  }
-
-  public reset(): void {
-    this.resetAlg();
-    this.resetOrientation();
-  }
-
-  public resetAlg(alg?: Alg): void {
-    this.alg = alg || new Alg();
-  }
-
-  public resetOrientation(): void {
-    this.homeQuatInverse = this.lastRawQuat.clone().inverse();
-    this.currentQuat = new Quaternion(0, 0, 0, 1);
-    this.lastTarget = new Quaternion(0, 0, 0, 1);
-  }
-
-  public name(): string | undefined {
-    return this.server.device.name;
-  }
-
-  private onCubeCharacteristicChanged(event: any): void {
-    const buffer: DataView = event.target.value;
-    this.recorded.push([event.timeStamp, buf2hex(buffer.buffer)]);
-    // TODO: read bytes from buffer instead of guessing meaning based on length.
-    if (buffer.byteLength < 16) {
-      for (let i = 3; i < buffer.byteLength - 4; i += 2) {
-        const move = moveMap[buffer.getUint8(i)];
-        this.alg = experimentalAppendMove(this.alg, move);
-        this.dispatchMove({
-          latestMove: moveMap[buffer.getUint8(i)],
-          timeStamp: event.timeStamp,
-          debug: {
-            stateStr: buf2hex(buffer.buffer),
-          },
-        });
-      }
-    } else {
-      const coords = bufferToString(
-        buffer.buffer.slice(3, buffer.byteLength - 3),
-      )
-        .split("#")
-        .map((s) => parseInt(s, 10) / 16384);
-      const quat = new Quaternion(coords[0], coords[1], coords[2], coords[3]);
-
-      this.lastRawQuat = quat.clone();
-
-      if (!this.homeQuatInverse) {
-        this.homeQuatInverse = quat.clone().inverse();
-      }
-
-      const targetQuat = quat.clone().multiply(this.homeQuatInverse.clone());
-      targetQuat.y = -targetQuat.y; // GoCube axis fix.
-
-      this.lastTarget.slerp(targetQuat, 0.5);
-      this.currentQuat.rotateTowards(this.lastTarget, rotateTowardsRate);
-
-      this.dispatchOrientation({
-        quaternion: this.currentQuat,
-        timeStamp: event.timeStamp,
-      });
-    }
-  }
-}
-
-const rotateTowardsRate = 0.5;
-
-// TODO: Move this into a factory?
-export const goCubeConfig: BluetoothConfig<BluetoothPuzzle> = {
-  connect: GoCube.connect.bind(GoCube),
-  prefixes: ["GoCube", "Rubik"],
-  filters: [{ namePrefix: "GoCube" }, { namePrefix: "Rubik" }],
-  optionalServices: [UUIDs.goCubeService],
-};

package/src/cubing/bluetooth/smart-puzzle/unsafe-raw-aes.ts

@@ -1,66 +0,0 @@
-const blockSize = 16;
-const zeros = new Uint8Array(blockSize);
-const paddingBlockPlaintext = new Uint8Array(
-  new Array(blockSize).fill(blockSize),
-);
-const AES_CBC = "AES-CBC";
-
-export async function importKey(keyBytes: ArrayBuffer): Promise<CryptoKey> {
-  return await crypto.subtle.importKey("raw", keyBytes, AES_CBC, true, [
-    "encrypt",
-    "decrypt",
-  ]);
-}
-
-async function unsafeEncryptBlockWithIV(
-  key: CryptoKey,
-  plaintextBlock: ArrayBuffer,
-  iv: ArrayBuffer,
-): Promise<ArrayBuffer> {
-  return (
-    await window.crypto.subtle.encrypt(
-      {
-        name: AES_CBC,
-        iv,
-      },
-      key,
-      plaintextBlock,
-    )
-  ).slice(0, blockSize);
-}
-
-export async function unsafeEncryptBlock(
-  key: CryptoKey,
-  plaintextBlock: ArrayBuffer,
-): Promise<ArrayBuffer> {
-  return (await unsafeEncryptBlockWithIV(key, plaintextBlock, zeros)).slice(
-    0,
-    blockSize,
-  );
-}
-
-export async function unsafeDecryptBlock(
-  key: CryptoKey,
-  ciphertextBlock: ArrayBuffer,
-): Promise<ArrayBuffer> {
-  const paddingBlock = await unsafeEncryptBlockWithIV(
-    key,
-    paddingBlockPlaintext,
-    ciphertextBlock,
-  );
-
-  const cbcCiphertext = new Uint8Array(2 * blockSize);
-  cbcCiphertext.set(new Uint8Array(ciphertextBlock), 0);
-  cbcCiphertext.set(new Uint8Array(paddingBlock), blockSize);
-
-  return (
-    await window.crypto.subtle.decrypt(
-      {
-        name: AES_CBC,
-        iv: zeros,
-      },
-      key,
-      cbcCiphertext,
-    )
-  ).slice(0, blockSize);
-}