www/js/interpreter.ts

@@ -140,26 +140,6 @@ function danceAsLowLevelMoves(moves: Move[], startingVariants: AllVariantsForMov
     if (move.progression) numProgessions++;
   }
 
-  // If there's multiple variants, check if there's fewer that flow into the first move.
-  if (currentVariantMoves.size !== 1) {
-    let newMoves: VariantCollection | undefined;
-    try {
-      newMoves = allVariantsForMove({ move: moves[0], nextMove: moves[1], startingVariants: currentVariants, numProgessions });
-    } catch {
-      newMoves = undefined;
-    }
-    if (newMoves) {
-      const firstMoveVariants = [...newMoves.values()].map(v => v.previousMoveVariant);
-      if (firstMoveVariants.length > 0) {
-        for (const variant of [...currentVariantMoves.keys()]) {
-          if (!firstMoveVariants.includes(variant)) {
-            currentVariantMoves.delete(variant);
-          }
-        }
-      }
-    }
-  }
-
   const res = [...currentVariantMoves.values()].at(-1)!;
   if (currentVariantMoves.size !== 1) {
     res.get(DancerIdentity.OnesRobin)![0].interpreterError = "Expected exactly one variant. Found "
@@ -176,15 +156,12 @@ function danceAsLowLevelMoves(moves: Move[], startingVariants: AllVariantsForMov
         if (!lowLevelMoves[i].endPosition) throw "endPosition is undefined";
         lowLevelMoves[i].endPosition = lowLevelMoves[i + 1].startPosition;
         if (!lowLevelMoves[i].endPosition) throw "endPosition is undefined now";
-        // TODO Exactly what is the StandStill fixup needed for? Can it be handled in other ways? Should it be rotation only?
-        /*
         if (lowLevelMoves[i].movementPattern.kind === SemanticAnimationKind.StandStill) {
           lowLevelMoves[i].startPosition = lowLevelMoves[i].endPosition;
           if (i > 0) {
             lowLevelMoves[i - 1].endPosition = lowLevelMoves[i].startPosition;
           }
         }
-        */
       }
       // If progression isn't detected properly, do nothing.
       if (progressionInSets === 0) {

www/js/interpreterCommon.ts

@@ -349,10 +349,6 @@ export class ShortLinesPosition {
     return this.isLeft() ? Facing.Right : Facing.Left;
   }
 
-  public isToLeftOf(otherPos: ShortLinesPosition): boolean {
-    return this.enumValue < otherPos.enumValue;
-  }
-
   public toString() : string {
     return this.enumValue.toString();
   }
@@ -524,83 +520,3 @@ export function handToDancerToSideInCircleFacingUpOrDown(which: CirclePosition):
       : [Hand.Left, { hand: Hand.Right, to: HandTo.DancerLeft }]
   ]);
 }
