cubing 0.22.0 → 0.24.0-pre2

package/src/cubing/twisty/controllers/indexer/simultaneous-moves/SimultaneousMoveIndexer.ts

@@ -1,181 +0,0 @@
-import { Alg, Move } from "../../../../alg";
-import type {
-  PuzzleWrapper,
-  State,
-} from "../../../views/3D/puzzles/KPuzzleWrapper";
-import {
-  Direction,
-  Duration,
-  PuzzlePosition,
-  Timestamp,
-} from "../../AnimationTypes";
-import type { AlgIndexer } from "../AlgIndexer";
-import { AnimatedLeafUnit, AnimLeafWithRange, simulMoves } from "./simul-moves";
-
-const demos: Record<string, AnimLeafWithRange[]> = {
-  "y' y' U' E D R2 r2 F2 B2 U E D' R2 L2' z2 S2 U U D D S2 F2' B2": [
-    { animLeaf: new Move("y", -1), start: 0, end: 1000 },
-    { animLeaf: new Move("y", -1), start: 1000, end: 2000 },
-    { animLeaf: new Move("U", -1), start: 1000, end: 1600 },
-    { animLeaf: new Move("E", 1), start: 1200, end: 1800 },
-    { animLeaf: new Move("D"), start: 1400, end: 2000 },
-    { animLeaf: new Move("R", 2), start: 2000, end: 3500 },
-    { animLeaf: new Move("r", 2), start: 2000, end: 3500 },
-    { animLeaf: new Move("F", 2), start: 3500, end: 4200 },
-    { animLeaf: new Move("B", 2), start: 3800, end: 4500 },
-    { animLeaf: new Move("U", 1), start: 4500, end: 5500 },
-    { animLeaf: new Move("E", 1), start: 4500, end: 5500 },
-    { animLeaf: new Move("D", -1), start: 4500, end: 5500 },
-    { animLeaf: new Move("R", 2), start: 5500, end: 6500 },
-    { animLeaf: new Move("L", -2), start: 5500, end: 6500 },
-    { animLeaf: new Move("z", 2), start: 5500, end: 6500 },
-    { animLeaf: new Move("S", 2), start: 6500, end: 7500 },
-    { animLeaf: new Move("U"), start: 7500, end: 8000 },
-    { animLeaf: new Move("U"), start: 8000, end: 8500 },
-    { animLeaf: new Move("D"), start: 7750, end: 8250 },
-    { animLeaf: new Move("D"), start: 8250, end: 8750 },
-    { animLeaf: new Move("S", 2), start: 8750, end: 9250 },
-    { animLeaf: new Move("F", -2), start: 8750, end: 10000 },
-    { animLeaf: new Move("B", 2), start: 8750, end: 10000 },
-  ],
-  "M' R' U' D' M R": [
-    { animLeaf: new Move("M", -1), start: 0, end: 1000 },
-    { animLeaf: new Move("R", -1), start: 0, end: 1000 },
-    { animLeaf: new Move("U", -1), start: 1000, end: 2000 },
-    { animLeaf: new Move("D", -1), start: 1000, end: 2000 },
-    { animLeaf: new Move("M"), start: 2000, end: 3000 },
-    { animLeaf: new Move("R"), start: 2000, end: 3000 },
-  ],
-  "U' E' r E r2' E r U E": [
-    { animLeaf: new Move("U", -1), start: 0, end: 1000 },
-    { animLeaf: new Move("E", -1), start: 0, end: 1000 },
-    { animLeaf: new Move("r"), start: 1000, end: 2500 },
-    { animLeaf: new Move("E"), start: 2500, end: 3500 },
-    { animLeaf: new Move("r", -2), start: 3500, end: 5000 },
-    { animLeaf: new Move("E"), start: 5000, end: 6000 },
-    { animLeaf: new Move("r"), start: 6000, end: 7000 },
-    { animLeaf: new Move("U"), start: 7000, end: 8000 },
-    { animLeaf: new Move("E"), start: 7000, end: 8000 },
-  ],
-};
-
-export class SimultaneousMoveIndexer<P extends PuzzleWrapper>
-  implements AlgIndexer<P>
-{
-  private animLeaves: AnimLeafWithRange[];
-  // TODO: Allow custom `durationFn`.
-
-  constructor(private puzzle: P, alg: Alg) {
-    this.animLeaves = demos[alg.toString()] ?? simulMoves(alg);
-    // TODO: Avoid assuming all base moves are block moves.
-  }
-
-  public getAnimLeaf(index: number): AnimatedLeafUnit | null {
-    return (
-      this.animLeaves[Math.min(index, this.animLeaves.length - 1)]?.animLeaf ??
-      null
-    );
-  }
-
-  private getAnimLeafWithRange(index: number): AnimLeafWithRange {
-    return this.animLeaves[Math.min(index, this.animLeaves.length - 1)];
-  }
-
-  public indexToMoveStartTimestamp(index: number): Timestamp {
-    let start = 0;
-    if (this.animLeaves.length > 0) {
-      start =
-        this.animLeaves[Math.min(index, this.animLeaves.length - 1)].start;
-    }
-    return start;
-  }
-
-  public timestampToIndex(timestamp: Timestamp): number {
-    let i = 0;
-    for (i = 0; i < this.animLeaves.length; i++) {
-      if (this.animLeaves[i].start >= timestamp) {
-        return Math.max(0, i - 1);
-      }
-    }
-    return Math.max(0, i - 1);
-  }
-
-  public timestampToPosition(
-    timestamp: Timestamp,
-    startTransformation?: State<P>,
-  ): PuzzlePosition {
-    const position: PuzzlePosition = {
-      state: startTransformation ?? (this.puzzle.identity() as any),
-      movesInProgress: [],
-    };
-    for (const leafWithRange of this.animLeaves) {
-      if (leafWithRange.end <= timestamp) {
-        const move = leafWithRange.animLeaf.as(Move);
-        if (move !== null) {
-          position.state = this.puzzle.combine(
-            position.state,
-            this.puzzle.stateFromMove(move),
-          ) as any;
-        }
-      } else if (
-        leafWithRange.start < timestamp &&
-        timestamp < leafWithRange.end
-      ) {
-        const move = leafWithRange.animLeaf.as(Move);
-        if (move !== null) {
-          position.movesInProgress.push({
-            move: move,
-            direction: Direction.Forwards,
-            fraction:
-              (timestamp - leafWithRange.start) /
-              (leafWithRange.end - leafWithRange.start),
-          });
-        }
-      } else if (timestamp < leafWithRange.start) {
-        continue;
-      }
-    }
-    return position;
-  }
-
-  public stateAtIndex(index: number, startTransformation?: State<P>): State<P> {
-    let state = startTransformation ?? this.puzzle.startState();
-    for (let i = 0; i < this.animLeaves.length && i < index; i++) {
-      const leafWithRange = this.animLeaves[i];
-      const move = leafWithRange.animLeaf.as(Move);
-      if (move !== null) {
-        state = this.puzzle.combine(state, this.puzzle.stateFromMove(move));
-      }
-    }
-    return state;
-  }
-
-  public transformAtIndex(index: number): State<P> {
-    let state = this.puzzle.identity();
-    for (const leafWithRange of this.animLeaves.slice(0, index)) {
-      const move = leafWithRange.animLeaf.as(Move);
-      if (move !== null) {
-        state = this.puzzle.combine(state, this.puzzle.stateFromMove(move));
-      }
-    }
-    return state;
-  }
-
-  public algDuration(): Duration {
-    let max = 0;
-    for (const leafWithRange of this.animLeaves) {
-      max = Math.max(max, leafWithRange.end);
-    }
-    return max;
-  }
-
-  public numAnimatedLeaves(): number {
-    // TODO: Cache internally once performance matters.
-    return this.animLeaves.length;
-  }
-
-  public moveDuration(index: number): number {
-    const move = this.getAnimLeafWithRange(index);
-    return move.end - move.start;
-  }
-}

