anchor.diff:                          positions.[u+5] <- position
                       | None -> ()
   
  -            for i in 1 .. dec tileMap.Width do
  -                for j in 1 .. dec tileMap.Height do
  -                    let u = i * tileMap.Width + j
  +            for i in 1 .. dec tileMapWidth do
  +                for j in 1 .. dec tileMapHeight do
  +                    let u = i * tileMapWidth + j
                       let positionM1 = &positions.[dec u]
                       let position = &positions.[u]
                       position.X <- (positionM1.X + position.X) / 2.0f
  
positive.code: 
  module Field =
  
      let FieldGeometries = dictPlus HashIdentity.Structural []
  
      type Field =
          private
              { FieldTileMap : TileMap AssetTag }
  
      let getFieldGeometry (field : Field) world =
          match FieldGeometries.TryGetValue field.FieldTileMap with
          | (true, geometry) -> geometry
          | (false, _) ->
  
              let (_, tileSets, tileMap) = World.getTileMapMetadata field.FieldTileMap world
              let untraversableLayer = tileMap.Layers.["Untraversable"] :?> TmxLayer
              let untraversableHeightLayer = tileMap.Layers.["UntraversableHeight"] :?> TmxLayer
              let traversableLayer = tileMap.Layers.["Traversable"] :?> TmxLayer
              let traversableHeightLayer = tileMap.Layers.["TraversableHeight"] :?> TmxLayer
  
              let texCoords = Array.zeroCreate<Vector2> (tileMap.Width * tileMap.Height * 6)
  
              for i in 0 .. dec tileMap.Width do
                  for j in 0 .. dec tileMap.Height do
                      let t = i * tileMap.Width + j
                      let tile = untraversableLayer.Tiles.[t]
                      let mutable tileSetOpt = None
                      for (tileSet, _) in tileSets do
                          match tileSetOpt with
                          | None ->
                              if tile.Gid = 0 then
  
negative.code:                         texCoords.[u+5] <- v2 texCoordX texCoordY
                      | None -> ()
  
              let positions = Array.zeroCreate<Vector3> (tileMapWidth * tileMapHeight * 6)
  
              for i in 0 .. dec tileMapWidth do
                  for j in 0 .. dec tileMapHeight do
                      let t = i * tileMapWidth + j
                      let tile = heightLayer.Tiles.[t]
                      let mutable tileSetOpt = None
                      for tileSet in tileSets do
                          match tileSetOpt with
                          | None ->
                              if tile.Gid = 0 then
  