-
-export function facingAdjacent(pos: SemanticPosition, otherPos: SemanticPosition): Facing | undefined {
-  if (pos.kind !== otherPos.kind) {
-    return undefined;
-  }
-
-  if (pos.kind === PositionKind.ShortLines) {
-    if (otherPos.kind !== PositionKind.ShortLines) {
-      return undefined;
-    }
-    if ((pos.setOffset ?? 0) !== (otherPos.setOffset ?? 0)) {
-      return undefined;
-    }
-    if ((pos.lineOffset ?? 0) !== (otherPos.lineOffset ?? 0)) {
-      if (pos.which === ShortLinesPosition.FarLeft && otherPos.which === ShortLinesPosition.FarRight
-          && ((pos.lineOffset ?? 0) - 1) === (otherPos.lineOffset ?? 0)) {
-        return Facing.Left;
-      } else if (pos.which === ShortLinesPosition.FarRight && otherPos.which === ShortLinesPosition.FarLeft
-          && ((pos.lineOffset ?? 0) + 1) === (otherPos.lineOffset ?? 0)) {
-        return Facing.Right;
-      } else {
-        return undefined;
-      }
-    }
-
-    if (otherPos.which.isToLeftOf(pos.which)) {
-      return Facing.Left;
-    } else {
-      return Facing.Right;
-    }
-  } else if (pos.kind === PositionKind.Circle) {
-    if (otherPos.kind !== PositionKind.Circle) {
-      return undefined;
-    }
-
-    if ((pos.lineOffset ?? 0) !== (otherPos.lineOffset ?? 0)) {
-      // TODO
-      return undefined;
-    }
-    if ((pos.setOffset ?? 0) !== (otherPos.setOffset ?? 0)) {
-      // TODO
-      return undefined;
-    }
-
-    if (pos.which.leftRightSide() === otherPos.which.leftRightSide()) {
-      if (pos.which.topBottomSide() === otherPos.which.topBottomSide()) {
-        return undefined;
-      }
-
-      if ((pos.lineOffset ?? 0) !== (otherPos.lineOffset ?? 0)) {
-        return undefined;
-      }
-
-      if ((pos.setOffset ?? 0) === (otherPos.setOffset ?? 0)) {
-        return pos.which.facingUpOrDown();
-      } else if (((pos.setOffset ?? 0) + 1) === (otherPos.setOffset ?? 0) && pos.which.isTop()) {
-        return Facing.Up;
-      } else if (((pos.setOffset ?? 0) - 1) === (otherPos.setOffset ?? 0) && !pos.which.isTop()) {
-        return Facing.Down;
-      }
-    } else if (pos.which.topBottomSide() === otherPos.which.topBottomSide()) {
-      if ((pos.setOffset ?? 0) === (otherPos.setOffset ?? 0)) {
-        return undefined;
-      }
-
-      if ((pos.lineOffset ?? 0) !== (otherPos.lineOffset ?? 0)) {
-        return pos.which.facingAcross();
-      } else if (((pos.lineOffset ?? 0) + 1) === (otherPos.lineOffset ?? 0) && pos.which.isLeft()) {
-        return Facing.Left;
-      } else if (((pos.lineOffset ?? 0) - 1) === (otherPos.lineOffset ?? 0) && !pos.which.isLeft()) {
-        return Facing.Right;
-      }
-    } else {
-      // Opposite corners of circle.
-      return undefined;
-    }
-  } else {
-    throw new Error("Unexpected PositionKind: " + otherPos.kind);
-  }
-}

www/js/lowLevelMove.ts

