Merge branch 'master' into master

kaczy93 · web-flow · commit de822d06834f · 2025-11-24T16:38:55.000+01:00
diff --git a/CentrED/Map/MapManager.cs b/CentrED/Map/MapManager.cs
@@ -174,10 +174,7 @@ private void OnConnected()
 
     private void OnDisconnected()
     {
-        LandTiles = new LandObject[0, 0];
-        LandTilesIdDictionary.Clear();
-        GhostLandTiles.Clear();
-        StaticsManager.Clear();
+        Reset();
     }
 
     public void EnableBlockLoading()
@@ -504,7 +501,7 @@ public IEnumerable<TileObject> GetTiles(TileObject? t1, TileObject? t2, bool top
     
     private MouseState _prevMouseState = Mouse.GetState();
     private bool _IsMouseDragging;
-    public Rectangle ViewRange { get; private set; }
+    public RectU16 ViewRange { get; private set; }
 
     public void Update(GameTime gameTime, bool isActive, bool processMouse, bool processKeyboard)
     {
@@ -702,26 +699,16 @@ public void Update(GameTime gameTime, bool isActive, bool processMouse, bool pro
         Camera.Update();
         if (Client.Running)
         {
-            CalculateViewRange(Camera, out var newViewRange);
+            var newViewRange = CalculateViewRange(Camera);
             if (ViewRange != newViewRange)
             {
-                List<PointU16> requested = new List<PointU16>();
-                for (var x = newViewRange.Left / 8; x <= newViewRange.Right / 8; x++)
-                {
-                    for (var y = newViewRange.Top / 8; y <= newViewRange.Bottom / 8; y++)
-                    {
-                        requested.Add(new PointU16((ushort)x, (ushort)y));
-                    }
-                }
-
                 ViewRange = newViewRange;
-                Client.ResizeCache(ViewRange.Width * ViewRange.Height / 8);
-                Client.RequestBlocks(requested);
+                Client.RequestBlocks(ViewRange);
             }
         }
         else
         {
-            ViewRange = Rectangle.Empty;
+            ViewRange = default;
         }
         if (Client.Running && AnimatedStatics)
         {
@@ -755,7 +742,7 @@ public void Reset()
         RealSelected = null;
         GhostLandTiles.Clear();
         StaticsManager.Clear();
-        ViewRange = Rectangle.Empty;
+        ViewRange = default;
         Client.ResetCache();
     }
 
@@ -805,7 +792,7 @@ private void UpdateMouseSelection(int x, int y)
         }
     }
 
-    private void CalculateViewRange(Camera camera, out Rectangle rect)
+    private RectU16 CalculateViewRange(Camera camera)
     {
         float zoom = camera.Zoom;
         int screenWidth = camera.ScreenSize.Width;
@@ -818,13 +805,14 @@ private void CalculateViewRange(Camera camera, out Rectangle rect)
         Vector3 center = camera.Position;
         
         // Render a few extra rows at the top to deal with things at lower z
-        var minTileX = (int)Math.Max(0, (center.X - screenDiamondDiagonal) / TILE_SIZE - 8);
-        var minTileY = (int)Math.Max(0, (center.Y - screenDiamondDiagonal) / TILE_SIZE - 8);
+        var minTileX = Client.ClampX((int)((center.X - screenDiamondDiagonal) / TILE_SIZE - 8));
+        var minTileY = Client.ClampY((int)((center.Y - screenDiamondDiagonal) / TILE_SIZE - 8));
         
         // Render a few extra rows at the bottom to deal with things at higher z
-        var maxTileX = (int)Math.Min(Client.Width * 8 - 1, (center.X + screenDiamondDiagonal) / TILE_SIZE + 8);
-        var maxTileY = (int)Math.Min(Client.Height * 8 - 1, (center.Y + screenDiamondDiagonal) / TILE_SIZE + 8);
-        rect = new Rectangle(minTileX, minTileY, maxTileX - minTileX, maxTileY - minTileY);
+        var maxTileX = Client.ClampX((int)((center.X + screenDiamondDiagonal) / TILE_SIZE + 8));
+        var maxTileY = Client.ClampY((int)((center.Y + screenDiamondDiagonal) / TILE_SIZE + 8));
+        
+        return new RectU16(minTileX, minTileY, maxTileX, maxTileY);
     }
 
     public Vector3 Unproject(int x, int y, int z)
@@ -1058,24 +1046,21 @@ private void DrawSelectionBuffer()
             _DepthStencilState,
             BlendState.AlphaBlend
         );