package/src/cubing/twisty/controllers/indexer/simultaneous-moves/SimultaneousMoveIndexerV2.ts

@@ -1,243 +0,0 @@
-import { Alg, Move } from "../../../../alg";
-import type {
-  PuzzleWrapper,
-  State,
-} from "../../../views/3D/puzzles/KPuzzleWrapper";
-import {
-  Direction,
-  Duration,
-  PuzzlePosition,
-  Timestamp,
-} from "../../AnimationTypes";
-import type { AlgIndexer, CurrentMove, CurrentMoveInfo } from "../AlgIndexer";
-import { AnimatedLeafUnit, AnimLeafWithRange, simulMoves } from "./simul-moves";
-
-const demos: Record<string, AnimLeafWithRange[]> = {
-  "y' y' U' E D R2 r2 F2 B2 U E D' R2 L2' z2 S2 U U D D S2 F2' B2": [
-    { animLeaf: new Move("y", -1), start: 0, end: 1000 },
-    { animLeaf: new Move("y", -1), start: 1000, end: 2000 },
-    { animLeaf: new Move("U", -1), start: 1000, end: 1600 },
-    { animLeaf: new Move("E", 1), start: 1200, end: 1800 },
-    { animLeaf: new Move("D"), start: 1400, end: 2000 },
-    { animLeaf: new Move("R", 2), start: 2000, end: 3500 },
-    { animLeaf: new Move("r", 2), start: 2000, end: 3500 },
-    { animLeaf: new Move("F", 2), start: 3500, end: 4200 },
-    { animLeaf: new Move("B", 2), start: 3800, end: 4500 },
-    { animLeaf: new Move("U", 1), start: 4500, end: 5500 },
-    { animLeaf: new Move("E", 1), start: 4500, end: 5500 },
-    { animLeaf: new Move("D", -1), start: 4500, end: 5500 },
-    { animLeaf: new Move("R", 2), start: 5500, end: 6500 },
-    { animLeaf: new Move("L", -2), start: 5500, end: 6500 },
-    { animLeaf: new Move("z", 2), start: 5500, end: 6500 },
-    { animLeaf: new Move("S", 2), start: 6500, end: 7500 },
-    { animLeaf: new Move("U"), start: 7500, end: 8000 },
-    { animLeaf: new Move("D"), start: 7750, end: 8250 },
-    { animLeaf: new Move("U"), start: 8000, end: 8500 },
-    { animLeaf: new Move("D"), start: 8250, end: 8750 },
-    { animLeaf: new Move("S", 2), start: 8750, end: 9250 },
-    { animLeaf: new Move("F", -2), start: 8750, end: 10000 },
-    { animLeaf: new Move("B", 2), start: 8750, end: 10000 },
-  ],
-  "M' R' U' D' M R": [
-    { animLeaf: new Move("M", -1), start: 0, end: 1000 },
-    { animLeaf: new Move("R", -1), start: 0, end: 1000 },
-    { animLeaf: new Move("U", -1), start: 1000, end: 2000 },
-    { animLeaf: new Move("D", -1), start: 1000, end: 2000 },
-    { animLeaf: new Move("M"), start: 2000, end: 3000 },
-    { animLeaf: new Move("R"), start: 2000, end: 3000 },
-  ],
-  "U' E' r E r2' E r U E": [
-    { animLeaf: new Move("U", -1), start: 0, end: 1000 },
-    { animLeaf: new Move("E", -1), start: 0, end: 1000 },
-    { animLeaf: new Move("r"), start: 1000, end: 2500 },
-    { animLeaf: new Move("E"), start: 2500, end: 3500 },
-    { animLeaf: new Move("r", -2), start: 3500, end: 5000 },
-    { animLeaf: new Move("E"), start: 5000, end: 6000 },
-    { animLeaf: new Move("r"), start: 6000, end: 7000 },
-    { animLeaf: new Move("U"), start: 7000, end: 8000 },
-    { animLeaf: new Move("E"), start: 7000, end: 8000 },
-  ],
-};
-
-export class SimultaneousMoveIndexerV2<P extends PuzzleWrapper>
-  implements AlgIndexer<P>
-{
-  private animLeaves: AnimLeafWithRange[];
-  // TODO: Allow custom `durationFn`.
-
-  constructor(private puzzle: P, alg: Alg) {
-    this.animLeaves = demos[alg.toString()] ?? simulMoves(alg);
-    // TODO: Avoid assuming all base moves are block moves.
-  }
-
-  public getAnimLeaf(index: number): AnimatedLeafUnit | null {
-    return (
-      this.animLeaves[Math.min(index, this.animLeaves.length - 1)]?.animLeaf ??
-      null
-    );
-  }
-
-  private getAnimLeafWithRange(index: number): AnimLeafWithRange {
-    return this.animLeaves[Math.min(index, this.animLeaves.length - 1)];
-  }
-
-  public indexToMoveStartTimestamp(index: number): Timestamp {
-    let start = 0;
-    if (this.animLeaves.length > 0) {
-      start =
-        this.animLeaves[Math.min(index, this.animLeaves.length - 1)].start;
-    }
-    return start;
-  }
-
-  public timestampToIndex(timestamp: Timestamp): number {
-    let i = 0;
-    for (i = 0; i < this.animLeaves.length; i++) {
-      if (this.animLeaves[i].start >= timestamp) {
-        return Math.max(0, i - 1);
-      }
-    }
-    return Math.max(0, i - 1);
-  }
-
-  public timestampToPosition(
-    timestamp: Timestamp,
-    startTransformation?: State<P>,
-  ): PuzzlePosition {
-    const currentMoveInfo = this.currentMoveInfo(timestamp);
-
-    let state = startTransformation ?? this.puzzle.identity();
-    for (const leafWithRange of this.animLeaves.slice(
-      0,
-      currentMoveInfo.stateIndex,
-    )) {
-      const move = leafWithRange.animLeaf.as(Move);
-      if (move !== null) {
-        state = this.puzzle.combine(state, this.puzzle.stateFromMove(move));
-      }
-    }
-
-    return {
-      state: state as any,
-      movesInProgress: currentMoveInfo.currentMoves,
-    };
-  }
-
-  // TODO: Caching
-  public currentMoveInfo(timestamp: Timestamp): CurrentMoveInfo {
-    // The starting timestamp of the earliest active move.
-    let windowEarliestTimestamp = Infinity;
-    for (const leafWithRange of this.animLeaves) {
-      if (leafWithRange.start <= timestamp && leafWithRange.end >= timestamp) {
-        windowEarliestTimestamp = Math.min(
-          windowEarliestTimestamp,
-          leafWithRange.start,
-        );
-      } else if (leafWithRange.start > timestamp) {
-        break;
-      }
-    }
-
-    const currentMoves: CurrentMove[] = [];
-    const movesStarting: CurrentMove[] = [];
-    const movesFinishing: CurrentMove[] = [];
-    const movesFinished: CurrentMove[] = [];
-    let latestStart: number = -Infinity; // TODO: is there a better way to accumulate this?
-    let earliestEnd: number = Infinity; // TODO: is there a better way to accumulate this?
-
-    let stateIndex: number = 0;
-    for (const leafWithRange of this.animLeaves) {
-      if (leafWithRange.end <= windowEarliestTimestamp) {
-        stateIndex++;
-      } else if (leafWithRange.start > timestamp) {
-        break;
-      } else {
-        const move = leafWithRange.animLeaf.as(Move);
-        if (move !== null) {
-          let fraction =
-            (timestamp - leafWithRange.start) /
-            (leafWithRange.end - leafWithRange.start);
-          let moveFinished = false;
-          if (fraction > 1) {
-            fraction = 1;
-            moveFinished = true;
-          }
-          const currentMove = {
-            move: move,
-            direction: Direction.Forwards,
-            fraction: fraction,
-            startTimestamp: leafWithRange.start,
-            endTimestamp: leafWithRange.end,
-          };
-          switch (fraction) {
-            case 0:
-              movesStarting.push(currentMove);
-              break;
-            case 1:
-              // Generalize this to avoid reordering commuting moves.
-              if (moveFinished) {
-                movesFinished.push(currentMove);
-              } else {
-                movesFinishing.push(currentMove);
-              }
-              break;
-            default:
-              currentMoves.push(currentMove);
-              latestStart = Math.max(latestStart, leafWithRange.start);
-              earliestEnd = Math.min(earliestEnd, leafWithRange.end);
-          }
-        }
-      }
-    }
-    return {
-      stateIndex,
-      currentMoves,
-      latestStart,
-      earliestEnd,
-      movesStarting,
-      movesFinishing,
-      movesFinished,
-    };
-  }
-
-  public stateAtIndex(index: number, startTransformation?: State<P>): State<P> {
-    let state = startTransformation ?? this.puzzle.startState();
-    for (let i = 0; i < this.animLeaves.length && i < index; i++) {
-      const leafWithRange = this.animLeaves[i];
-      const move = leafWithRange.animLeaf.as(Move);
-      if (move !== null) {
-        state = this.puzzle.combine(state, this.puzzle.stateFromMove(move));
-      }
-    }
-    return state;
-  }
-
-  public transformAtIndex(index: number): State<P> {
-    let state = this.puzzle.identity();
-    for (const leafWithRange of this.animLeaves.slice(0, index)) {
-      const move = leafWithRange.animLeaf.as(Move);
-      if (move !== null) {
-        state = this.puzzle.combine(state, this.puzzle.stateFromMove(move));
-      }
-    }
-    return state;
-  }
-
-  public algDuration(): Duration {
-    let max = 0;
-    for (const leafWithRange of this.animLeaves) {
-      max = Math.max(max, leafWithRange.end);
-    }
-    return max;
-  }
-
-  public numAnimatedLeaves(): number {
-    // TODO: Cache internally once performance matters.
-    return this.animLeaves.length;
-  }
-
-  public moveDuration(index: number): number {
-    const move = this.getAnimLeafWithRange(index);
-    return move.end - move.start;
-  }
-}

