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:                     withSig model signal
                  | None ->
                      let (model, signal2) =
                          let allies = BattleDispatcher.getAllies model
                          let enemies = BattleDispatcher.getEnemies model
                          if Seq.forall (fun character -> character.CharacterState.IsWounded) allies
                          then BattleDispatcher.tick time { model with BattleState = BattleCease (false, time) } // tick for frame 0
                          elif Seq.forall (fun character -> character.CharacterState.IsWounded) enemies
                          then BattleDispatcher.tick time { model with BattleState = BattleCease (true, time) } // tick for frame 0
                          else just { model with BattleState = BattleRunning battleRunning }
                      withSig model (signal + signal2)
  
          static member tickNoCommand time battleRunning (model : BattleModel) =
              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 }}
                  BattleDispatcher.tick time model // tick for frame 0
              | Queue.Nil ->
                  let (allySignals, model) =
                      List.fold (fun (commands, model) ally ->
  
negative.code:                 let world = World.hintRenderPackageDisuse Assets.BattlePackage world
                  just (World.hintAudioPackageDisuse Assets.BattlePackage world)
              | ResetCharacter characterIndex ->
                  let character = getCharacter characterIndex model
                  let world =
                      if character.CharacterState.IsAlly then
                          let index = character.CharacterState.PartyIndex
  