cubing 0.20.2 → 0.21.0-pre12

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

@@ -0,0 +1,181 @@
+import { Alg, Move } from "../../../../../alg";
+import type {
+  PuzzleWrapper,
+  State,
+} from "../../../../views/3D/puzzles/KPuzzleWrapper";
+import {
+  Direction,
+  Duration,
+  PuzzlePosition,
+  Timestamp,
+} from "../../cursor/CursorTypes";
+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/old/animation/indexer/simultaneous-moves/SimultaneousMoveIndexerV2.ts

@@ -0,0 +1,243 @@
+import { Alg, Move } from "../../../../../alg";
+import type {
+  PuzzleWrapper,
+  State,
+} from "../../../../views/3D/puzzles/KPuzzleWrapper";
+import {
+  Direction,
+  Duration,
+  PuzzlePosition,
+  Timestamp,
+} from "../../cursor/CursorTypes";
+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/{animation → old/animation}/indexer/simultaneous-moves/simul-moves.ts

@@ -8,18 +8,19 @@ import {
   Alg,
   Grouping,
   Newline,
-} from "../../../../alg";
+} from "../../../../../alg";
 import type { MillisecondTimestamp } from "../../cursor/CursorTypes";
 import { defaultDurationForAmount } from "../AlgDuration";
 
