cubing 0.22.0 → 0.24.0-pre2

package/src/cubing/bluetooth/smart-robot/GanRobot.ts

@@ -1,311 +0,0 @@
-import { Alg, Move } from "../../alg";
-import type { BluetoothConfig } from "../smart-puzzle/bluetooth-puzzle";
-
-// TODO: Remove this. It's only used for debugging.
-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(" ");
-}
-
-const MAX_NIBBLES_PER_WRITE = 18 * 2;
-const QUANTUM_TURN_DURATION_MS = 150;
-const DOUBLE_TURN_DURATION_MS = 250;
-
-const U_D_SWAP = new Alg("F B R2 L2 B' F'");
-const U_D_UNSWAP = U_D_SWAP.invert(); // TODO: make `cubing.js` clever enough to be able to reuse the regular swap.
-const F_B_SWAP = new Alg("U D R2 L2 D' U'");
-const F_B_UNSWAP = F_B_SWAP.invert();
-
-// TODO: Short IDs
-const UUIDs = {
-  ganRobotService: "0000fff0-0000-1000-8000-00805f9b34fb",
-  statusCharacteristic: "0000fff2-0000-1000-8000-00805f9b34fb",
-  moveCharacteristic: "0000fff3-0000-1000-8000-00805f9b34fb",
-};
-
-const moveMap: Record<string, number> = {
-  "R": 0,
-  "R2": 1,
-  "R2'": 1,
-  "R'": 2,
-  "F": 3,
-  "F2": 4,
-  "F2'": 4,
-  "F'": 5,
-  "D": 6,
-  "D2": 7,
-  "D2'": 7,
-  "D'": 8,
-  "L": 9,
-  "L2": 10,
-  "L2'": 10,
-  "L'": 11,
-  "B": 12,
-  "B2": 13,
-  "B2'": 13,
-  "B'": 14,
-};
-
-const moveMapX: Record<string, number> = {
-  "R": 0,
-  "R2": 1,
-  "R2'": 1,
-  "R'": 2,
-  "U": 3,
-  "U2": 4,
-  "U2'": 4,
-  "U'": 5,
-  "F": 6,
-  "F2": 7,
-  "F2'": 7,
-  "F'": 8,
-  "L": 9,
-  "L2": 10,
-  "L2'": 10,
-  "L'": 11,
-  "D": 12,
-  "D2": 13,
-  "D2'": 13,
-  "D'": 14,
-};
-
-function isDoubleTurnNibble(nibble: number): boolean {
-  return nibble % 3 === 1;
-}
-
-function nibbleDuration(nibble: number): number {
-  return isDoubleTurnNibble(nibble)
-    ? DOUBLE_TURN_DURATION_MS
-    : QUANTUM_TURN_DURATION_MS;
-}
-
-function throwInvalidMove(move: Move) {
-  console.error("invalid move", move, move.toString());
-  throw new Error("invalid move!");
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export interface GanRobotStatus {
-  movesRemaining: number;
-}
-
-interface GanRobotOptions {
-  xAngle: boolean;
-  singleMoveFixHack: boolean;
-  bufferQueue: number;
-  postSleep: number;
-}
-
-export class GanRobot extends EventTarget {
-  experimentalDebugOnSend: ((alg: Alg) => void) | null = null;
-  experimentalDebugLog: typeof console.log = () => {};
-
-  // Because our Bluetooth connection code is set up not to know what kind of device is connecting, we put these options directly on the class.
-  experimentalOptions: GanRobotOptions = {
-    xAngle: false,
-    singleMoveFixHack: false,
-    bufferQueue: 0,
-    postSleep: 0,
-  };
-
-  constructor(
-    _service: BluetoothRemoteGATTService,
-    private server: BluetoothRemoteGATTServer,
-    device: BluetoothDevice,
-    private statusCharacteristic: BluetoothRemoteGATTCharacteristic,
-    private moveCharacteristic: BluetoothRemoteGATTCharacteristic,
-  ) {
-    super();
-    device.addEventListener(
-      "gattserverdisconnected",
-      this.onDisconnect.bind(this),
-    );
-  }
-
-  // We have to perform async operations before we call the constructor.
-  static async connect(
-    server: BluetoothRemoteGATTServer,
-    device: BluetoothDevice,
-  ) {
-    const ganTimerService = await server.getPrimaryService(
-      UUIDs.ganRobotService,
-    );
-    const statusCharacteristic = await ganTimerService.getCharacteristic(
-      UUIDs.statusCharacteristic,
-    );
-    const moveCharacteristic = await ganTimerService.getCharacteristic(
-      UUIDs.moveCharacteristic,
-    );
-    const timer = new GanRobot(
-      ganTimerService,
-      server,
-      device,
-      statusCharacteristic,
-      moveCharacteristic,
-    );
-    return timer;
-  }
-
-  public name(): string | undefined {
-    return this.server.device.name;
-  }
-
-  disconnect(): void {
-    this.server.disconnect();
-  }
-
-  onDisconnect(): void {
-    this.dispatchEvent(new CustomEvent("disconnect"));
-  }
-
-  private moveToNibble(move: Move): number {
-    const nibble =
-      (this.experimentalOptions.xAngle ? moveMapX : moveMap)[move.toString()] ??
-      null;
-    if (nibble === null) {
-      throwInvalidMove(move);
-    }
-    return nibble;
-  }
-
-  private async writeNibbles(nibbles: number[]): Promise<void> {
-    if (nibbles.length > MAX_NIBBLES_PER_WRITE) {
-      throw new Error(
-        `Can only write ${MAX_NIBBLES_PER_WRITE} nibbles at a time!`,
-      );
-    }
-    // const byteLength = Math.ceil(nibbles.length / 2);
-    const bytes = new Uint8Array(18);
-    let i: number;
-    for (i = 0; i < nibbles.length; i++) {
-      const byteIdx = Math.floor(i / 2);
-      bytes[byteIdx] += nibbles[i];
-      if (i % 2 === 0) {
-        bytes[byteIdx] *= 0x10;
-      }
-    }
-    if (nibbles.length % 2 === 1) {
-      bytes[Math.ceil(nibbles.length / 2) - 1] += 0xf;
-    }
-    for (let i = Math.ceil(nibbles.length / 2); i < 18; i++) {
-      bytes[i] = 0xff;
-    }
-    let sleepDuration = 0;
-    for (const nibble of nibbles) {
-      sleepDuration += nibbleDuration(nibble);
-    }
-    this.experimentalDebugLog("WRITING:", buf2hex(bytes));
-    await this.moveCharacteristic.writeValue(bytes);
-    await sleep(sleepDuration * 0.75);
-    while ((await this.getStatus()).movesRemaining > 0) {
-      // repeat
-    }
-    await sleep(this.experimentalOptions.postSleep);
-  }
-
-  private async getStatus(): Promise<GanRobotStatus> {
-    const statusBytes = new Uint8Array(
-      (await this.statusCharacteristic.readValue()).buffer,
-    );
-    this.experimentalDebugLog("moves remaining:", statusBytes[0]);
-    return {
-      movesRemaining: statusBytes[0],
-    };
-  }
-
-  locked: boolean = false;
-  processQueue(): void {}
-
-  private moveQueue: Alg = new Alg();
-  // TODO: Don't let this resolve until the move is done?
-  private async queueMoves(moves: Alg): Promise<void> {
-    this.moveQueue = this.moveQueue
-      .concat(moves)
-      .simplify({ collapseMoves: true, quantumMoveOrder: (_) => 4 });
-    if (!this.locked) {
-      // TODO: We're currently iterating over units instead of leaves to avoid "zip bomps".
-      try {
-        this.locked = true;
-        if (this.moveQueue.experimentalNumUnits() === 1) {
-          await sleep(this.experimentalOptions.bufferQueue);
-        }
-        // await this.writeNibbles([0xf, 0xf]);
-        while (this.moveQueue.experimentalNumUnits() > 0) {
-          let units = Array.from(this.moveQueue.units());
-          if (
-            this.experimentalOptions.singleMoveFixHack &&
-            units.length === 1
-          ) {
-            const move = units[0] as Move;
-            if (move.amount === 2) {
-              units = [
-                move.modified({ amount: 1 }),
-                move.modified({ amount: 1 }),
-              ];
-            } else {
-              units = [
-                move.modified({ amount: -move.amount }),
-                move.modified({ amount: 2 }),
-              ];
-            }
-          }
-          const moves = units.splice(0, MAX_NIBBLES_PER_WRITE);
-          const nibbles: number[] = moves.map(this.moveToNibble.bind(this));
-          const sending = new Alg(moves);
-          this.experimentalDebugLog("SENDING", sending.toString());
-          if (this.experimentalDebugOnSend) {
-            this.experimentalDebugOnSend(sending);
-          }
-          const write = this.writeNibbles(nibbles);
-          this.moveQueue = new Alg(units);
-          await write;
-        }
-      } finally {
-        this.locked = false;
-      }
-    }
-  }
-
-  async applyMoves(moves: Iterable<Move>): Promise<void> {
-    // const nibbles: number[] = [];
-    for (const move of moves) {
-      const str = move.toString();
-      if (str in (this.experimentalOptions.xAngle ? moveMapX : moveMap)) {
-        await this.queueMoves(new Alg([move]));
-      } else if (
-        move.family === (this.experimentalOptions.xAngle ? "B" : "U")
-      ) {
-        // We purposely send just the swap, so that U2 will get coalesced
-        await Promise.all([
-          this.queueMoves(
-            this.experimentalOptions.xAngle ? F_B_SWAP : U_D_SWAP,
-          ),
-          this.queueMoves(
-            new Alg([
-              move.modified({
-                family: this.experimentalOptions.xAngle ? "F" : "D",
-              }),
-            ]).concat(
-              this.experimentalOptions.xAngle ? F_B_UNSWAP : U_D_UNSWAP,
-            ),
-          ),
-        ]);
-      }
-    }
-  }
-}
-
-// // TODO: Move this into a factory?
-export const ganTimerConfig: BluetoothConfig<GanRobot> = {
-  connect: GanRobot.connect.bind(GanRobot),
-  prefixes: ["GAN"],
-  filters: [{ namePrefix: "GAN" }],
-  optionalServices: [UUIDs.ganRobotService],
-};

package/src/cubing/bluetooth/smart-robot/index.ts

@@ -1,13 +0,0 @@
-import { bluetoothConnect, BluetoothConnectOptions } from "../connect";
-import type { BluetoothConfig } from "../smart-puzzle/bluetooth-puzzle";
-import { GanRobot, ganTimerConfig } from "./GanRobot";
-
-export type BluetoothRobot = GanRobot; // TODO
-
-const smartRobotConfigs: BluetoothConfig<BluetoothRobot>[] = [ganTimerConfig];
-
-export async function connectSmartRobot(
-  options?: BluetoothConnectOptions,
-): Promise<BluetoothRobot> {
-  return bluetoothConnect<BluetoothRobot>(smartRobotConfigs, options);
-}

package/src/cubing/bluetooth/smart-timer/GanTimer.ts

@@ -1,141 +0,0 @@
-import type { MillisecondTimestamp } from "../../twisty/controllers/AnimationTypes";
-import type { BluetoothConfig } from "../smart-puzzle/bluetooth-puzzle";
-
-// TODO: Short IDs
-const UUIDs = {
-  ganTimerService: "0000fff0-0000-1000-8000-00805f9b34fb",
-  timeCharacteristic: "0000fff2-0000-1000-8000-00805f9b34fb",
-};
-
-interface GanTimerDetail {
-  currentTime: MillisecondTimestamp;
-  latestTimes: [
-    MillisecondTimestamp,
-    MillisecondTimestamp,
-    MillisecondTimestamp,
-  ];
-}
-
-export class GanTimer extends EventTarget {
-  private polling = false;
-  private previousDetail: GanTimerDetail | null = null;
-
-  constructor(
-    _service: BluetoothRemoteGATTService,
-    private server: BluetoothRemoteGATTServer,
-    device: BluetoothDevice,
-    private timeCharacteristic: BluetoothRemoteGATTCharacteristic,
-  ) {
-    super();
-    this.startPolling();
-    console.log(server);
-    device.addEventListener(
-      "gattserverdisconnected",
-      this.onDisconnect.bind(this),
-    );
-  }
-
-  // We have to perform async operations before we call the constructor.
-  static async connect(
-    server: BluetoothRemoteGATTServer,
-    device: BluetoothDevice,
-  ) {
-    const ganTimerService = await server.getPrimaryService(
-      UUIDs.ganTimerService,
-    );
-    console.log("Service:", ganTimerService);
-    const timeCharacteristic = await ganTimerService.getCharacteristic(
-      UUIDs.timeCharacteristic,
-    );
-    console.log("Characteristic:", timeCharacteristic);
-    const timer = new GanTimer(
-      ganTimerService,
-      server,
-      device,
-      timeCharacteristic,
-    );
-    return timer;
-  }
-
-  disconnect(): void {
-    this.server.disconnect();
-  }
-
-  async poll() {
-    if (!this.polling) {
-      return;
-    }
-    const value = await this.getTimeCharacteristic();
-
-    const detail: GanTimerDetail = {
-      currentTime: this.decodeTimeMs(value.slice(0, 4)),
-      latestTimes: [
-        this.decodeTimeMs(value.slice(4, 8)),
-        this.decodeTimeMs(value.slice(8, 12)),
-        this.decodeTimeMs(value.slice(12, 16)),
-      ],
-    };
-
-    if (detail.currentTime === 0) {
-      if (this.previousDetail && this.previousDetail.currentTime !== 0) {
-        this.dispatchEvent(new CustomEvent("reset"));
-      }
-    }
-
-    if (detail.currentTime !== 0 && this.previousDetail) {
-      if (this.previousDetail.currentTime === 0) {
-        this.dispatchEvent(new CustomEvent("start"));
-      }
-
-      if (detail.currentTime !== this.previousDetail.currentTime) {
-        this.dispatchEvent(new CustomEvent("update", { detail }));
-
-        if (
-          detail.currentTime === detail.latestTimes[0] &&
-          detail.latestTimes[1] === this.previousDetail.latestTimes[0] &&
-          detail.latestTimes[2] === this.previousDetail.latestTimes[1]
-        ) {
-          this.dispatchEvent(new CustomEvent("stop", { detail }));
-        }
-      }
-    }
-
-    this.previousDetail = detail;
-
-    this.poll();
-  }
-
-  onDisconnect(): void {
-    this.dispatchEvent(new CustomEvent("disconnect"));
-  }
-
-  async getTimeCharacteristic() {
-    return new Uint8Array((await this.timeCharacteristic.readValue()).buffer);
-  }
-
-  async getTime() {
-    const value = await this.getTimeCharacteristic();
-    return this.decodeTimeMs(value.slice(0, 4));
-  }
-
-  decodeTimeMs(bytes: Uint8Array) {
-    return (bytes[0] * 60 + bytes[1]) * 1000 + bytes[2] + bytes[3] * 256;
-  }
-
-  startPolling() {
-    this.polling = true;
-    this.poll();
-  }
-
-  stopPolling() {
-    this.polling = false;
-  }
-}
-
-// // TODO: Move this into a factory?
-export const ganTimerConfig: BluetoothConfig<GanTimer> = {
-  connect: GanTimer.connect.bind(GanTimer),
-  prefixes: ["GAN"],
-  filters: [{ namePrefix: "GAN" }],
-  optionalServices: [UUIDs.ganTimerService],
-};

package/src/cubing/bluetooth/smart-timer/index.ts

@@ -1,13 +0,0 @@
-import { bluetoothConnect, BluetoothConnectOptions } from "../connect";
-import type { BluetoothConfig } from "../smart-puzzle/bluetooth-puzzle";
-import { GanTimer, ganTimerConfig } from "./GanTimer";
-
-export type BluetoothTimer = GanTimer; // TODO
-
-const smartTimerConfigs: BluetoothConfig<BluetoothTimer>[] = [ganTimerConfig];
-
-export async function connectSmartTimer(
-  options?: BluetoothConnectOptions,
-): Promise<BluetoothTimer> {
-  return bluetoothConnect<BluetoothTimer>(smartTimerConfigs, options);
-}

package/src/cubing/bluetooth/transformer.ts

@@ -1,74 +0,0 @@
-import { Quaternion, Vector3 } from "three";
-import type {
-  MoveEvent,
-  OrientationEvent,
-} from "./smart-puzzle/bluetooth-puzzle";
-
-// TODO: Combine orientation and moves into a single event to handle quaternion remapping.
-export interface StreamTransformer {
-  // Modifies the input.
-  transformMove(moveEvent: MoveEvent): void;
-
-  // Modifies the input.
-  transformOrientation(orientationEvent: OrientationEvent): void;
-}
-
-function maxAxis(v: Vector3): string {
-  const maxVal = Math.max(Math.abs(v.x), Math.abs(v.y), Math.abs(v.z));
-  switch (maxVal) {
-    case v.x:
-      return "x";
-    case -v.x:
-      return "-x";
-    case v.y:
-      return "y";
-    case -v.y:
-      return "-y";
-    case v.z:
-      return "z";
-    case -v.z:
-      return "-z";
-    default:
-      throw new Error("Uh-oh.");
-  }
-}
-
-const s2 = Math.sqrt(0.5);
-
-const m: { [s: string]: Quaternion } = {
-  "y z": new Quaternion(0, 0, 0, 1),
-  "-z y": new Quaternion(s2, 0, 0, s2),
-  "x z": new Quaternion(0, 0, -s2, s2),
-  "-x z": new Quaternion(0, 0, s2, s2),
-};
-
-export class BasicRotationTransformer implements StreamTransformer {
-  // private reorientQuat = new Quaternion();
-
-  public transformMove(_moveEvent: MoveEvent): void {
-    // Nothing to do.
-  }
-
-  public transformOrientation(orientationEvent: OrientationEvent): void {
-    const { x, y, z, w } = orientationEvent.quaternion;
-    const quat = new Quaternion(x, y, z, w);
-
-    const U = new Vector3(0, 1, 0);
-    const F = new Vector3(0, 0, 1);
-    const maxU = maxAxis(U.applyQuaternion(quat));
-    const maxF = maxAxis(F.applyQuaternion(quat));
-
-    const oriQuat = m[`${maxU} ${maxF}`] || m["y z"];
-
-    console.log(quat);
-    console.log(oriQuat);
-    const q2 = quat.premultiply(oriQuat);
-
-    // console.log(maxAxis(U.applyQuaternion(quat)), maxAxis(F.applyQuaternion(quat)));
-    console.log(q2);
-
-    orientationEvent.quaternion = quat;
-
-    console.log(orientationEvent.quaternion);
-  }
-}

package/src/cubing/esm-test-worker.js

@@ -1,5 +0,0 @@
-// This should be in the `solve` folder.
-// But due to `esbuild` chunking, we have to put it in the root folder.
-// Remove this file once https://github.com/evanw/esbuild/issues/312 is implemented.
-
-import "./search/esm-test-worker";

package/src/cubing/kpuzzle/3x3x3/3x3x3.kpuzzle.json.spec.ts

@@ -1,40 +0,0 @@
-import { Alg } from "../../alg";
-import { KPuzzle } from "../kpuzzle";
-import { cube3x3x3KPuzzle } from "./3x3x3.kpuzzle.json";
-
-function transformationForAlg(alg: string | Alg) {
-  const kpuzzle = new KPuzzle(cube3x3x3KPuzzle);
-  kpuzzle.applyAlg(new Alg(alg));
-  return kpuzzle.state;
-}
-
-describe("3x3x3 definition", () => {
-  it("should have consistent moves", () => {
-    expect(transformationForAlg("r")).not.toEqual(transformationForAlg("R M"));
-
-    expect(transformationForAlg("u")).toEqual(transformationForAlg("U E'"));
-    expect(transformationForAlg("l")).toEqual(transformationForAlg("L M"));
-    expect(transformationForAlg("f")).toEqual(transformationForAlg("F S"));
-    expect(transformationForAlg("r")).toEqual(transformationForAlg("R M'"));
-    expect(transformationForAlg("b")).toEqual(transformationForAlg("B S'"));
-    expect(transformationForAlg("d")).toEqual(transformationForAlg("D E"));
-
-    expect(transformationForAlg("u")).toEqual(transformationForAlg("Uw"));
-    expect(transformationForAlg("l")).toEqual(transformationForAlg("Lw"));
-    expect(transformationForAlg("f")).toEqual(transformationForAlg("Fw"));
-    expect(transformationForAlg("r")).toEqual(transformationForAlg("Rw"));
-    expect(transformationForAlg("b")).toEqual(transformationForAlg("Bw"));
-    expect(transformationForAlg("d")).toEqual(transformationForAlg("Dw"));
-
-    expect(transformationForAlg("x")).toEqual(transformationForAlg("R M' L'"));
-    expect(transformationForAlg("y")).toEqual(transformationForAlg("U E' D'"));
-    expect(transformationForAlg("z")).toEqual(transformationForAlg("F S B'"));
-
-    expect(transformationForAlg("Uv")).toEqual(transformationForAlg("y"));
-    expect(transformationForAlg("Lv")).toEqual(transformationForAlg("x'"));
-    expect(transformationForAlg("Fv")).toEqual(transformationForAlg("z"));
-    expect(transformationForAlg("Rv")).toEqual(transformationForAlg("x"));
-    expect(transformationForAlg("Bv")).toEqual(transformationForAlg("z'"));
-    expect(transformationForAlg("Dv")).toEqual(transformationForAlg("y'"));
-  });
-});