anchor.diff:                      let localTime = time - startTime
                       let (step, stepCount) = MoveType.computeStepAndStepCount origin destination moveType
                       let totalTime = int64 (dec stepCount)
  -                    if localTime = totalTime then
  +                    if localTime < totalTime then
  +                        let field = Field.updateAvatar (Avatar.updateBottom ((+) step)) field
  +                        (cue, definitions, just field)
  +                    else
                           let field = Field.updateAvatar (Avatar.updateBottom (constant destination)) field
  -                        (Cue.Nil, definitions, just field)
  -                    else
  -                        let field = Field.updateAvatar (Avatar.updateBottom ((+) step)) field
                           (Cue.Nil, definitions, just field)
                   | CharacterTarget characterType ->
                       match Map.tryFindKey (constant (function CharacterState (_, characterType2, _, _, _, _) -> characterType2 = characterType | _ -> false)) field.PropStates with
  
positive.code:                             let localTime = time - startTime
                              let (step, stepCount) = MoveType.computeStepAndStepCount origin destination moveType
                              let finishTime = int64 (dec stepCount)
                              if localTime = finishTime then
                                  let bounds = bounds.WithBottom destination
                                  let field = Field.updatePropStates (Map.add propKey (CharacterState (bounds, characterType, direction, color, glow, exists))) field
                                  (Cue.Nil, definitions, just field)
                              else
                                  let bounds = bounds.Translate step
                                  let field = Field.updatePropStates (Map.add propKey (CharacterState (bounds, characterType, direction, color, glow, exists))) field
                                  (Cue.Nil, definitions, just field)
                          | _ -> (Cue.Nil, definitions, just field)
  
negative.code:             | Move (target, destination, moveType) ->
                  match target with
                  | AvatarTarget ->
                      let cue = MoveState (World.getUpdateTime world, target, field.Avatar.Bottom, destination, moveType)
                      (cue, definitions, just field)
                  | CharacterTarget characterType ->
                      // NOTE: I really don't like the need to do these inefficient reverse map look-ups as a matter of
                      // course. Perhaps there's an elegant solution that is more performance.
                      match Map.tryFindKey (constant (function CharacterState (_, characterType2, _, _, _, _) -> characterType2 = characterType | _ -> false)) field.PropStates with
                      | Some propKey ->
                          match field.PropStates.[propKey] with
                          | CharacterState (bounds, _, _, _, _, _) ->
                              let cue = MoveState (World.getUpdateTime world, target, bounds.Bottom, destination, moveType)
                              (cue, definitions, just field)
                          | _ -> (Cue.Nil, definitions, just field)
                      | None -> (Cue.Nil, definitions, just field)
                  | NpcTarget _ | ShopkeepTarget _ | CharacterIndexTarget _ ->
  