anchor.diff:          | ReticlesCancel
   
       and [<NoComparison>] BattleCommand =
  -        | InitializeBattleCmd
  -        | FinalizeBattleCmd
  -        | DestroyCharacterCmd of CharacterIndex
  +        | FadeSong
  +        | InitializeBattle
  +        | FinalizeBattle
           | ResetCharacterCmd of CharacterIndex
  -        | IndexedCommandCmd of IndexedCommand * int
  -        | FadeSongCmd
  +        | DestroyCharacter of CharacterIndex
  +        | IndexedCommand of IndexedCommand * int
   
       and Screen with
   
  
positive.code:                         else just model
                      | WoundCycle ->
                          if CharacterAnimationState.finished time character.CharacterAnimationState
                          then withMsg { model with CurrentCommandOpt = None } (DestroyCharacter characterIndex)
                          else just model
                      | _ -> failwithumf ()
  
          let tickReady time timeStart model =
              let timeLocal = time - timeStart
              match timeLocal with
              | 0L -> withMsg model ReadyCharacters
              | 30L -> withMsg { model with BattleState = BattleRunning } PoiseCharacters
              | _ -> just model
  
          let rec tickCurrentCommand time currentCommand model =
              let timeLocal = time - currentCommand.TimeStart
              match currentCommand.ActionCommand.Action with
              | Attack ->
  
negative.code:                 | BattleCease (outcome, timeStart) -> tickCease time timeStart outcome model
              (model, sigs)
  
          static let battleBindings (battle : Screen) =
              [battle.OutgoingStartEvent =>! FadeSong
               battle.SelectEvent =>! InitializeBattle
               battle.DeselectEvent =>! FinalizeBattle
               battle.UpdateEvent => Tick]
  
          static let allyBindings index =
              let regularMenu = Simulants.RegularMenu index
              let specialMenu = Simulants.SpecialMenu index
              let itemMenu = Simulants.ItemMenu index
              let reticles = Simulants.Reticles index
              [regularMenu.ItemSelectEvent =|>! fun evt -> IndexedCommand (RegularMenuSelect evt.Data, index)
               specialMenu.ItemSelectEvent =|>! fun evt -> IndexedCommand (SpecialMenuSelect evt.Data, index)
               specialMenu.CancelEvent =>! IndexedCommand (RegularMenuShow, index)
               itemMenu.ItemSelectEvent =|>! fun evt -> IndexedCommand (ItemMenuSelect evt.Data, index)
               itemMenu.CancelEvent =>! IndexedCommand (RegularMenuShow, index)
               reticles.TargetSelectEvent =|> fun evt -> ReticlesSelect (evt.Data, AllyIndex index)
               reticles.CancelEvent =>! IndexedCommand (ReticlesCancel, index)]
  
          static let allyPartyBindings allyMax =
              seq { for i in 0 .. allyMax - 1 do yield allyBindings i } |>
              Seq.concat |>
              Seq.toList
  
          static let indexedCommand command index world =
              let ally = Simulants.Ally index
              let regularMenu = Simulants.RegularMenu index
              let specialMenu = Simulants.SpecialMenu index
  