@@ -77,8 +77,6 @@ export type SemanticAnimation = {
 
   // If true, move in close while rotating.
   close: boolean,
-
-  facing?: animation.RotationAnimationFacing,
 } | {
   kind: SemanticAnimationKind.Swing,
 
@@ -294,7 +292,7 @@ function SemanticToSetPosition(semantic: SemanticPosition): DancerSetPosition {
           && (semantic.balance === BalanceWeight.Backward || semantic.balance === BalanceWeight.Forward)) {
           balanceOffset = {
             x: 0,
-            y: Math.sign(position.y) * (
+            y: position.y * (
               semantic.balance === BalanceWeight.Forward
                 ? -balanceAmount
                 : balanceAmount)
@@ -354,9 +352,9 @@ function SemanticToSetPosition(semantic: SemanticPosition): DancerSetPosition {
           case HandTo.DancerRight:
             return OffsetPlus({ x: +1, y: 0 }, balanceHandAdjustment);
           case HandTo.DancerForward:
-            const armLength = yAmount + (semantic.balance === BalanceWeight.Backward ? balanceAmount : semantic.balance === BalanceWeight.Forward ? -balanceAmount : 0);
+            const armLength = yAmount + (semantic.balance === BalanceWeight.Backward ? balanceAmount : 0);
             if (hand === connection.hand) {
-              return { x: 0, y: +armLength };
+              return { x: 0, y: +armLength/2 };
             } else {
               return { x: dancerWidth / 2 * (hand === Hand.Left ? -1 : +1), y: +armLength };
             }
@@ -657,7 +655,7 @@ function animateLowLevelMoveWithoutSlide(move: LowLevelMove): animation.Animatio
                 width: 1,
                 height: 1,
               },
-              facing: move.movementPattern.facing ?? animation.RotationAnimationFacing.Forward,
+              facing: animation.RotationAnimationFacing.Forward,
               closer: move.movementPattern.close ? {
                 transitionBeats: 1,
                 minDistance: 1,

www/js/main.ts

@@ -428,7 +428,7 @@ displaySettingsDiv.appendChild(debugRenderLabel);
 wrapperDiv.appendChild(displaySettingsDiv);
 
 // Default dance is Two Hearts in Time by Isaac Banner. Selected arbitrarily.
-const defaultDanceTitle = "March for Andrea";
+const defaultDanceTitle = "Two Hearts in Time";
 
 const danceList = document.createElement('select');
 for (const [idx, dance] of danceLibrary.dances.entries()) {

www/js/moves/_moveInterpreter.ts

@@ -1,5 +1,5 @@
 import { CoupleRole, DanceRole, DancerIdentity, ExtendedDancerIdentity } from "../danceCommon.js";
-import { CirclePosition, CircleSideOrCenter, DancerDistance, PositionKind, SemanticPosition } from "../interpreterCommon.js";
+import { CirclePosition, CircleSideOrCenter, PositionKind, SemanticPosition } from "../interpreterCommon.js";
 import { Move, chooser_pairz } from "../libfigureMapper.js";
 import { LowLevelMove, SemanticAnimation, SemanticAnimationKind } from "../lowLevelMove.js";
 
@@ -44,25 +44,12 @@ export abstract class SingleVariantMoveInterpreter<T extends MoveInterpreter<N>,
   constructor(moveInterpreter: T, startingPos: SemanticPositionsForAllDancers) {
     this.moveInterpreter = moveInterpreter;
     this.startingPos = startingPos;
-
-    if (!this.allowStartingClose()) {
-      for (const [id, startPos] of this.startingPos) {
-        if (startPos.dancerDistance && startPos.dancerDistance !== DancerDistance.Normal) {
-          throw new Error("Can not start " + this.move.move + " at dancerDistance " + startPos.dancerDistance);
-        }
-      }
-    }
   }
 
   get move() : Move & { move: N } {
     return this.moveInterpreter.move;
   }
 
-  allowStartingClose(): boolean {
-    // Swings can end close, but most moves can't start close, so do this check by default for all moves.
-    return false;
-  }
-
   moveAsLowLevelMoves(): LowLevelMovesForAllDancers {
     throw new Error("You must implement either moveAsLowLevelMoves() or moveAsVariants().");
   }

www/js/moves/balance.ts

@@ -1,101 +1,39 @@
-import { BalanceWeight, Facing, HandConnection, HandTo, PositionKind, facingAdjacent } from "../interpreterCommon.js";
+import { BalanceWeight } from "../interpreterCommon.js";
 import { SemanticAnimationKind } from "../lowLevelMove.js";
-import { Hand } from "../rendererConstants.js";
+import { ISingleVariantMoveInterpreter, LowLevelMovesForAllDancers, MoveInterpreter, MoveInterpreterCtorArgs, SemanticPositionsForAllDancers, SingleVariantMoveInterpreter, moveInterpreters } from "./_moveInterpreter.js";
-import { ISingleVariantMoveInterpreter, LowLevelMovesForAllDancers, MoveInterpreter, MoveInterpreterCtorArgs, SemanticPositionsForAllDancers, SingleVariantMoveInterpreter, Variant, VariantCollection, moveInterpreters } from "./_moveInterpreter.js";
 
 class BalanceSingleVariant extends SingleVariantMoveInterpreter<Balance, "balance"> {
-  private static readonly balanceOptions : [BalanceWeight, BalanceWeight | undefined, Hand | undefined][]= [
+  moveAsLowLevelMoves(): LowLevelMovesForAllDancers {
-    // TODO Any others?
+    return this.handleMove(({ startPos }) => {
-    [BalanceWeight.Forward, undefined, undefined],
+      // TODO Use who to determine facing?
-    [BalanceWeight.Forward, BalanceWeight.Backward, undefined],
+      // TODO Could be left to right, not back and forth?
-    // TODO Should be left/right/inside/outside hands?
+      // TODO How to determine hand... by next move, I guess?
-    [BalanceWeight.Forward, BalanceWeight.Backward, Hand.Left],
-    [BalanceWeight.Forward, BalanceWeight.Backward, Hand.Right],
-    [BalanceWeight.Right, BalanceWeight.Backward, undefined],
-    [BalanceWeight.Right, BalanceWeight.Left, undefined],
-    [BalanceWeight.Left, BalanceWeight.Right, undefined],
-  ];
 
-  moveAsVariants(previousMoveVariant: string): VariantCollection {
+      return this.combine([
-    const res = new Map<string, Variant>();
+        {
-
+          beats: this.moveInterpreter.forwardBeats,
-    for (const [firstWeight, secondWeight, hand] of BalanceSingleVariant.balanceOptions) {
+          endPosition: { ...startPos, balance: BalanceWeight.Forward },
-      // If balancing someone, need to know by which hand.
+          movementPattern: { kind: SemanticAnimationKind.Linear },
-      if ((hand === undefined) !== (this.move.parameters.who === "everyone")) continue;
+        },
-      try {
+        {
-        res.set((firstWeight?.toString() ?? "") + (secondWeight?.toString() ?? "") + (hand === undefined ? "" : hand.toString() + "Hand"), {
+          beats: this.moveInterpreter.backwardBeats,
-          lowLevelMoves: this.moveAsLowLevelMovesWeights(firstWeight, secondWeight, hand),
+          endPosition: { ...startPos, balance: BalanceWeight.Backward },
-          previousMoveVariant
+          movementPattern: { kind: SemanticAnimationKind.Linear },
-        });
+        },
-      }
+      ], startPos);
-      catch { }
+    });
-    }
-
-    return res;
-  }
-
-  moveAsLowLevelMovesWeights(firstWeight?: BalanceWeight, secondWeight?: BalanceWeight, hand?: Hand): LowLevelMovesForAllDancers {
-    if (this.move.parameters.who !== "everyone") {
-      return this.handlePairedMove(this.move.parameters.who, ({ startPos, withPos }) => {
-        // TODO Does this need to support balancing inside/outside hands? If so how to identify them?
-        const hands = hand === undefined ? startPos.hands : new Map<Hand, HandConnection>([[hand, {hand, to: HandTo.DancerForward}]]);
-
-        const facing = facingAdjacent(startPos, withPos);
-        if (facing === undefined) {
-          throw new Error("Not adjacent to paired dancer.");
-        }
-
-        const startingPos = {...startPos, facing, hands};
-
-        return this.combine([
-          {
-            beats: this.moveInterpreter.balancePartBeats,
-            endPosition: { ...startingPos, balance: firstWeight, hands },
-            movementPattern: { kind: SemanticAnimationKind.Linear },
-          },
-          {
-            beats: this.moveInterpreter.balancePartBeats,
-            endPosition: { ...startingPos, balance: secondWeight, hands },
-            movementPattern: { kind: SemanticAnimationKind.Linear },
-          },
-        ], startingPos);
-      });
-    } else {
-      return this.handleMove(({ startPos }) => {
-        // TODO Use who to determine facing?
-        // TODO Could be left to right, not back and forth?
-        // TODO How to determine hand... by next move, I guess?
-        if (startPos.kind === PositionKind.Circle && startPos.facing === Facing.CenterOfCircle) {
-          if (firstWeight === BalanceWeight.Left || firstWeight === BalanceWeight.Right || firstWeight === BalanceWeight.Backward
-            || secondWeight === BalanceWeight.Left || secondWeight === BalanceWeight.Right || secondWeight === BalanceWeight.Backward) {
-            throw new Error("Balancing left or right in a circle is unsupported.");
-          }
-        }
-
-        return this.combine([
-          {
-            beats: this.moveInterpreter.balancePartBeats,
-            endPosition: { ...startPos, balance: firstWeight },
-            movementPattern: { kind: SemanticAnimationKind.Linear },
-          },
-          {
-            beats: this.moveInterpreter.balancePartBeats,
-            endPosition: { ...startPos, balance: secondWeight },
-            movementPattern: { kind: SemanticAnimationKind.Linear },
-          },
-        ], startPos);
-      });
-    }
   }
 }
 
 class Balance extends MoveInterpreter<"balance"> {
-  public readonly balancePartBeats: number;
+  public readonly forwardBeats: number;
+  public readonly backwardBeats: number;
 
   constructor(args: MoveInterpreterCtorArgs<"balance">) {
     super(args);
 
-    this.balancePartBeats = this.move.beats / 2;
+    this.forwardBeats = this.move.beats / 2;
+    this.backwardBeats = this.move.beats - this.forwardBeats;
   }
 
   buildSingleVariantMoveInterpreter(startingPos: SemanticPositionsForAllDancers): ISingleVariantMoveInterpreter {

www/js/moves/balanceTheRing.ts

@@ -1,4 +1,4 @@
-import { BalanceWeight, Facing, HandConnection, HandTo, PositionKind, SemanticPosition, handsInCircle } from "../interpreterCommon.js";
+import { BalanceWeight, Facing, HandConnection, HandTo, PositionKind, SemanticPosition } from "../interpreterCommon.js";
 import { Move } from "../libfigureMapper.js";
 import { LowLevelMove, SemanticAnimationKind } from "../lowLevelMove.js";
 import { Hand } from "../rendererConstants.js";
@@ -11,11 +11,14 @@ export function balanceCircleInAndOut(move: Move, startPos: SemanticPosition, ba
   }
 
   balanceBeats ??= 4;
-  const balancePartBeats = balanceBeats / 2;
+  const balancePartBeats = balanceBeats/2;
 
   const holdingHandsInCircle: SemanticPosition = {...startPos,
     facing: Facing.CenterOfCircle,
-    hands: handsInCircle,
+    hands: new Map<Hand, HandConnection>([
+      [Hand.Left, { hand: Hand.Right, to: HandTo.LeftInCircle }],
+      [Hand.Right, { hand: Hand.Left, to: HandTo.RightInCircle }],
+    ]),
   };
   const circleBalancedIn: SemanticPosition = {...holdingHandsInCircle,
     balance: BalanceWeight.Forward,

www/js/moves/boxTheGnat.ts

@@ -18,10 +18,6 @@ class BoxTheGnatSingleVariant extends SingleVariantMoveInterpreter<BoxTheGnat, t
       const balancePartBeats = balanceBeats / 2;
       const twirlBeats = this.move.beats - balanceBeats;
 
-      if (startPos.hands && startPos.hands.get(Hand.Right) === undefined && startPos.hands.get(Hand.Left)?.hand === Hand.Left) {
-        throw new Error(this.move.move + " shouldn't start with holding left hands. Something went wrong.");
-      }
-
       // TODO Adjust facing?
       const startPosition = { ...startPos, hands: new Map<Hand, HandConnection>([[hand, { hand, to: HandTo.DancerForward }]]) };
 

www/js/moves/butterflyWhirl.ts

@@ -1,4 +1,3 @@
-import { RotationAnimationFacing } from "../animation.js";
 import { Move } from "../libfigureMapper.js";
 import { SemanticAnimationKind } from "../lowLevelMove.js";
 import { Hand } from "../rendererConstants.js";
@@ -7,10 +6,6 @@ import { ISingleVariantMoveInterpreter, LowLevelMovesForAllDancers, MoveInterpre
 const moveName: Move["move"] = "butterfly whirl";
 
 class ButterflyWhirlSingleVariant extends SingleVariantMoveInterpreter<ButterflyWhirl, typeof moveName> {
-  override allowStartingClose(): boolean {
-    return true;
-  }
-
   moveAsLowLevelMoves(): LowLevelMovesForAllDancers {
     return this.handleCircleMove(({ startPos }) => {
       return this.combine([{
@@ -19,10 +14,8 @@ class ButterflyWhirlSingleVariant extends SingleVariantMoveInterpreter<Butterfly
         movementPattern: {
           kind: SemanticAnimationKind.RotateAround,
           around: startPos.which.leftRightSide(),
+          // TODO hand around isn't the same as allemande...
           byHand: startPos.which.isOnLeftLookingAcross() ? Hand.Right : Hand.Left,
-          facing: startPos.which.isOnLeftLookingAcross()
-                    ? RotationAnimationFacing.Forward
-                    : RotationAnimationFacing.Backward,
           close: true,
           minAmount: 360,
         }

www/js/moves/circle.ts

@@ -1,4 +1,4 @@
-import { DancerDistance, Facing, handsInCircle } from "../interpreterCommon.js";
+import { Facing, handsInCircle } from "../interpreterCommon.js";
 import { Move } from "../libfigureMapper.js";
 import { SemanticAnimationKind } from "../lowLevelMove.js";
 import { ISingleVariantMoveInterpreter, LowLevelMovesForAllDancers, MoveInterpreter, SemanticPositionsForAllDancers, SingleVariantMoveInterpreter, moveInterpreters } from "./_moveInterpreter.js";

www/js/moves/downTheHall.ts

@@ -22,9 +22,6 @@ class DownTheHallSingleVariant extends SingleVariantMoveInterpreter<DownTheHall,
     }
     return this.handleMove(({ startPos }) => {
       const startFacing = this.move.parameters.facing === "backward" ? Facing.Up : Facing.Down;
-      if (startPos.facing !== startFacing && (startPos.facing === Facing.Up || startPos.facing === Facing.Down)) {
-        throw new Error("Started facing the wrong direction.");
-      }
       const startWhich: ShortLinesPosition = startPos.kind === PositionKind.ShortLines
         ? startPos.which
         // TODO Is this always the right way to convert circle to short lines?

www/js/moves/petronella.ts

@@ -1,4 +1,4 @@
-import { DancerDistance, Facing, SemanticPosition } from "../interpreterCommon.js";
+import { Facing, SemanticPosition } from "../interpreterCommon.js";
 import { SemanticAnimationKind, LowLevelMove } from "../lowLevelMove.js";
 import { ISingleVariantMoveInterpreter, LowLevelMovesForAllDancers, MoveInterpreter, PartialLowLevelMove, SemanticPositionsForAllDancers, SingleVariantMoveInterpreter, moveInterpreters } from "./_moveInterpreter.js";
 import { balanceCircleInAndOut } from "./balanceTheRing.js";

www/js/moves/rollAway.ts

@@ -9,7 +9,7 @@ const moveName: Move["move"] = "roll away";
 class RollAwaySingleVariant extends SingleVariantMoveInterpreter<RollAway, typeof moveName> {
   moveAsLowLevelMoves(): LowLevelMovesForAllDancers {
     // TODO maybe can roll away in short lines?
-    return this.handleCirclePairedMove(this.move.parameters.whom, ({ id, startPos, withPos }) => {
+    return this.handleCirclePairedMove(this.move.parameters.who, ({ id, startPos, withPos }) => {
       let isRoller: boolean;
       switch (this.move.parameters.who) {
         case "gentlespoons":

www/js/moves/swing.ts

@@ -33,10 +33,6 @@ const swingEndValues: SwingEnd[] = [
 ];
 
 class SwingSingleVariant extends SingleVariantMoveInterpreter<Swing, typeof moveName> {
-  override allowStartingClose(): boolean {
-    return true;
-  }
-
   moveAsVariants(previousMoveVariant: string): VariantCollection {
     const res = new Map<string, Variant>();
 
@@ -208,12 +204,10 @@ class Swing extends MoveInterpreter<typeof moveName> {
             ? 2
             : this.move.beats / 4;
         this.swingBeats = this.move.beats - this.balancePartBeats * 2;
-        break;
       case "meltdown":
         this.balancePartBeats = 0;
         this.meltdownBeats = this.move.beats >= 8 ? 4 : this.move.beats / 2;
         this.swingBeats = this.move.beats - this.meltdownBeats;
-        break;
       default:
         throw new Error ("Unknown swing prefix: " + this.move.parameters.prefix);
     }