-export interface LocalMoveWithRange {
-  move: Move;
+export type AnimatedLeafUnit = Move | Pause;
+export interface LocalAnimLeavesWithRange {
+  animLeafUnit: AnimatedLeafUnit;
   msUntilNext: MillisecondTimestamp;
   duration: MillisecondTimestamp;
 }
 
-export interface MoveWithRange {
-  move: Move;
+export interface AnimLeafWithRange {
+  animLeaf: AnimatedLeafUnit;
   start: MillisecondTimestamp;
   end: MillisecondTimestamp;
 }
@@ -48,16 +49,16 @@ function isSameAxis(move1: Move, move2: Move): boolean {
 
 // TODO: Replace this with an optimized implementation.
 // TODO: Consider `(x U)` and `(U x F)` to be simultaneous.
-export class LocalSimulMoves extends TraversalUp<LocalMoveWithRange[]> {
-  public traverseAlg(alg: Alg): LocalMoveWithRange[] {
-    const processed: LocalMoveWithRange[][] = [];
+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);
+    return Array.prototype.concat(...processed) as LocalAnimLeavesWithRange[];
   }
 
-  public traverseGroupingOnce(alg: Alg): LocalMoveWithRange[] {
+  public traverseGroupingOnce(alg: Alg): LocalAnimLeavesWithRange[] {
     if (alg.experimentalIsEmpty()) {
       return [];
     }
@@ -82,10 +83,10 @@ export class LocalSimulMoves extends TraversalUp<LocalMoveWithRange[]> {
       );
     }
 
-    const localMovesWithRange: LocalMoveWithRange[] = moves.map(
-      (blockMove): LocalMoveWithRange => {
+    const localMovesWithRange: LocalAnimLeavesWithRange[] = moves.map(
+      (blockMove): LocalAnimLeavesWithRange => {
         return {
-          move: blockMove,
+          animLeafUnit: blockMove,
           msUntilNext: 0,
           duration: maxSimulDur,
         };
@@ -96,30 +97,32 @@ export class LocalSimulMoves extends TraversalUp<LocalMoveWithRange[]> {
     return localMovesWithRange;
   }
 
-  public traverseGrouping(grouping: Grouping): LocalMoveWithRange[] {
-    const processed: LocalMoveWithRange[][] = [];
+  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);
+    return Array.prototype.concat(...processed) as LocalAnimLeavesWithRange[];
   }
 
-  public traverseMove(move: Move): LocalMoveWithRange[] {
+  public traverseMove(move: Move): LocalAnimLeavesWithRange[] {
     const duration = defaultDurationForAmount(move.amount);
     return [
       {
-        move: move,
+        animLeafUnit: move,
         msUntilNext: duration,
         duration,
       },
     ];
   }
 
-  public traverseCommutator(commutator: Commutator): LocalMoveWithRange[] {
-    const processed: LocalMoveWithRange[][] = [];
+  public traverseCommutator(
+    commutator: Commutator,
+  ): LocalAnimLeavesWithRange[] {
+    const processed: LocalAnimLeavesWithRange[][] = [];
     const segmentsOnce: Alg[] = [
       commutator.A,
       commutator.B,
@@ -129,11 +132,11 @@ export class LocalSimulMoves extends TraversalUp<LocalMoveWithRange[]> {
     for (const segment of segmentsOnce) {
       processed.push(this.traverseGroupingOnce(segment));
     }
-    return Array.prototype.concat(...processed);
+    return Array.prototype.concat(...processed) as LocalAnimLeavesWithRange[];
   }
 
-  public traverseConjugate(conjugate: Conjugate): LocalMoveWithRange[] {
-    const processed: LocalMoveWithRange[][] = [];
+  public traverseConjugate(conjugate: Conjugate): LocalAnimLeavesWithRange[] {
+    const processed: LocalAnimLeavesWithRange[][] = [];
     const segmentsOnce: Alg[] = [
       conjugate.A,
       conjugate.B,
@@ -142,18 +145,27 @@ export class LocalSimulMoves extends TraversalUp<LocalMoveWithRange[]> {
     for (const segment of segmentsOnce) {
       processed.push(this.traverseGroupingOnce(segment));
     }
-    return Array.prototype.concat(...processed);
+    return Array.prototype.concat(...processed) as LocalAnimLeavesWithRange[];
   }
 
-  public traversePause(_pause: Pause): LocalMoveWithRange[] {
-    return [];
+  public traversePause(pause: Pause): LocalAnimLeavesWithRange[] {
+    const duration = defaultDurationForAmount(1);
+    return [
+      {
+        animLeafUnit: pause,
+        msUntilNext: duration, // TODO
+        duration,
+      },
+    ];
   }
 
-  public traverseNewline(_newline: Newline): LocalMoveWithRange[] {
+  public traverseNewline(_newline: Newline): LocalAnimLeavesWithRange[] {
     return [];
   }
 
-  public traverseLineComment(_comment: LineComment): LocalMoveWithRange[] {
+  public traverseLineComment(
+    _comment: LineComment,
+  ): LocalAnimLeavesWithRange[] {
     return [];
   }
 }
@@ -162,19 +174,19 @@ const localSimulMovesInstance = new LocalSimulMoves();
 
 const localSimulMoves = localSimulMovesInstance.traverseAlg.bind(
   localSimulMovesInstance,
-) as (a: Alg) => LocalMoveWithRange[];
+) as (a: Alg) => LocalAnimLeavesWithRange[];
 
-export function simulMoves(a: Alg): MoveWithRange[] {
+export function simulMoves(a: Alg): AnimLeafWithRange[] {
   let timestamp = 0;
   const l = localSimulMoves(a).map(
-    (localSimulMove: LocalMoveWithRange): MoveWithRange => {
-      const moveWithRange = {
-        move: localSimulMove.move,
+    (localSimulMove: LocalAnimLeavesWithRange): AnimLeafWithRange => {
+      const leafWithRange = {
+        animLeaf: localSimulMove.animLeafUnit,
         start: timestamp,
         end: timestamp + localSimulMove.duration,
       };
       timestamp += localSimulMove.msUntilNext;
-      return moveWithRange;
+      return leafWithRange;
     },
   );
   return l;

package/src/cubing/twisty/{animation → old/animation}/indexer/tree/AlgWalker.ts

@@ -10,12 +10,15 @@ import {
   TraversalDownUp,
   TraversalUp,
   Unit,
-} from "../../../../alg";
+} from "../../../../../alg";
 import {
   experimentalDirectedGenerator,
   ExperimentalIterationDirection,
-} from "../../../../alg";
-import type { PuzzleWrapper, State } from "../../../3D/puzzles/KPuzzleWrapper";
+} from "../../../../../alg";
+import type {
+  PuzzleWrapper,
+  State,
+} from "../../../../views/3D/puzzles/KPuzzleWrapper";
 import type { Duration } from "../../cursor/CursorTypes";
 import { AlgDuration, defaultDurationForAmount } from "../AlgDuration";
 

package/src/cubing/twisty/{animation → old/animation}/indexer/tree/TreeAlgIndexer.ts

@@ -1,5 +1,8 @@
-import type { Alg, Move } from "../../../../alg";
-import type { PuzzleWrapper, State } from "../../../3D/puzzles/KPuzzleWrapper";
+import type { Alg, Move } from "../../../../../alg";
+import type {
+  PuzzleWrapper,
+  State,
+} from "../../../../views/3D/puzzles/KPuzzleWrapper";
 import type { Duration, Timestamp } from "../../cursor/CursorTypes";
 import type { AlgIndexer } from "../AlgIndexer";
 import { chunkAlgs } from "./chunkAlgs";
@@ -25,7 +28,7 @@ export class TreeAlgIndexer implements AlgIndexer<PuzzleWrapper> {
     );
   }
 
-  public getMove(index: number): Move | null {
+  public getAnimLeaf(index: number): Move | null {
     // FIXME need to support Pause
     if (this.walker.moveByIndex(index)) {
       if (!this.walker.move) {
@@ -45,14 +48,14 @@ export class TreeAlgIndexer implements AlgIndexer<PuzzleWrapper> {
     if (this.walker.moveByIndex(index) || this.walker.i === index) {
       return this.walker.dur;
     }
-    throw new Error("Out of algorithm: index " + index);
+    throw new Error(`Out of algorithm: index ${index}`);
   }
 
   public indexToMovesInProgress(index: number): Timestamp {
     if (this.walker.moveByIndex(index) || this.walker.i === index) {
       return this.walker.dur;
     }
-    throw new Error("Out of algorithm: index " + index);
+    throw new Error(`Out of algorithm: index ${index}`);
   }
 
   public stateAtIndex(

package/src/cubing/twisty/{animation → old/animation}/indexer/tree/chunkAlgs.ts

@@ -9,8 +9,8 @@ import {
   Pause,
   TraversalUp,
   Unit,
-} from "../../../../alg";
-import { AlgBuilder } from "../../../../alg";
+} from "../../../../../alg";
+import { AlgBuilder } from "../../../../../alg";
 
 const MIN_CHUNKING_THRESHOLD = 16;
 

package/src/cubing/twisty/{animation → old/animation}/stream/timeline-move-calculation-draft.ts

@@ -1,4 +1,4 @@
-import { Move, QuantumMove } from "../../../alg";
+import { Move, QuantumMove } from "../../../../alg";
 import type { Duration, Timestamp } from "../cursor/CursorTypes";
 
 interface Event {
@@ -74,7 +74,7 @@ export function toAxes(
             prev.event.move.innerLayer,
             prev.event.move.outerLayer,
           ),
-          prev.event.move.amount + newEntry.event.move.amount,
+          (prev.event.move.amount as number) + newEntry.event.move.amount,
         );
       } else {
         axes[axes.length - 1].push(newEntry);