-        for (var x = ViewRange.Left; x < ViewRange.Right; x++)
+        foreach (var (x,y) in ViewRange)
         {
-            for (var y = ViewRange.Top; y < ViewRange.Bottom; y++)
+            var landTile = LandTiles[x, y];
+            if (landTile != null)
             {
-                var landTile = LandTiles[x, y];
-                if (landTile != null)
-                {
-                    DrawLand(landTile, landTile.ObjectIdColor);
-                }
+                DrawLand(landTile, landTile.ObjectIdColor);
+            }
 
-                var tiles = StaticsManager.Get(x, y);
-                if(tiles == null) continue;
-                foreach (var tile in tiles)
+            var tiles = StaticsManager.Get(x, y);
+            if(tiles == null) continue;
+            foreach (var tile in tiles)
+            {
+                if (tile.CanDraw)
                 {
-                    if (tile.CanDraw)
-                    {
-                        DrawStatic(tile, tile.ObjectIdColor);
-                    }
+                    DrawStatic(tile, tile.ObjectIdColor);
                 }
             }
         }
@@ -1115,7 +1100,7 @@ private void DrawLights(Camera camera)
         _mapRenderer.End();
     }
 
-    private void DrawLand(Camera camera, Rectangle viewRange, string technique = "Terrain")
+    private void DrawLand(Camera camera, RectU16 viewRange, string technique = "Terrain")
     {
         if (!ShowLand)
         {
@@ -1132,23 +1117,21 @@ private void DrawLand(Camera camera, Rectangle viewRange, string technique = "Te
             BlendState.AlphaBlend
         );
            
-        for (var x = viewRange.Left; x < viewRange.Right; x++)
+        foreach (var (x,y) in viewRange)
         {
-            for (var y = viewRange.Top; y < viewRange.Bottom; y++)
+            var tile = LandTiles[x, y];
+            if (tile != null && tile.CanDraw)
             {
-                var tile = LandTiles[x, y];
-                if (tile != null && tile.CanDraw)
+                var hueOverride = Vector4.Zero;
+                if (WalkableSurfaces && !UoFileManager.TileData.LandData[tile.LandTile.Id].IsWet)
                 {
-                    var hueOverride = Vector4.Zero;
-                    if (WalkableSurfaces && !UoFileManager.TileData.LandData[tile.LandTile.Id].IsWet)
-                    {
-                        hueOverride = IsWalkable(tile) ? WalkableHue : NonWalkableHue;
+                    hueOverride = IsWalkable(tile) ? WalkableHue : NonWalkableHue;
 
-                    }
-                    DrawLand(tile, hueOverride);
                 }
+                DrawLand(tile, hueOverride);
             }
         }
+        
         foreach (var tile in GhostLandTiles.Values)
         {
             DrawLand(tile);
@@ -1165,15 +1148,12 @@ private void DrawLandHeight()
         var font = _fontSystem.GetFont(18 * Camera.Zoom);
         var halfTile = TILE_SIZE * 0.5f * Camera.Zoom;
         _spriteBatch.Begin();
-        for (var x = ViewRange.Left; x < ViewRange.Right; x++)
+        foreach (var (x, y) in ViewRange)
         {
-            for (var y = ViewRange.Top; y < ViewRange.Bottom; y++)
+            var tile = LandTiles[x, y];
+            if (tile != null && tile.CanDraw)
             {
-                var tile = LandTiles[x, y];
-                if (tile != null && tile.CanDraw)
-                {
-                    DrawTileHeight(tile, font, halfTile);
-                }
+                DrawTileHeight(tile, font, halfTile);
             }
         }
         foreach (var tile in GhostLandTiles.Values)
@@ -1200,7 +1180,7 @@ private void DrawTileHeight(LandObject tile, DynamicSpriteFont font, float yOffs
         }
     }
 
-    private void DrawStatics(Camera camera, Rectangle viewRange)
+    private void DrawStatics(Camera camera, RectU16 viewRange)
     {
         if (!ShowStatics)
         {
@@ -1216,23 +1196,20 @@ private void DrawStatics(Camera camera, Rectangle viewRange)
             _DepthStencilState,
             BlendState.AlphaBlend
         );
-        for (var x = viewRange.Left; x < viewRange.Right; x++)
+        foreach (var (x,y) in viewRange)
         {
-            for (var y = viewRange.Top; y < viewRange.Bottom; y++)
+            var tiles = StaticsManager.Get(x, y);
+            if(tiles == null) continue;
+            foreach (var tile in tiles)
             {
-                var tiles = StaticsManager.Get(x, y);
-                if(tiles == null) continue;
-                foreach (var tile in tiles)
+                if (tile.CanDraw)
                 {
-                    if (tile.CanDraw)
+                    var hueOverride = Vector4.Zero;
+                    if (WalkableSurfaces && UoFileManager.TileData.StaticData[tile.Tile.Id].IsSurface)
                     {
-                        var hueOverride = Vector4.Zero;
-                        if (WalkableSurfaces && UoFileManager.TileData.StaticData[tile.Tile.Id].IsSurface)
-                        {
-                            hueOverride = IsWalkable(tile) ? WalkableHue : NonWalkableHue;
-                        }
-                        DrawStatic(tile, hueOverride);
+                        hueOverride = IsWalkable(tile) ? WalkableHue : NonWalkableHue;
                     }
+                    DrawStatic(tile, hueOverride);
                 }
             }
         }
@@ -1303,18 +1280,8 @@ public void ExportImage(string path, int widthPx, int heightPx, float zoom)
         myCamera.ScreenSize = new Rectangle(rbounds.X, rbounds.Y, rbounds.Width, rbounds.Height);
         myCamera.Update();
         
-        CalculateViewRange(myCamera, out var bounds);
-        List<PointU16> requested = new List<PointU16>();
-        for (var x = bounds.Left / 8; x <= bounds.Right / 8; x++)
-        {
-            for (var y = bounds.Top / 8; y <= bounds.Bottom / 8; y++)
-            {
-                requested.Add(new PointU16((ushort)x, (ushort)y));
-            }
-        }
-
-        Client.ResizeCache(bounds.Width * bounds.Height / 8);
-        Client.RequestBlocks(requested);
+        var cameraBounds = CalculateViewRange(myCamera);
+        Client.RequestBlocks(cameraBounds);
         while(Client.WaitingForBlocks) 
             Client.Update();
         
@@ -1327,8 +1294,8 @@ public void ExportImage(string path, int widthPx, int heightPx, float zoom)
         _mapEffect.WorldViewProj = myCamera.FnaWorldViewProj;
         DrawLights(myCamera);
         _mapRenderer.SetRenderTarget(myRenderTarget, new FNARectangle(0,0, widthPx, heightPx));
-        DrawLand(myCamera, bounds);
-        DrawStatics(myCamera, bounds);
+        DrawLand(myCamera, cameraBounds);
+        DrawStatics(myCamera, cameraBounds);
         ApplyLights();
         using var fs = new FileStream(path, FileMode.OpenOrCreate);
         if(path.EndsWith(".png"))
diff --git a/CentrED/UI/Windows/ConnectWindow.cs b/CentrED/UI/Windows/ConnectWindow.cs
@@ -117,14 +117,12 @@ protected override void InternalDraw()
             if (ImGui.Button(LangManager.Get(DISCONNECT)))
             {
                 CEDClient.Disconnect();
-                CEDGame.MapManager.Reset();
             }
         }
         else
         {
             if (ImGui.Button(LangManager.Get(CONNECT)) || ImGui.IsWindowFocused() && ImGui.IsKeyPressed(ImGuiKey.Enter))
             {
-                CEDGame.MapManager.Reset();
                 _buttonDisabled = true;
                 new Task
                 (
diff --git a/CentrED/UI/Windows/MinimapWindow.cs b/CentrED/UI/Windows/MinimapWindow.cs
@@ -155,11 +155,11 @@ protected override void InternalDraw()
             }
 
             var rect = CEDGame.MapManager.ViewRange;
-            var center = new Point(rect.X + rect.Width / 2, rect.Y + rect.Height / 2);
-            var p1 = currentPos + new Vector2(rect.Left / 8, center.Y / 8);
-            var p2 = currentPos + new Vector2(center.X / 8, rect.Top / 8);
-            var p3 = currentPos + new Vector2(rect.Right / 8, center.Y / 8);
-            var p4 = currentPos + new Vector2(center.X / 8, rect.Bottom / 8);
+            var center = new Point(rect.X1 + rect.Width / 2, rect.Y1 + rect.Height / 2);
+            var p1 = currentPos + new Vector2(rect.X1 / 8, center.Y / 8);
+            var p2 = currentPos + new Vector2(center.X / 8, rect.Y1 / 8);
+            var p3 = currentPos + new Vector2(rect.X2 / 8, center.Y / 8);
+            var p4 = currentPos + new Vector2(center.X / 8, rect.Y2 / 8);
             ImGui.GetWindowDrawList().AddQuad(p1, p2, p3, p4, ImGui.GetColorU32(ImGuiColor.Red));
             CEDGame.UIManager.GetWindow<LSOWindow>().DrawArea(currentPos);
             CEDGame.UIManager.GetWindow<ServerAdminWindow>().DrawArea(currentPos);
diff --git a/Client/CentrEDClient.cs b/Client/CentrEDClient.cs
@@ -200,26 +200,25 @@ public void LoadBlocks(RectU16 areaInfo)
 
     public void RequestBlocks(RectU16 areaInfo)
     {
-        List<PointU16> requested = new List<PointU16>();
-        for (var x = areaInfo.X1 / 8; x <= areaInfo.X2 / 8; x++)
+        List<PointU16> toRequest = new List<PointU16>();
+        foreach (var (x,y) in areaInfo / 8)
         {
-            for (var y = areaInfo.Y1 / 8; y <= areaInfo.Y2 / 8; y++)
-            {
-                requested.Add(new PointU16((ushort)x, (ushort)y));
-            }
+            if(!IsValidX(x) || !IsValidY(y))
+                continue;
+            if(Landscape.BlockCache.Contains(Block.Id(x, y)))
+                continue;
+            
+            var chunk = new PointU16(x, y);
+            if(RequestedBlocks.Contains(chunk))
+                continue;
+            
+            toRequest.Add(chunk);
         }
-
-        ResizeCache(Math.Max(1, areaInfo.Width * areaInfo.Height / 8));
-        RequestBlocks(requested);
-    }
-
-    public void RequestBlocks(List<PointU16> blockCoords)
-    {
-        var filteredBlockCoords = blockCoords.FindAll
-            (b => !Landscape.BlockCache.Contains(Block.Id(b.X, b.Y)) && !RequestedBlocks.Contains(b) && IsValidX(b.X) && IsValidY(b.Y));
+      
+        Landscape.BlockCache.Grow(Math.Max(1, areaInfo.Width * areaInfo.Height / 8));
         
-        filteredBlockCoords.ForEach(b => RequestedBlocks.Add(b));
-        filteredBlockCoords.ForEach(b => RequestedBlocksQueue.Enqueue(b));;
+        toRequest.ForEach(b => RequestedBlocks.Add(b));
+        toRequest.ForEach(b => RequestedBlocksQueue.Enqueue(b));;
     }
 
     private void UpdateRequestedBlocks()
@@ -246,11 +245,21 @@ public bool IsValidX(int x)
         return x >= 0 && x < WidthInTiles;
     }
 
+    public ushort ClampX(int x)
+    {
+        return (ushort)Math.Clamp(x, 0, WidthInTiles - 1);
+    }
+
     public bool IsValidY(int y)
     {
         return y >= 0 && y < HeightInTiles;
     }
     
+    public ushort ClampY(int y)
+    {
+        return (ushort)Math.Clamp(y, 0, HeightInTiles - 1);
+    }
+    
     public bool InternalSetPos(ushort x, ushort y)
     {
         if (x == X && y == Y)
@@ -343,11 +352,7 @@ public void SendWithUndo(Packet p)
     public void ResetCache()
     {
         Landscape?.BlockCache.Reset();
-    }
-
-    public void ResizeCache(int newSize)
-    {
-        Landscape?.BlockCache.Resize(newSize);
+        Landscape?.BlockCache.Resize(Math.Max(Width, Height) + 1);
     }
 
     public void Flush()
@@ -462,7 +467,7 @@ internal void InitLandscape(ushort width, ushort height)
     {
         Landscape = new ClientLandscape(this, width, height);
         Landscape.RegisterPacketHandlers(NetState!);
-        Landscape.BlockCache.Resize(Math.Max(width, height) + 1);
+        ResetCache();
         Connected?.Invoke();
         State = ClientState.Running;
         if (AccessLevel == AccessLevel.Administrator)
diff --git a/Shared/BlockCache.cs b/Shared/BlockCache.cs
@@ -60,6 +60,12 @@ private bool Dequeue(out Block? block)
         return true;
     }
 
+    public void Grow(int newSize)
+    {
+        if (newSize > _maxSize)
+            Resize(newSize);
+    }
+
     public void Resize(int newSize)
     {
         if (newSize < 0)
diff --git a/Shared/Network/RectU16.cs b/Shared/Network/RectU16.cs

Original file line number	Diff line number	Diff line change
`@@ -174,10 +174,7 @@ private void OnConnected()`
`174`	`174`
`175`	`175`	`private void OnDisconnected()`
`176`	`176`	`{`
`177`		`- LandTiles = new LandObject[0, 0];`
`178`		`- LandTilesIdDictionary.Clear();`
`179`		`- GhostLandTiles.Clear();`
`180`		`- StaticsManager.Clear();`
	`177`	`+ Reset();`
`181`	`178`	`}`
`182`	`179`
`183`	`180`	`public void EnableBlockLoading()`
`@@ -504,7 +501,7 @@ public IEnumerable<TileObject> GetTiles(TileObject? t1, TileObject? t2, bool top`
`504`	`501`
`505`	`502`	`private MouseState _prevMouseState = Mouse.GetState();`
`506`	`503`	`private bool _IsMouseDragging;`
`507`		`- public Rectangle ViewRange { get; private set; }`
	`504`	`+ public RectU16 ViewRange { get; private set; }`
`508`	`505`
`509`	`506`	`public void Update(GameTime gameTime, bool isActive, bool processMouse, bool processKeyboard)`
`510`	`507`	`{`
`@@ -702,26 +699,16 @@ public void Update(GameTime gameTime, bool isActive, bool processMouse, bool pro`
`702`	`699`	`Camera.Update();`
`703`	`700`	`if (Client.Running)`
`704`	`701`	`{`
`705`		`- CalculateViewRange(Camera, out var newViewRange);`
	`702`	`+ var newViewRange = CalculateViewRange(Camera);`
`706`	`703`	`if (ViewRange != newViewRange)`
`707`	`704`	`{`
`708`		`- List<PointU16> requested = new List<PointU16>();`
`709`		`- for (var x = newViewRange.Left / 8; x <= newViewRange.Right / 8; x++)`
`710`		`- {`
`711`		`- for (var y = newViewRange.Top / 8; y <= newViewRange.Bottom / 8; y++)`
`712`		`- {`
`713`		`- requested.Add(new PointU16((ushort)x, (ushort)y));`
`714`		`- }`
`715`		`- }`
`716`		`-`
`717`	`705`	`ViewRange = newViewRange;`
`718`		`- Client.ResizeCache(ViewRange.Width * ViewRange.Height / 8);`
`719`		`- Client.RequestBlocks(requested);`
	`706`	`+ Client.RequestBlocks(ViewRange);`
`720`	`707`	`}`
`721`	`708`	`}`
`722`	`709`	`else`
`723`	`710`	`{`
`724`		`- ViewRange = Rectangle.Empty;`
	`711`	`+ ViewRange = default;`
`725`	`712`	`}`
`726`	`713`	`if (Client.Running && AnimatedStatics)`
`727`	`714`	`{`
`@@ -755,7 +742,7 @@ public void Reset()`
`755`	`742`	`RealSelected = null;`
`756`	`743`	`GhostLandTiles.Clear();`
`757`	`744`	`StaticsManager.Clear();`
`758`		`- ViewRange = Rectangle.Empty;`
	`745`	`+ ViewRange = default;`
`759`	`746`	`Client.ResetCache();`
`760`	`747`	`}`
`761`	`748`
`@@ -805,7 +792,7 @@ private void UpdateMouseSelection(int x, int y)`
`805`	`792`	`}`
`806`	`793`	`}`
`807`	`794`
`808`		`- private void CalculateViewRange(Camera camera, out Rectangle rect)`
	`795`	`+ private RectU16 CalculateViewRange(Camera camera)`
`809`	`796`	`{`
`810`	`797`	`float zoom = camera.Zoom;`
`811`	`798`	`int screenWidth = camera.ScreenSize.Width;`
`@@ -818,13 +805,14 @@ private void CalculateViewRange(Camera camera, out Rectangle rect)`
`818`	`805`	`Vector3 center = camera.Position;`
`819`	`806`
`820`	`807`	`// Render a few extra rows at the top to deal with things at lower z`
`821`		`- var minTileX = (int)Math.Max(0, (center.X - screenDiamondDiagonal) / TILE_SIZE - 8);`
`822`		`- var minTileY = (int)Math.Max(0, (center.Y - screenDiamondDiagonal) / TILE_SIZE - 8);`
	`808`	`+ var minTileX = Client.ClampX((int)((center.X - screenDiamondDiagonal) / TILE_SIZE - 8));`
	`809`	`+ var minTileY = Client.ClampY((int)((center.Y - screenDiamondDiagonal) / TILE_SIZE - 8));`
`823`	`810`
`824`	`811`	`// Render a few extra rows at the bottom to deal with things at higher z`
`825`		`- var maxTileX = (int)Math.Min(Client.Width * 8 - 1, (center.X + screenDiamondDiagonal) / TILE_SIZE + 8);`
`826`		`- var maxTileY = (int)Math.Min(Client.Height * 8 - 1, (center.Y + screenDiamondDiagonal) / TILE_SIZE + 8);`
`827`		`- rect = new Rectangle(minTileX, minTileY, maxTileX - minTileX, maxTileY - minTileY);`
	`812`	`+ var maxTileX = Client.ClampX((int)((center.X + screenDiamondDiagonal) / TILE_SIZE + 8));`
	`813`	`+ var maxTileY = Client.ClampY((int)((center.Y + screenDiamondDiagonal) / TILE_SIZE + 8));`
	`814`	`+`
	`815`	`+ return new RectU16(minTileX, minTileY, maxTileX, maxTileY);`
`828`	`816`	`}`
`829`	`817`
`830`	`818`	`public Vector3 Unproject(int x, int y, int z)`
`@@ -1058,24 +1046,21 @@ private void DrawSelectionBuffer()`
`1058`	`1046`	`_DepthStencilState,`
`1059`	`1047`	`BlendState.AlphaBlend`
`1060`	`1048`	`);`
`1061`		`- for (var x = ViewRange.Left; x < ViewRange.Right; x++)`
	`1049`	`+ foreach (var (x,y) in ViewRange)`
`1062`	`1050`	`{`
`1063`		`- for (var y = ViewRange.Top; y < ViewRange.Bottom; y++)`
	`1051`	`+ var landTile = LandTiles[x, y];`
	`1052`	`+ if (landTile != null)`
`1064`	`1053`	`{`
`1065`		`- var landTile = LandTiles[x, y];`
`1066`		`- if (landTile != null)`
`1067`		`- {`
`1068`		`- DrawLand(landTile, landTile.ObjectIdColor);`
`1069`		`- }`
	`1054`	`+ DrawLand(landTile, landTile.ObjectIdColor);`
	`1055`	`+ }`
`1070`	`1056`
`1071`		`- var tiles = StaticsManager.Get(x, y);`
`1072`		`- if(tiles == null) continue;`
`1073`		`- foreach (var tile in tiles)`
	`1057`	`+ var tiles = StaticsManager.Get(x, y);`
	`1058`	`+ if(tiles == null) continue;`
	`1059`	`+ foreach (var tile in tiles)`
	`1060`	`+ {`
	`1061`	`+ if (tile.CanDraw)`
`1074`	`1062`	`{`
`1075`		`- if (tile.CanDraw)`
`1076`		`- {`
`1077`		`- DrawStatic(tile, tile.ObjectIdColor);`
`1078`		`- }`
	`1063`	`+ DrawStatic(tile, tile.ObjectIdColor);`
`1079`	`1064`	`}`
`1080`	`1065`	`}`
`1081`	`1066`	`}`
`@@ -1115,7 +1100,7 @@ private void DrawLights(Camera camera)`
`1115`	`1100`	`_mapRenderer.End();`
`1116`	`1101`	`}`
`1117`	`1102`
`1118`		`- private void DrawLand(Camera camera, Rectangle viewRange, string technique = "Terrain")`
	`1103`	`+ private void DrawLand(Camera camera, RectU16 viewRange, string technique = "Terrain")`
`1119`	`1104`	`{`
`1120`	`1105`	`if (!ShowLand)`
`1121`	`1106`	`{`
`@@ -1132,23 +1117,21 @@ private void DrawLand(Camera camera, Rectangle viewRange, string technique = "Te`
`1132`	`1117`	`BlendState.AlphaBlend`
`1133`	`1118`	`);`
`1134`	`1119`
`1135`		`- for (var x = viewRange.Left; x < viewRange.Right; x++)`
	`1120`	`+ foreach (var (x,y) in viewRange)`
`1136`	`1121`	`{`
`1137`		`- for (var y = viewRange.Top; y < viewRange.Bottom; y++)`
	`1122`	`+ var tile = LandTiles[x, y];`
	`1123`	`+ if (tile != null && tile.CanDraw)`
`1138`	`1124`	`{`
`1139`		`- var tile = LandTiles[x, y];`
`1140`		`- if (tile != null && tile.CanDraw)`
	`1125`	`+ var hueOverride = Vector4.Zero;`
	`1126`	`+ if (WalkableSurfaces && !UoFileManager.TileData.LandData[tile.LandTile.Id].IsWet)`
`1141`	`1127`	`{`
`1142`		`- var hueOverride = Vector4.Zero;`
`1143`		`- if (WalkableSurfaces && !UoFileManager.TileData.LandData[tile.LandTile.Id].IsWet)`
`1144`		`- {`
`1145`		`- hueOverride = IsWalkable(tile) ? WalkableHue : NonWalkableHue;`
	`1128`	`+ hueOverride = IsWalkable(tile) ? WalkableHue : NonWalkableHue;`
`1146`	`1129`
`1147`		`- }`
`1148`		`- DrawLand(tile, hueOverride);`
`1149`	`1130`	`}`
	`1131`	`+ DrawLand(tile, hueOverride);`
`1150`	`1132`	`}`
`1151`	`1133`	`}`
	`1134`	`+`
`1152`	`1135`	`foreach (var tile in GhostLandTiles.Values)`
`1153`	`1136`	`{`
`1154`	`1137`	`DrawLand(tile);`
`@@ -1165,15 +1148,12 @@ private void DrawLandHeight()`
`1165`	`1148`	`var font = _fontSystem.GetFont(18 * Camera.Zoom);`
`1166`	`1149`	`var halfTile = TILE_SIZE * 0.5f * Camera.Zoom;`
`1167`	`1150`	`_spriteBatch.Begin();`
`1168`		`- for (var x = ViewRange.Left; x < ViewRange.Right; x++)`
	`1151`	`+ foreach (var (x, y) in ViewRange)`
`1169`	`1152`	`{`
`1170`		`- for (var y = ViewRange.Top; y < ViewRange.Bottom; y++)`
	`1153`	`+ var tile = LandTiles[x, y];`
	`1154`	`+ if (tile != null && tile.CanDraw)`
`1171`	`1155`	`{`
`1172`		`- var tile = LandTiles[x, y];`
`1173`		`- if (tile != null && tile.CanDraw)`
`1174`		`- {`
`1175`		`- DrawTileHeight(tile, font, halfTile);`
`1176`		`- }`
	`1156`	`+ DrawTileHeight(tile, font, halfTile);`
`1177`	`1157`	`}`
`1178`	`1158`	`}`
`1179`	`1159`	`foreach (var tile in GhostLandTiles.Values)`
`@@ -1200,7 +1180,7 @@ private void DrawTileHeight(LandObject tile, DynamicSpriteFont font, float yOffs`
`1200`	`1180`	`}`
`1201`	`1181`	`}`
`1202`	`1182`
`1203`		`- private void DrawStatics(Camera camera, Rectangle viewRange)`
	`1183`	`+ private void DrawStatics(Camera camera, RectU16 viewRange)`
`1204`	`1184`	`{`
`1205`	`1185`	`if (!ShowStatics)`
`1206`	`1186`	`{`
`@@ -1216,23 +1196,20 @@ private void DrawStatics(Camera camera, Rectangle viewRange)`
`1216`	`1196`	`_DepthStencilState,`
`1217`	`1197`	`BlendState.AlphaBlend`
`1218`	`1198`	`);`
`1219`		`- for (var x = viewRange.Left; x < viewRange.Right; x++)`
	`1199`	`+ foreach (var (x,y) in viewRange)`
`1220`	`1200`	`{`
`1221`		`- for (var y = viewRange.Top; y < viewRange.Bottom; y++)`
	`1201`	`+ var tiles = StaticsManager.Get(x, y);`
	`1202`	`+ if(tiles == null) continue;`
	`1203`	`+ foreach (var tile in tiles)`
`1222`	`1204`	`{`
`1223`		`- var tiles = StaticsManager.Get(x, y);`
`1224`		`- if(tiles == null) continue;`
`1225`		`- foreach (var tile in tiles)`
	`1205`	`+ if (tile.CanDraw)`
`1226`	`1206`	`{`
`1227`		`- if (tile.CanDraw)`
	`1207`	`+ var hueOverride = Vector4.Zero;`
	`1208`	`+ if (WalkableSurfaces && UoFileManager.TileData.StaticData[tile.Tile.Id].IsSurface)`
`1228`	`1209`	`{`
`1229`		`- var hueOverride = Vector4.Zero;`
`1230`		`- if (WalkableSurfaces && UoFileManager.TileData.StaticData[tile.Tile.Id].IsSurface)`
`1231`		`- {`
`1232`		`- hueOverride = IsWalkable(tile) ? WalkableHue : NonWalkableHue;`
`1233`		`- }`
`1234`		`- DrawStatic(tile, hueOverride);`
	`1210`	`+ hueOverride = IsWalkable(tile) ? WalkableHue : NonWalkableHue;`
`1235`	`1211`	`}`
	`1212`	`+ DrawStatic(tile, hueOverride);`
`1236`	`1213`	`}`
`1237`	`1214`	`}`
`1238`	`1215`	`}`
`@@ -1303,18 +1280,8 @@ public void ExportImage(string path, int widthPx, int heightPx, float zoom)`
`1303`	`1280`	`myCamera.ScreenSize = new Rectangle(rbounds.X, rbounds.Y, rbounds.Width, rbounds.Height);`
`1304`	`1281`	`myCamera.Update();`
`1305`	`1282`
`1306`		`- CalculateViewRange(myCamera, out var bounds);`
`1307`		`- List<PointU16> requested = new List<PointU16>();`
`1308`		`- for (var x = bounds.Left / 8; x <= bounds.Right / 8; x++)`
`1309`		`- {`
`1310`		`- for (var y = bounds.Top / 8; y <= bounds.Bottom / 8; y++)`
`1311`		`- {`
`1312`		`- requested.Add(new PointU16((ushort)x, (ushort)y));`
`1313`		`- }`
`1314`		`- }`
`1315`		`-`
`1316`		`- Client.ResizeCache(bounds.Width * bounds.Height / 8);`
`1317`		`- Client.RequestBlocks(requested);`
	`1283`	`+ var cameraBounds = CalculateViewRange(myCamera);`
	`1284`	`+ Client.RequestBlocks(cameraBounds);`
`1318`	`1285`	`while(Client.WaitingForBlocks)`
`1319`	`1286`	`Client.Update();`
`1320`	`1287`
`@@ -1327,8 +1294,8 @@ public void ExportImage(string path, int widthPx, int heightPx, float zoom)`
`1327`	`1294`	`_mapEffect.WorldViewProj = myCamera.FnaWorldViewProj;`
`1328`	`1295`	`DrawLights(myCamera);`
`1329`	`1296`	`_mapRenderer.SetRenderTarget(myRenderTarget, new FNARectangle(0,0, widthPx, heightPx));`
`1330`		`- DrawLand(myCamera, bounds);`
`1331`		`- DrawStatics(myCamera, bounds);`
	`1297`	`+ DrawLand(myCamera, cameraBounds);`
	`1298`	`+ DrawStatics(myCamera, cameraBounds);`
`1332`	`1299`	`ApplyLights();`
`1333`	`1300`	`using var fs = new FileStream(path, FileMode.OpenOrCreate);`
`1334`	`1301`	`if(path.EndsWith(".png"))`
Original file line number	Diff line number	Diff line change
`@@ -117,14 +117,12 @@ protected override void InternalDraw()`
`117`	`117`	`if (ImGui.Button(LangManager.Get(DISCONNECT)))`
`118`	`118`	`{`
`119`	`119`	`CEDClient.Disconnect();`
`120`		`- CEDGame.MapManager.Reset();`
`121`	`120`	`}`
`122`	`121`	`}`
`123`	`122`	`else`
`124`	`123`	`{`
`125`	`124`	`if (ImGui.Button(LangManager.Get(CONNECT)) \|\| ImGui.IsWindowFocused() && ImGui.IsKeyPressed(ImGuiKey.Enter))`
`126`	`125`	`{`
`127`		`- CEDGame.MapManager.Reset();`
`128`	`126`	`_buttonDisabled = true;`
`129`	`127`	`new Task`
`130`	`128`	`(`
Original file line number	Diff line number	Diff line change
`@@ -60,6 +60,12 @@ private bool Dequeue(out Block? block)`
`60`	`60`	`return true;`
`61`	`61`	`}`
`62`	`62`
	`63`	`+ public void Grow(int newSize)`
	`64`	`+ {`
	`65`	`+ if (newSize > _maxSize)`
	`66`	`+ Resize(newSize);`
	`67`	`+ }`
	`68`	`+`
`63`	`69`	`public void Resize(int newSize)`
`64`	`70`	`{`
`65`	`71`	`if (newSize < 0)`