anchor.diff:                          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 }
  +                        else just model
                       withSig model (signal + signal2)
   
  -        and tickNoCommand time battleRunning model =
  -            match battleRunning.ActionQueue with
  +        and tickNoCommand time model =
  +            match model.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 }}
  +                let model = { model with CurrentCommandOpt = Some command; ActionQueue = nextCommands }
                   tick time model // tick for frame 0
               | Queue.Nil ->
  -                let (allySignals, model) =
  +                let (allySignalsRev, model) =
                       List.fold (fun (commands, model) ally ->
                           if ally.ActionTime = Constants.Battle.ActionTime
                           then (Command (IndexedCommandCmd (RegularMenuShow, ally.CharacterState.PartyIndex)) :: commands, model)
                           else (commands, model))
                           ([], model)
                           (getAllies model)
  -                let (enemySignals, model) =
  +                let (enemySignalsRev, model) =
                       List.fold (fun (commands, model) enemy ->
  -                        let enemyIndex = EnemyIndex enemy.CharacterState.PartyIndex
  -                        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
  -                            let model = { model with BattleState = BattleRunning { battleRunning with ActionQueue = Queue.conj attack battleRunning.ActionQueue }}
  +                            let enemyIndex = EnemyIndex enemy.CharacterState.PartyIndex
  +                            let allies = getAllies model
  +                            let allyIndex = (Random ()).Next allies.Length
  +                            let attack = { Action = Attack; Source = enemyIndex; TargetOpt = Some (AllyIndex allyIndex) }
  +                            let model = { model with ActionQueue = Queue.conj attack model.ActionQueue }
                               (Message (ResetCharacter enemyIndex) :: commands, model)
                           else (commands, model))
                           ([], model)
                           (getEnemies model)
                   let advanceCharactersSignal = Message AdvanceCharacters
  -                let signals = advanceCharactersSignal :: enemySignals @ allySignals
  +                let signals = advanceCharactersSignal :: List.rev enemySignalsRev @ List.rev allySignalsRev
                   withSigs model signals
   
  -        and tickRunning time battleRunning model =
  -            match battleRunning.CurrentCommandOpt with
  -            | Some currentCommand -> tickCurrentCommand time currentCommand battleRunning model
  -            | None -> tickNoCommand time battleRunning model
  +        and tickRunning time model =
  +            match model.CurrentCommandOpt with
  +            | Some currentCommand -> tickCurrentCommand time currentCommand model
  +            | None -> tickNoCommand time model
   
           and tickCease time timeStart outcome model =
               let timeLocal = time - timeStart
  
positive.code:             let (model, sigs) =
                  match model.BattleState with
                  | BattleReady timeStart -> tickReady time timeStart model
                  | BattleRunning battleRunning -> tickRunning time battleRunning model
                  | BattleCease (outcome, timeStart) -> tickCease time timeStart outcome model
              (model, sigs)
  
  
negative.code:             let character = updater character
              { model with BattleCharacters = Map.add characterIndex character model.BattleCharacters }
  
          let tickAttack sourceIndex (targetIndexOpt : CharacterIndex option) time timeLocal model =
  
              // if target available, proceed with attack
              let source = getCharacter sourceIndex model
  