anchor.diff:                          then (Command (IndexedCommand (RegularMenuShow, ally.CharacterState.PartyIndex)) :: commands, model)
                           else (commands, model))
                           ([], model)
  -                        (BattleDispatcher.getAllies model)
  +                        (getAllies model)
                   let (enemySignals, model) =
                       List.fold (fun (commands, model) enemy ->
                           let enemyIndex = EnemyIndex enemy.CharacterState.PartyIndex
  -                        let allies = BattleDispatcher.getAllies model
  +                        let allies = getAllies model
                           let allyIndex = (Random ()).Next allies.Length
                           let attack = { Action = Attack; Source = enemyIndex; TargetOpt = Some (AllyIndex allyIndex) }
                           if enemy.ActionTime = Constants.Battle.ActionTime then
  
positive.code:                             (Message (ResetCharacterM enemyIndex) :: commands, model)
                          else (commands, model))
                          ([], model)
                          (BattleDispatcher.getEnemies model)
                  let advanceCharactersSignal = Message AdvanceCharactersM
                  let signals = advanceCharactersSignal :: enemySignals @ allySignals
                  withSigs model signals
  
          static member tickRunning time battleRunning model =
              match battleRunning.CurrentCommandOpt with
              | Some currentCommand -> BattleDispatcher.tickCurrentCommand time currentCommand battleRunning model
              | None -> BattleDispatcher.tickNoCommand time battleRunning model
  
          static member tickCease time timeStart outcome (model : BattleModel) =
              let timeLocal = time - timeStart
              match timeLocal with
              | 0L -> withMsg model (CelebrateCharactersM outcome)
              | _ -> just model
  
          static member tick time (model : BattleModel) =
              let (model, sigs) =
                  match model.BattleState with
                  | BattleReady timeStart -> BattleDispatcher.tickReady time timeStart model
                  | BattleRunning battleRunning -> BattleDispatcher.tickRunning time battleRunning model
                  | BattleCease (outcome, timeStart) -> BattleDispatcher.tickCease time timeStart outcome model
              (model, sigs)
  
          static member tickWorld (model : BattleModel) world =
              BattleDispatcher.tick (World.getTickTime world) model
  
          static member inputBindings index =
              let regularMenu = Simulants.RegularMenu index
              let specialMenu = Simulants.SpecialMenu index
              let itemMenu = Simulants.ItemMenu index
  
negative.code:                     withSig model signal
                  | None ->
                      let (model, signal2) =
                          let allies = getAllies model
                          let enemies = getEnemies model
                          if Seq.forall (fun character -> character.CharacterState.IsWounded) allies
                          then tick time { model with BattleState = BattleCease (false, time) } // tick for frame 0
                          elif Seq.forall (fun character -> character.CharacterState.IsWounded) enemies
                          then tick time { model with BattleState = BattleCease (true, time) } // tick for frame 0
                          else just { model with BattleState = BattleRunning battleRunning }
                      withSig model (signal + signal2)
  
          and tickNoCommand time battleRunning model =
              match battleRunning.ActionQueue with
              | Queue.Cons (currentCommand, nextCommands) ->
                  let command = CurrentCommand.make time currentCommand
                  let model = { model with BattleState = BattleRunning { battleRunning with CurrentCommandOpt = Some command; ActionQueue = nextCommands }}
                  tick time model // tick for frame 0
              | Queue.Nil ->
                  let (allySignals, model) =
                      List.fold (fun (commands, model) ally ->
  