anchor.diff:                  else world
               else world
   
  -        static let runCharacterNavigation newNavigationDescriptor characterAddress address world =
  +        static let runCharacterNavigation newNavigationDescriptor (character : Entity) gameplay world =
               let chain = chain {
  -                do! updateEntity (Entity.setActivityState <| Navigation newNavigationDescriptor) characterAddress
  +                do! update ^ character.SetActivityState ^ Navigation newNavigationDescriptor
                   do! during (fun world ->
  -                    match World.getEntityBy Entity.getActivityState characterAddress world with
  -                    | Navigation navigationDescriptor -> newNavigationDescriptor.WalkDescriptor.WalkOriginM = navigationDescriptor.WalkDescriptor.WalkOriginM
  +                    match character.GetActivityState world with
  +                    | Navigation navigationDescriptor ->
  +                        newNavigationDescriptor.WalkDescriptor.WalkOriginM =
  +                            navigationDescriptor.WalkDescriptor.WalkOriginM
                       | Action _ -> false
                       | NoActivity -> false) ^ chain {
                       do! update ^ fun world ->
                           let navigationDescriptor =
  -                            match World.getEntityBy Entity.getActivityState characterAddress world with
  +                            match character.GetActivityState world with
                               | Navigation navigationDescriptor -> navigationDescriptor
                               | _ -> failwith "Unexpected match failure in InfinityRpg.GameplayDispatcherModule.runCharacterNavigation."
  -                        updateCharacterByNavigation navigationDescriptor characterAddress world
  +                        updateCharacterByNavigation navigationDescriptor character world
                       do! pass }}
  -            let observation = observe TickEventAddress characterAddress |> until (DeselectEventAddress ->>- address)
  +            let observation = observe TickEventAddress character |> until (DeselectEventAddress ->>- gameplay.ScreenAddress)
               snd <| runAssumingCascade chain observation world
   
  -        static let runCharacterAction newActionDescriptor characterAddress address world =
  +        static let runCharacterAction newActionDescriptor (character : Entity) gameplay world =
               // NOTE: currently just implements attack
               let chain = chain {
  -                do! updateEntity (Entity.setActivityState <| Action newActionDescriptor) characterAddress
  -                do! during (World.getEntityBy (Entity.getActivityState >> ActivityState.isActing) characterAddress) ^ chain {
  +                do! update ^ character.SetActivityState ^ Action newActionDescriptor
  +                do! during (fun world -> ActivityState.isActing <| character.GetActivityState world) ^ chain {
                       do! update ^ fun world ->
                           let actionDescriptor =
  -                            match World.getEntityBy Entity.getActivityState characterAddress world  with
  +                            match character.GetActivityState world  with
                               | Action actionDescriptor -> actionDescriptor
                               | _ -> failwithumf ()
  -                        let world = updateCharacterByAction actionDescriptor characterAddress world
  -                        runCharacterReaction actionDescriptor characterAddress address world
  +                        let world = updateCharacterByAction actionDescriptor character world
  +                        runCharacterReaction actionDescriptor character gameplay world
                       do! pass }}
  -            let observation = observe TickEventAddress characterAddress |> until (DeselectEventAddress ->>- address)
  +            let observation = observe TickEventAddress character |> until (DeselectEventAddress ->>- gameplay.ScreenAddress)
               snd <| runAssumingCascade chain observation world
   
  -        static let runCharacterNoActivity characterAddress world =
  -            World.updateEntity (Entity.setActivityState NoActivity) characterAddress world
  -
  -        static let runCharacterActivity newActivity characterAddress address world =
  +        static let runCharacterNoActivity (character : Entity) world =
  +            character.SetActivityState NoActivity world
  +
  +        static let runCharacterActivity newActivity character gameplay world =
               match newActivity with
  -            | Action newActionDescriptor -> runCharacterAction newActionDescriptor characterAddress address world
  -            | Navigation newNavigationDescriptor -> runCharacterNavigation newNavigationDescriptor characterAddress address world
  -            | NoActivity -> runCharacterNoActivity characterAddress world
  -
  -        static let tryRunEnemyActivity address world newActivity enemyAddress =
  +            | Action newActionDescriptor -> runCharacterAction newActionDescriptor character gameplay world
  +            | Navigation newNavigationDescriptor -> runCharacterNavigation newNavigationDescriptor character gameplay world
  +            | NoActivity -> runCharacterNoActivity character world
  +
  +        static let tryRunEnemyActivity gameplay world newActivity (enemy : Entity) =
               if newActivity <> NoActivity then
  -                let enemy = World.getEntity enemyAddress world
  -                let enemy = Entity.setDesiredTurn NoTurn enemy
  -                let world = World.setEntity enemy enemyAddress world
  -                runCharacterActivity newActivity enemyAddress address world
  +                let world = enemy.SetDesiredTurn NoTurn world
  +                runCharacterActivity newActivity enemy gameplay world
               else world
   
  -        static let runEnemyNavigationActivities enemyNavigationActivities enemyAddresses address world =
  +        static let runEnemyNavigationActivities enemyNavigationActivities enemies gameplay world =
               if Seq.exists ActivityState.isNavigating enemyNavigationActivities
  -            then Seq.fold2 (tryRunEnemyActivity address) world enemyNavigationActivities enemyAddresses
  +            then Seq.fold2 (tryRunEnemyActivity gameplay) world enemyNavigationActivities enemies
               else world
   
  -        static let runEnemyActivities enemyActionActivities enemyNavigationActivities enemyAddresses address world =
  +        static let runEnemyActivities enemyActionActivities enemyNavigationActivities enemies gameplay world =
               let anyEnemyActionActivity = Seq.exists ActivityState.isActing enemyActionActivities
               let newEnemyActivities = if anyEnemyActionActivity then enemyActionActivities else enemyNavigationActivities
  -            Seq.fold2 (tryRunEnemyActivity address) world newEnemyActivities enemyAddresses
  -
  -        static let runPlayerTurn playerTurn address world =
  +            Seq.fold2 (tryRunEnemyActivity gameplay) world newEnemyActivities enemies
  +            
  +        static let runPlayerTurn playerTurn gameplay world =
   
               // construct occupation map
               let occupationMap =
  -                let field = World.getEntity (getFieldAddress address) world
  -                let enemies = World.getEntities (getEnemyAddresses address world) world
  -                OccupationMap.makeFromFieldTilesAndCharactersAndDesiredTurn field.FieldMapNp.FieldTiles enemies playerTurn
  +                let field = proxyField gameplay
  +                let fieldMap = field.GetFieldMapNp world
  +                let enemies = proxyEnemies gameplay world
  +                let enemyPositions = Seq.map (fun (enemy : Entity) -> enemy.GetPosition world) enemies
  +                OccupationMap.makeFromFieldTilesAndCharactersAndDesiredTurn fieldMap.FieldTiles enemyPositions playerTurn
   
               // determine player activity
               let optNewPlayerActivity =
  
positive.code:                 (List.ofSeq enemies)
                  []
  
          static let determineEnemyNavigationActivities enemyAddresses world =
              let enemies = World.getEntities enemyAddresses world
              List.foldBack
                  (fun (enemy : Entity) enemyActivities ->
                      let noCurrentEnemyActionActivity =
  
negative.code:             let world =
                  match optNewPlayerActivity with
                  | Some newPlayerActivity ->
                      let player = proxyPlayer gameplay
                      runCharacterActivity newPlayerActivity player gameplay world
                  | None -> world
  
              // determine (and set) enemy desired turns if applicable
  