package/src/cubing/twisty/controllers/indexer/simultaneous-moves/simul-moves.ts

@@ -1,193 +0,0 @@
-import {
-  LineComment,
-  Commutator,
-  Conjugate,
-  Pause,
-  TraversalUp,
-  Move,
-  Alg,
-  Grouping,
-  Newline,
-} from "../../../../alg";
-import type { MillisecondTimestamp } from "../../AnimationTypes";
-import { defaultDurationForAmount } from "../AlgDuration";
-
-export type AnimatedLeafUnit = Move | Pause;
-export interface LocalAnimLeavesWithRange {
-  animLeafUnit: AnimatedLeafUnit;
-  msUntilNext: MillisecondTimestamp;
-  duration: MillisecondTimestamp;
-}
-
-export interface AnimLeafWithRange {
-  animLeaf: AnimatedLeafUnit;
-  start: MillisecondTimestamp;
-  end: MillisecondTimestamp;
-}
-
-const axisLookup: Record<string, "x" | "y" | "z"> = {
-  u: "y",
-  l: "x",
-  f: "z",
-  r: "x",
-  b: "z",
-  d: "y",
-  m: "x",
-  e: "y",
-  s: "z",
-  x: "x",
-  y: "y",
-  z: "z",
-};
-
-function isSameAxis(move1: Move, move2: Move): boolean {
-  return (
-    axisLookup[move1.family[0].toLowerCase()] ===
-    axisLookup[move2.family[0].toLowerCase()]
-  );
-}
-
-// TODO: Replace this with an optimized implementation.
-// TODO: Consider `(x U)` and `(U x F)` to be simultaneous.
-export class LocalSimulMoves extends TraversalUp<LocalAnimLeavesWithRange[]> {
-  public traverseAlg(alg: Alg): LocalAnimLeavesWithRange[] {
-    const processed: LocalAnimLeavesWithRange[][] = [];
-    for (const nestedUnit of alg.units()) {
-      processed.push(this.traverseUnit(nestedUnit));
-    }
-    return Array.prototype.concat(...processed) as LocalAnimLeavesWithRange[];
-  }
-
-  public traverseGroupingOnce(alg: Alg): LocalAnimLeavesWithRange[] {
-    if (alg.experimentalIsEmpty()) {
-      return [];
-    }
-
-    for (const unit of alg.units()) {
-      if (!unit.is(Move))
-        // TODO: define the type statically on the class?
-        return this.traverseAlg(alg);
-    }
-
-    const moves = Array.from(alg.units()) as Move[];
-    let maxSimulDur = defaultDurationForAmount(moves[0].amount);
-    for (let i = 0; i < moves.length - 1; i++) {
-      for (let j = 1; j < moves.length; j++) {
-        if (!isSameAxis(moves[i], moves[j])) {
-          return this.traverseAlg(alg);
-        }
-      }
-      maxSimulDur = Math.max(
-        maxSimulDur,
-        defaultDurationForAmount(moves[i].amount),
-      );
-    }
-
-    const localMovesWithRange: LocalAnimLeavesWithRange[] = moves.map(
-      (blockMove): LocalAnimLeavesWithRange => {
-        return {
-          animLeafUnit: blockMove,
-          msUntilNext: 0,
-          duration: maxSimulDur,
-        };
-      },
-    );
-    localMovesWithRange[localMovesWithRange.length - 1].msUntilNext =
-      maxSimulDur;
-    return localMovesWithRange;
-  }
-
-  public traverseGrouping(grouping: Grouping): LocalAnimLeavesWithRange[] {
-    const processed: LocalAnimLeavesWithRange[][] = [];
-
-    const segmentOnce: Alg =
-      grouping.amount > 0 ? grouping.alg : grouping.alg.invert();
-    for (let i = 0; i < Math.abs(grouping.amount); i++) {
-      processed.push(this.traverseGroupingOnce(segmentOnce));
-    }
-    return Array.prototype.concat(...processed) as LocalAnimLeavesWithRange[];
-  }
-
-  public traverseMove(move: Move): LocalAnimLeavesWithRange[] {
-    const duration = defaultDurationForAmount(move.amount);
-    return [
-      {
-        animLeafUnit: move,
-        msUntilNext: duration,
-        duration,
-      },
-    ];
-  }
-
-  public traverseCommutator(
-    commutator: Commutator,
-  ): LocalAnimLeavesWithRange[] {
-    const processed: LocalAnimLeavesWithRange[][] = [];
-    const segmentsOnce: Alg[] = [
-      commutator.A,
-      commutator.B,
-      commutator.A.invert(),
-      commutator.B.invert(),
-    ];
-    for (const segment of segmentsOnce) {
-      processed.push(this.traverseGroupingOnce(segment));
-    }
-    return Array.prototype.concat(...processed) as LocalAnimLeavesWithRange[];
-  }
-
-  public traverseConjugate(conjugate: Conjugate): LocalAnimLeavesWithRange[] {
-    const processed: LocalAnimLeavesWithRange[][] = [];
-    const segmentsOnce: Alg[] = [
-      conjugate.A,
-      conjugate.B,
-      conjugate.A.invert(),
-    ];
-    for (const segment of segmentsOnce) {
-      processed.push(this.traverseGroupingOnce(segment));
-    }
-    return Array.prototype.concat(...processed) as LocalAnimLeavesWithRange[];
-  }
-
-  public traversePause(pause: Pause): LocalAnimLeavesWithRange[] {
-    const duration = defaultDurationForAmount(1);
-    return [
-      {
-        animLeafUnit: pause,
-        msUntilNext: duration, // TODO
-        duration,
-      },
-    ];
-  }
-
-  public traverseNewline(_newline: Newline): LocalAnimLeavesWithRange[] {
-    return [];
-  }
-
-  public traverseLineComment(
-    _comment: LineComment,
-  ): LocalAnimLeavesWithRange[] {
-    return [];
-  }
-}
-
-const localSimulMovesInstance = new LocalSimulMoves();
-
-const localSimulMoves = localSimulMovesInstance.traverseAlg.bind(
-  localSimulMovesInstance,
-) as (a: Alg) => LocalAnimLeavesWithRange[];
-
-export function simulMoves(a: Alg): AnimLeafWithRange[] {
-  let timestamp = 0;
-  const l = localSimulMoves(a).map(
-    (localSimulMove: LocalAnimLeavesWithRange): AnimLeafWithRange => {
-      const leafWithRange = {
-        animLeaf: localSimulMove.animLeafUnit,
-        start: timestamp,
-        end: timestamp + localSimulMove.duration,
-      };
-      timestamp += localSimulMove.msUntilNext;
-      return leafWithRange;
-    },
-  );
-  return l;
-}