anchor.diff:                  let (allySignalsRev, model) =
                       List.fold (fun (commands, model) ally ->
                           if ally.ActionTime = Constants.Battle.ActionTime
  -                        then (Command (IndexedCommandCmd (RegularMenuShow, ally.CharacterState.PartyIndex)) :: commands, model)
  +                        then (Command (IndexedCommand (RegularMenuShow, ally.CharacterState.PartyIndex)) :: commands, model)
                           else (commands, model))
                           ([], model)
                           (getAllies model)
  
positive.code:                 let world = reticles.SetVisible false world
                  let world = previousMenu.SetVisible true world
                  just (previousMenu.SetCenter (ally.GetCenter world) world)
  
          override this.Content (model, _, _) =
              [Content.layer Simulants.Scene.Name []
  
negative.code:                   ActionQueue = Queue.empty }
               model)
  
          static let getAllies model =
              model.BattleCharacters |> Map.toSeq |> Seq.filter (function (AllyIndex _, _) -> true | _ -> false) |> Seq.map snd |> Seq.toList
  
          static let getEnemies model =
              model.BattleCharacters |> Map.toSeq |> Seq.filter (function (EnemyIndex _, _) -> true | _ -> false) |> Seq.map snd |> Seq.toList
  
          static let updateCharacters3 predicate updater model =
              { model with BattleCharacters = Map.map (fun index character -> if predicate index then updater character else character) model.BattleCharacters }
  
          static let updateCharacters updater model =
              updateCharacters3 tautology updater model
  
          static let updateAllies updater model =
              updateCharacters3 (function AllyIndex _ -> true | _ -> false) updater model
  
          static let updateEnemies updater model =
              updateCharacters3 (function EnemyIndex _ -> true | _ -> false) updater model
  
          static let tryGetCharacter characterIndex model =
              Map.tryFind characterIndex model.BattleCharacters
  
          static let getCharacter characterIndex model =
              tryGetCharacter characterIndex model |> Option.get
  
          static let getCharacterIndex (entity : Entity) =
              let strs = entity.Name.Split '+'
              let ctor = if strs.[0] = "Ally" then AllyIndex else EnemyIndex
              ctor (scvalue<int> strs.[1])
  
          static let tryUpdateCharacter updater characterIndex model =
              match tryGetCharacter characterIndex model with
              | Some character ->
                  let character = updater character
                  { model with BattleCharacters = Map.add characterIndex character model.BattleCharacters }
              | None -> model
          do ignore tryUpdateCharacter
  
          static let updateCharacter updater characterIndex model =
              let character = getCharacter characterIndex model
              let character = updater character
              { model with BattleCharacters = Map.add characterIndex character model.BattleCharacters }
  
          static let tickAttack sourceIndex (targetIndexOpt : CharacterIndex option) time timeLocal model =
  
              // if target available, proceed with attack
              let source = getCharacter sourceIndex model
  