From de4c60c4722e1e1166ebcfe00c422e0f6f36f1b8 Mon Sep 17 00:00:00 2001
From: Mark Suckerberg <mark@suckerberg.gay>
Date: Fri, 6 Oct 2023 16:07:00 -0500
Subject: [PATCH] Working camera 2

---
 .run/Blocktest (Local Multiplayer).run.xml    |   3 +-
 Blocktest.sln.DotSettings                     |   6 +-
 Blocktest/BlocktestGame.cs                    |   3 +-
 Blocktest/Code/Block System/BlockSprites.cs   |  17 +--
 Blocktest/Code/Block System/RenderableTile.cs |  66 ++++++++++
 .../Code/Block System/RenderableTilemap.cs    |  60 +++++++++
 Blocktest/Code/Block System/TilemapSprites.cs |  49 -------
 Blocktest/Code/Rendering/Camera.cs            |  65 ++++++++++
 Blocktest/Code/Rendering/Renderable.cs        |  35 +++++
 Blocktest/Code/Scenes/GameScene.cs            | 119 +++++++++++------
 DedicatedServer/Code/WorldHandler.cs          |  16 +--
 Shared/Code/Block System/BlockShared.cs       |   2 +-
 Shared/Code/Block System/TileShared.cs        |  48 +++++++
 Shared/Code/Block System/TilemapShared.cs     | 122 ++----------------
 Shared/Code/Components/Transform.cs           |  30 +++++
 Shared/Code/Math.cs                           |  33 ++++-
 16 files changed, 450 insertions(+), 224 deletions(-)
 create mode 100644 Blocktest/Code/Block System/RenderableTile.cs
 create mode 100644 Blocktest/Code/Block System/RenderableTilemap.cs
 delete mode 100644 Blocktest/Code/Block System/TilemapSprites.cs
 create mode 100644 Blocktest/Code/Rendering/Camera.cs
 create mode 100644 Blocktest/Code/Rendering/Renderable.cs
 create mode 100644 Shared/Code/Block System/TileShared.cs
 create mode 100644 Shared/Code/Components/Transform.cs

diff --git a/.run/Blocktest (Local Multiplayer).run.xml b/.run/Blocktest (Local Multiplayer).run.xml
index f9d1c62..4914f9a 100644
--- a/.run/Blocktest (Local Multiplayer).run.xml	
+++ b/.run/Blocktest (Local Multiplayer).run.xml	
@@ -1,5 +1,6 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="Blocktest (Local Multiplayer)" type="DotNetProject" factoryName=".NET Project">
+  <configuration default="false" name="Blocktest (Local Multiplayer)" type="DotNetProject" factoryName=".NET Project"
+                 singleton="false">
     <option name="EXE_PATH" value="$PROJECT_DIR$/Blocktest/bin/Debug/net7.0/Blocktest.exe" />
     <option name="PROGRAM_PARAMETERS" value="connect 127.0.0.1" />
     <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/Blocktest/bin/Debug/net7.0" />
diff --git a/Blocktest.sln.DotSettings b/Blocktest.sln.DotSettings
index fe185d3..2c6cd24 100644
--- a/Blocktest.sln.DotSettings
+++ b/Blocktest.sln.DotSettings
@@ -1,2 +1,6 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:Boolean x:Key="/Default/UserDictionary/Words/=Blocktest/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
\ No newline at end of file
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Adjacencies/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Blocktest/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Renderable/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=renderables/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Smoothable/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/Blocktest/BlocktestGame.cs b/Blocktest/BlocktestGame.cs
index 8bbe51e..1fa26bd 100644
--- a/Blocktest/BlocktestGame.cs
+++ b/Blocktest/BlocktestGame.cs
@@ -10,7 +10,6 @@ public sealed class BlocktestGame : Game {
     private IScene? _currentScene;
     private GraphicsDeviceManager _graphics;
 
-
     /// <inheritdoc />
     public BlocktestGame() {
         _connect = false;
@@ -18,6 +17,7 @@ public BlocktestGame() {
         Content.RootDirectory = "Content";
         IsMouseVisible = true;
         TargetElapsedTime = TimeSpan.FromMilliseconds(16);
+        Window.AllowUserResizing = true;
     }
 
     public BlocktestGame(string newIp) {
@@ -26,6 +26,7 @@ public BlocktestGame(string newIp) {
         _graphics = new GraphicsDeviceManager(this);
         Content.RootDirectory = "Content";
         IsMouseVisible = true;
+        Window.AllowUserResizing = true;
         TargetElapsedTime = TimeSpan.FromMilliseconds(16);
     }
 
diff --git a/Blocktest/Code/Block System/BlockSprites.cs b/Blocktest/Code/Block System/BlockSprites.cs
index 32ef2c3..45c167d 100644
--- a/Blocktest/Code/Block System/BlockSprites.cs	
+++ b/Blocktest/Code/Block System/BlockSprites.cs	
@@ -7,7 +7,7 @@ namespace Blocktest.Block_System;
 /// </summary>
 public sealed class BlockSprites {
     /// <summary> Shared block info </summary>
-    public BlockShared BlockShared;
+    private readonly BlockShared _blockShared;
 
     /// <summary> The block's sprite. </summary>
     public Drawable BlockSprite;
@@ -18,7 +18,7 @@ public sealed class BlockSprites {
     /* METHODS */
 
     public BlockSprites(BlockShared newBlockShared) {
-        BlockShared = newBlockShared;
+        _blockShared = newBlockShared;
         LoadSprite();
     }
 
@@ -29,27 +29,24 @@ public BlockSprites(BlockShared newBlockShared) {
     ///     DO NOT FORGET TO CALL THE BASE METHOD IF YOU OVERRIDE THIS.
     /// </remarks>
     public void LoadSprite() {
-        string path = @"Graphics\Blocks\" + BlockShared.BlockName.ToLower().Replace(" ", "");
+        string path = @"Graphics\Blocks\" + _blockShared.BlockName.ToLower().Replace(" ", "");
         try {
             BlockSprite =
                 new Drawable(path,
                     new Rectangle(1, 1, 10,
                         10)); //this might need to be expanded in the future in case we decide to make use of the full 12x12 tiles on our spritesheets
-            if (!BlockShared.BlockSmoothing) {
+            if (!_blockShared.BlockSmoothing) {
                 return;
             }
             SpriteSheet = new SpriteSheet(path, 4, 4, 1);
             if (SpriteSheet.OrderedSprites.Length <= 1) {
-                Console.WriteLine("Block " +
-                                  this +
-                                  " is marked as smoothable, but a sprite sheet could not be found at " +
-                                  path +
-                                  "!");
+                Console.WriteLine(
+                    $"Block {this} is marked as smoothable, but a sprite sheet could not be found at {path}!");
             }
         }
         catch (ContentLoadException) {
             BlockSprite = new Drawable(@"Graphics\Blocks\error");
-            Console.WriteLine("Block " + this + " does not have an icon at " + path + "!");
+            Console.WriteLine($"Block {this} does not have a sprite at {path}!");
         }
     }
 }
\ No newline at end of file
diff --git a/Blocktest/Code/Block System/RenderableTile.cs b/Blocktest/Code/Block System/RenderableTile.cs
new file mode 100644
index 0000000..348ac7a
--- /dev/null
+++ b/Blocktest/Code/Block System/RenderableTile.cs	
@@ -0,0 +1,66 @@
+using Blocktest.Rendering;
+using Shared.Code;
+using Shared.Code.Block_System;
+namespace Blocktest.Block_System;
+
+public class RenderableTile : TileShared {
+    public readonly Renderable Renderable;
+
+    public RenderableTile(TileShared tile, bool background) : base(tile.SourceBlock,
+        tile.Transform.Position / GlobalsShared.GridSize) {
+        Renderable = new Renderable(Transform, background ? Layer.BackgroundBlocks : Layer.ForegroundBlocks,
+            BlockSpritesManager.AllBlocksSprites[tile.SourceBlock.BlockId].BlockSprite, tile.Color);
+    }
+
+    /// <summary>
+    ///     This method is called whenever an adjacent (according to a tilemap's adjacency variable) tile is placed or removed.
+    ///     Used for smoothing.
+    /// </summary>
+    /// <param name="position">The position of the current tile.</param>
+    /// <param name="tilemap">The tilemap the tile is on.</param>
+    public void UpdateAdjacencies(Vector2Int position, TilemapShared tilemap) {
+        if (!SourceBlock.BlockSmoothing) {
+            return;
+        } // If the tile doesn't smooth, don't even try
+
+        int bitmask = 0; // Uses bitmask smoothing, look it up
+
+        if (HasSmoothableTile(position + Vector2Int.Up, tilemap)) {
+            bitmask += 1;
+        }
+        if (HasSmoothableTile(position + Vector2Int.Down, tilemap)) {
+            bitmask += 2;
+        }
+        if (HasSmoothableTile(position + Vector2Int.Right, tilemap)) {
+            bitmask += 4;
+        }
+        if (HasSmoothableTile(position + Vector2Int.Left, tilemap)) {
+            bitmask += 8;
+        }
+
+        Renderable.Appearance = BlockSpritesManager.AllBlocksSprites[SourceBlock.BlockId].SpriteSheet
+            .OrderedSprites[bitmask];
+    }
+
+    /// <summary>
+    ///     Whether or not the tile at a certain <paramref name="position" /> can smooth with this tile.
+    /// </summary>
+    /// <param name="position">The position of the tile to check for smoothing.</param>
+    /// <param name="tilemap">The tilemap on which the tile you want to check for smoothing is.</param>
+    /// <returns>Whether or not the tile can smooth with this tile.</returns>
+    private bool HasSmoothableTile(Vector2Int position, TilemapShared tilemap) {
+        if (tilemap.TryGetTile(position, out TileShared? tile)) {
+            return SourceBlock.SmoothSelf
+                ? IsSameTileType(tile)
+                : tile.SourceBlock.BlockId != 0; // Don't smooth with air, possibly find nicer way to do this later.
+        }
+        return false;
+    }
+
+    /// <summary>
+    ///     If the tile provided is the same type (references the same block) as the current tile.
+    /// </summary>
+    /// <param name="otherTile">The other tile to check.</param>
+    /// <returns>Whether or not the other block is the same type as the current tile</returns>
+    private bool IsSameTileType(TileShared otherTile) => otherTile.SourceBlock == SourceBlock;
+}
\ No newline at end of file
diff --git a/Blocktest/Code/Block System/RenderableTilemap.cs b/Blocktest/Code/Block System/RenderableTilemap.cs
new file mode 100644
index 0000000..21e45b0
--- /dev/null
+++ b/Blocktest/Code/Block System/RenderableTilemap.cs	
@@ -0,0 +1,60 @@
+using Blocktest.Rendering;
+using Shared.Code;
+using Shared.Code.Block_System;
+namespace Blocktest.Block_System;
+
+public class RenderableTilemap {
+    private readonly TilemapShared _tilemap;
+
+    private readonly RenderableTile[,] _renderables;
+    private readonly Camera _camera;
+
+    /// <summary>
+    ///     A list of <see cref="Vector2Int" />s that specify which blocks should be refreshed when a tile is placed/destroyed.
+    ///     Defaults to the changed block and all cardinal directions.
+    /// </summary>
+    private static readonly List<Vector2Int> Adjacencies = new()
+        { Vector2Int.Zero, Vector2Int.Up, Vector2Int.Down, Vector2Int.Left, Vector2Int.Right };
+
+
+    public RenderableTilemap(TilemapShared newTilemap, Camera camera) {
+        _tilemap = newTilemap;
+        _camera = camera;
+        _renderables = new RenderableTile[_tilemap.TilemapSize.X, _tilemap.TilemapSize.Y];
+        UpdateRenderables();
+        newTilemap.OnTileChanged += OnTilemapChanged;
+    }
+
+    private void OnTilemapChanged(TileShared tile, Vector2Int location) {
+        _camera.RenderedComponents.Remove(_renderables[location.X, location.Y].Renderable);
+
+        foreach (Vector2Int dir in Adjacencies) {
+            if (location.X + dir.X < 0 ||
+                location.X + dir.X >= _tilemap.TilemapSize.X ||
+                location.Y + dir.Y < 0 ||
+                location.Y + dir.Y >= _tilemap.TilemapSize.Y) {
+                continue;
+            }
+            _renderables[location.X + dir.X, location.Y + dir.Y].UpdateAdjacencies(location + dir, _tilemap);
+        }
+
+        RenderableTile newTile = new RenderableTile(tile, _tilemap.Background);
+        _renderables[location.X, location.Y] = newTile;
+        newTile.UpdateAdjacencies(location, _tilemap);
+        _camera.RenderedComponents.Add(newTile.Renderable);
+    }
+
+    private void UpdateRenderables() {
+        _camera.RenderedComponents.Clear();
+        for (int x = 0; x < _tilemap.TilemapSize.X; x++)
+        for (int y = 0; y < _tilemap.TilemapSize.Y; y++) {
+            if (!_tilemap.TryGetTile(new Vector2Int(x, y), out TileShared? tile)) {
+                continue;
+            }
+            RenderableTile newTile = new RenderableTile(tile, _tilemap.Background);
+            _renderables[x, y] = newTile;
+            _camera.RenderedComponents.Add(newTile.Renderable);
+            newTile.UpdateAdjacencies(new Vector2Int(x, y), _tilemap);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Blocktest/Code/Block System/TilemapSprites.cs b/Blocktest/Code/Block System/TilemapSprites.cs
deleted file mode 100644
index 5fc7615..0000000
--- a/Blocktest/Code/Block System/TilemapSprites.cs	
+++ /dev/null
@@ -1,49 +0,0 @@
-using Blocktest.Rendering;
-using Shared.Code;
-using Shared.Code.Block_System;
-namespace Blocktest.Block_System;
-
-/// <summary>
-///     Handles drawing <see cref="TilemapShared" />.
-/// </summary>
-public sealed class TilemapSprites {
-    public TilemapShared Tilemap;
-
-    /// <summary>
-    ///     Creates a <see cref="Tilemap" />.
-    /// </summary>
-    /// <param name="sizeX">The width of the tilemap in tiles.</param>
-    /// <param name="sizeY">The height of the tilemap in tiles.</param>
-    public TilemapSprites(TilemapShared newTilemap) {
-        Tilemap = newTilemap;
-    }
-
-    /// <summary>
-    ///     Called from the main draw loop, draws each tile in the tilemap.
-    /// </summary>
-    /// <remarks>
-    ///     This can almost definitely be optimized, but I'm focused on getting a decent version out
-    ///     quickly so the codebase split causes fewer issues for others.
-    ///     </remark>
-    ///     <param name="spriteBatch">The spritebatch to draw the tilemap tiles' sprite on.</param>
-    public void DrawAllTiles(SpriteBatch spriteBatch) {
-        for (int x = 0; x < Tilemap.TilemapSize.X; x++) {
-            for (int y = 0; y < Tilemap.TilemapSize.Y; y++) {
-                if (!Tilemap.TryGetTile(new Vector2Int(x, y), out TileShared? tile)) {
-                    continue;
-                }
-                BlockSprites blockSprites = BlockSpritesManager.AllBlocksSprites[tile.SourceBlock.BlockId];
-                Drawable sprite = tile.SourceBlock.BlockSmoothing
-                    ? blockSprites.SpriteSheet.OrderedSprites[tile.Bitmask]
-                    : blockSprites.BlockSprite;
-                spriteBatch.Draw(sprite.Texture, new Vector2(tile.Rectangle.X, tile.Rectangle.Y), sprite.Bounds,
-                    tile.Color);
-            }
-        }
-        /*foreach (TileShared tile in tilemap.allTiles) {
-            BlockSprites blockSprites = BlockSpritesManager.AllBlocksSprites[tile.SourceBlock.blockID];
-            Drawable sprite = blockSprites.spriteSheet.OrderedSprites[tile.bitmask];
-            spriteBatch.Draw(sprite.Texture, new Vector2(tile.rectangle.X, tile.rectangle.Y), sprite.Bounds, tile.color);
-        }*/
-    }
-}
\ No newline at end of file
diff --git a/Blocktest/Code/Rendering/Camera.cs b/Blocktest/Code/Rendering/Camera.cs
new file mode 100644
index 0000000..958170f
--- /dev/null
+++ b/Blocktest/Code/Rendering/Camera.cs
@@ -0,0 +1,65 @@
+namespace Blocktest.Rendering;
+
+public sealed class Camera {
+    private readonly Color _backgroundColor;
+    private readonly Vector2 _size;
+
+    public readonly List<Renderable> RenderedComponents = new();
+
+    public Rectangle RenderLocation;
+    public readonly RenderTarget2D RenderTarget;
+    public Vector2 Position;
+
+    public Camera(Vector2 position, Vector2 size, GraphicsDevice graphicsDevice, Color? backgroundColor = null) {
+        Position = position;
+        _size = size;
+        _backgroundColor = backgroundColor ?? Color.CornflowerBlue;
+        RenderTarget = new RenderTarget2D(graphicsDevice, (int)size.X, (int)size.Y, false, SurfaceFormat.Color,
+            DepthFormat.None, 0, RenderTargetUsage.DiscardContents);
+    }
+
+    public void Draw(GraphicsDevice graphics, SpriteBatch spriteBatch) {
+        graphics.SetRenderTarget(RenderTarget);
+        graphics.Clear(_backgroundColor);
+
+        spriteBatch.Begin();
+
+        foreach (Renderable component in RenderedComponents) {
+            if (component.Appearance == null) {
+                continue;
+            }
+
+            Vector2 worldPosition = component.Transform.Position;
+            Vector2 cameraPosition = worldPosition - Position;
+
+            if (worldPosition.X + component.Appearance.Bounds.Width < Position.X &&
+                worldPosition.X > Position.X + _size.X &&
+                worldPosition.Y + component.Appearance.Bounds.Height < Position.Y &&
+                worldPosition.Y > Position.Y + _size.Y) {
+                continue;
+            }
+
+            Vector2 flippedPosition = new(cameraPosition.X,
+                RenderTarget.Height - cameraPosition.Y - component.Appearance.Bounds.Height);
+
+            Rectangle positionBounds = new((int)flippedPosition.X, (int)flippedPosition.Y,
+                (int)(component.Appearance.Bounds.Width * component.Transform.Scale.X),
+                (int)(component.Appearance.Bounds.Height * component.Transform.Scale.Y));
+
+            spriteBatch.Draw(component.Appearance.Texture, positionBounds, component.Appearance.Bounds,
+                component.RenderColor, component.Transform.Rotation, component.Transform.Origin, SpriteEffects.None,
+                (float)component.Layer / EnumCount);
+        }
+
+        spriteBatch.End();
+
+        graphics.SetRenderTarget(null);
+    }
+
+    private static readonly int EnumCount = Enum.GetValues(typeof(Layer)).Length;
+
+    public Vector2 CameraToWorldPos(Vector2 mouseState) => new(
+        (mouseState.X - RenderLocation.X) / RenderLocation.Width * RenderTarget.Width + Position.X, Position.Y +
+        RenderTarget.Height -
+        (mouseState.Y - RenderLocation.Y) / RenderLocation.Height * RenderTarget.Height);
+}
\ No newline at end of file
diff --git a/Blocktest/Code/Rendering/Renderable.cs b/Blocktest/Code/Rendering/Renderable.cs
new file mode 100644
index 0000000..223eca6
--- /dev/null
+++ b/Blocktest/Code/Rendering/Renderable.cs
@@ -0,0 +1,35 @@
+using Shared.Code.Components;
+namespace Blocktest.Rendering;
+
+public enum Layer {
+    Top = 0,
+    Player = 1,
+    Default = 2,
+    ForegroundBlocks = 3,
+    BackgroundBlocks = 4
+}
+
+public sealed class Renderable {
+    public readonly Transform Transform;
+    public Drawable? Appearance;
+    public Color RenderColor;
+    public Layer Layer;
+
+    public Renderable(Transform transform, Layer layer = Layer.Default, Drawable? appearance = null,
+                      Color? renderColor = null) {
+        Transform = transform;
+        Layer = layer;
+        Appearance = appearance;
+        RenderColor = renderColor ?? Color.White;
+    }
+
+    public void Draw(SpriteBatch spriteBatch, Vector2 cameraPosition) {
+        if (Appearance == null) {
+            return;
+        }
+
+        spriteBatch.Draw(Appearance.Texture, Transform.Position - cameraPosition, Appearance.Bounds, RenderColor,
+            Transform.Rotation, Transform.Origin, Transform.Scale,
+            SpriteEffects.None, 0);
+    }
+}
\ No newline at end of file
diff --git a/Blocktest/Code/Scenes/GameScene.cs b/Blocktest/Code/Scenes/GameScene.cs
index 731b333..a57a60f 100644
--- a/Blocktest/Code/Scenes/GameScene.cs
+++ b/Blocktest/Code/Scenes/GameScene.cs
@@ -1,6 +1,7 @@
 using Blocktest.Block_System;
 using Blocktest.Misc;
 using Blocktest.Networking;
+using Blocktest.Rendering;
 using Microsoft.Xna.Framework.Input;
 using Shared.Code;
 using Shared.Code.Block_System;
@@ -8,10 +9,7 @@
 namespace Blocktest.Scenes;
 
 public sealed class GameScene : IScene {
-    private readonly TilemapSprites _backgroundTilemapSprites;
     private readonly bool _connect;
-
-    private readonly TilemapSprites _foregroundTilemapSprites;
     private readonly FrameCounter _frameCounter = new();
     private readonly BlocktestGame _game;
     private readonly Client _networkingClient;
@@ -19,20 +17,27 @@ public sealed class GameScene : IScene {
     private readonly SpriteFont _spriteFont;
     private int _blockSelected = 1; //ID of the block to place
 
+    private readonly RenderableTilemap _backgroundTilemapSprites;
+    private readonly RenderableTilemap _foregroundTilemapSprites;
+    
     private bool _buildMode = true; //true for build, false for destroy
 
     private KeyboardState _previousKeyboardState;
 
+    private readonly Camera _camera;
+
     public GameScene(BlocktestGame game, bool doConnect, string? ip) {
         _connect = doConnect;
         _spriteBatch = new SpriteBatch(game.GraphicsDevice);
         _spriteFont = game.Content.Load<SpriteFont>("Fonts/OpenSans");
         _game = game;
 
-        GlobalsShared.BackgroundTilemap = new TilemapShared(GlobalsShared.MaxX, GlobalsShared.MaxY);
-        GlobalsShared.ForegroundTilemap = new TilemapShared(GlobalsShared.MaxX, GlobalsShared.MaxY);
-        _backgroundTilemapSprites = new TilemapSprites(GlobalsShared.BackgroundTilemap);
-        _foregroundTilemapSprites = new TilemapSprites(GlobalsShared.ForegroundTilemap);
+        _camera = new Camera(Vector2.Zero, new Vector2(512, 256), game.GraphicsDevice);
+
+        GlobalsShared.BackgroundTilemap = new TilemapShared(GlobalsShared.MaxX, GlobalsShared.MaxY, true);
+        GlobalsShared.ForegroundTilemap = new TilemapShared(GlobalsShared.MaxX, GlobalsShared.MaxY, false);
+        _backgroundTilemapSprites = new RenderableTilemap(GlobalsShared.BackgroundTilemap, _camera);
+        _foregroundTilemapSprites = new RenderableTilemap(GlobalsShared.ForegroundTilemap, _camera);
         _networkingClient = new Client();
 
         if (_connect && ip != null) {
@@ -44,12 +49,12 @@ public GameScene(BlocktestGame game, bool doConnect, string? ip) {
 
         int[,,] newWorld = new int[GlobalsShared.MaxX, GlobalsShared.MaxY, 2];
         for (int i = 0; i < GlobalsShared.MaxX; i++) {
-            newWorld[i, 59, 1] = 4;
-            newWorld[i, 58, 1] = 2;
-            newWorld[i, 57, 1] = 2;
-            newWorld[i, 56, 1] = 2;
-            newWorld[i, 55, 1] = 2;
-            newWorld[i, 54, 1] = 3;
+            newWorld[i, 0, 1] = 4;
+            newWorld[i, 1, 1] = 2;
+            newWorld[i, 2, 1] = 2;
+            newWorld[i, 3, 1] = 2;
+            newWorld[i, 4, 1] = 2;
+            newWorld[i, 5, 1] = 3;
         }
         testDownload.World = newWorld;
         testDownload.TickNum = 1;
@@ -72,7 +77,7 @@ public void Update(GameTime gameTime) {
         
         _networkingClient.ClientTickBuffer.IncrCurrTick();
 
-        if (!CheckWindowActive(currentMouseState)) {
+        if (!_game.IsActive) {
             return;
         }
 
@@ -91,19 +96,36 @@ public void Update(GameTime gameTime) {
             }
         }
 
-        
+        float moveValue = 2.5f;
+        if (currentKeyboardState.IsKeyDown(Keys.LeftShift) || currentKeyboardState.IsKeyDown(Keys.RightShift)) {
+            moveValue *= 4;
+        }
+
+        if (currentKeyboardState.IsKeyDown(Keys.A)) {
+            _camera.Position.X -= moveValue;
+        } else if (currentKeyboardState.IsKeyDown(Keys.D)) {
+            _camera.Position.X += moveValue;
+        }
 
+        if (currentKeyboardState.IsKeyDown(Keys.W)) {
+            _camera.Position.Y += moveValue;
+        } else if (currentKeyboardState.IsKeyDown(Keys.S)) {
+            _camera.Position.Y -= moveValue;
+        }
+        
         _previousKeyboardState = currentKeyboardState;
 
         if (currentMouseState.LeftButton != ButtonState.Pressed &&
-            currentMouseState.RightButton != ButtonState.Pressed) {
+            currentMouseState.RightButton != ButtonState.Pressed ||
+            !_camera.RenderLocation.Contains(currentMouseState.Position)) {
             return;
         }
 
         bool foreground = currentMouseState.LeftButton == ButtonState.Pressed;
+        Vector2 mousePos = _camera.CameraToWorldPos(currentMouseState.Position.ToVector2());
         Vector2Int tilePos = new Vector2Int(
-            MathHelper.Clamp(currentMouseState.X / GlobalsShared.GridSize.X, 0, GlobalsShared.MaxX),
-            MathHelper.Clamp(currentMouseState.Y / GlobalsShared.GridSize.Y, 0, GlobalsShared.MaxY));
+            Math.Clamp((int)mousePos.X / GlobalsShared.GridSize.X, 0, GlobalsShared.MaxX),
+            Math.Clamp((int)mousePos.Y / GlobalsShared.GridSize.Y, 0, GlobalsShared.MaxY));
 
         if (_buildMode) {
             TileChange testChange = new() {
@@ -134,11 +156,18 @@ public void Update(GameTime gameTime) {
     public void Draw(GameTime gameTime, GraphicsDevice graphicsDevice) {
         graphicsDevice.Clear(Color.CornflowerBlue);
 
-        _spriteBatch.Begin();
+        _camera.Draw(graphicsDevice, _spriteBatch);
+
+        const bool pixelPerfect = false;
+
+        Rectangle destinationRectangle = pixelPerfect ? GetPixelPerfectRect() : GetFitRect();
+        _camera.RenderLocation = destinationRectangle;
 
-        _backgroundTilemapSprites.DrawAllTiles(_spriteBatch);
-        _foregroundTilemapSprites.DrawAllTiles(_spriteBatch);
+        graphicsDevice.Clear(Color.DarkGray);
 
+        _spriteBatch.Begin(samplerState: pixelPerfect ? SamplerState.PointClamp : null);
+        _spriteBatch.Draw(_camera.RenderTarget, destinationRectangle, Color.White);
+        
         float deltaTime = (float)gameTime.ElapsedGameTime.TotalSeconds;
 
         _frameCounter.Update(deltaTime);
@@ -151,26 +180,42 @@ public void Draw(GameTime gameTime, GraphicsDevice graphicsDevice) {
             _spriteBatch.DrawString(_spriteFont, ping, new Vector2(10, 30), Color.Black);
         }
 
-        if (_buildMode) {
-            _spriteBatch.Draw(BlockSpritesManager.AllBlocksSprites[_blockSelected].BlockSprite.Texture,
-                new Vector2Int(Mouse.GetState().X - Mouse.GetState().X % 8,
-                    Mouse.GetState().Y - Mouse.GetState().Y % 8),
-                new Rectangle(1, 1, 10, 10), Color.DimGray);
-        }
-
         _spriteBatch.End();
     }
 
-    public void EndScene() {
-        _networkingClient.Stop();
+    private Rectangle GetPixelPerfectRect() {
+        int multiplier = int.Min(_game.GraphicsDevice.Viewport.Height / _camera.RenderTarget.Height,
+            _game.GraphicsDevice.Viewport.Width / _camera.RenderTarget.Width);
+
+        int width = _camera.RenderTarget.Width * multiplier;
+        int height = _camera.RenderTarget.Height * multiplier;
+
+        int x = (_game.GraphicsDevice.Viewport.Width - width) / 2;
+        int y = (_game.GraphicsDevice.Viewport.Height - height) / 2;
+
+        return new Rectangle(x, y, width, height);
     }
 
-    /// <summary>
-    ///     Checks if the window is active and the mouse is within the window.
-    /// </summary>
-    /// <param name="mouse">The current state of the mouse</param>
-    /// <returns>True if the window is active and the mouse is within the window.</returns>
-    private bool CheckWindowActive(MouseState mouse) {
-        return _game.IsActive && _game.GraphicsDevice.Viewport.Bounds.Contains(mouse.Position);
+    private Rectangle GetFitRect() {
+        float aspectRatio = (float)_game.GraphicsDevice.Viewport.Width / _game.GraphicsDevice.Viewport.Height;
+        float renderTargetAspectRatio = (float)_camera.RenderTarget.Width / _camera.RenderTarget.Height;
+
+        int width, height;
+        if (aspectRatio > renderTargetAspectRatio) {
+            width = (int)(_game.GraphicsDevice.Viewport.Height * renderTargetAspectRatio);
+            height = _game.GraphicsDevice.Viewport.Height;
+        } else {
+            width = _game.GraphicsDevice.Viewport.Width;
+            height = (int)(_game.GraphicsDevice.Viewport.Width / renderTargetAspectRatio);
+        }
+
+        int x = (_game.GraphicsDevice.Viewport.Width - width) / 2;
+        int y = (_game.GraphicsDevice.Viewport.Height - height) / 2;
+
+        return new Rectangle(x, y, width, height);
+    }
+    
+    public void EndScene() {
+        _networkingClient.Stop();
     }
 }
\ No newline at end of file
diff --git a/DedicatedServer/Code/WorldHandler.cs b/DedicatedServer/Code/WorldHandler.cs
index e39c24e..6c10ffb 100644
--- a/DedicatedServer/Code/WorldHandler.cs
+++ b/DedicatedServer/Code/WorldHandler.cs
@@ -23,18 +23,18 @@ internal sealed class WorldHandler {
 
     public WorldHandler() {
         BlockManagerShared.Initialize();
-        GlobalsShared.BackgroundTilemap = new TilemapShared(GlobalsShared.MaxX, GlobalsShared.MaxY);
-        GlobalsShared.ForegroundTilemap = new TilemapShared(GlobalsShared.MaxX, GlobalsShared.MaxY);
+        GlobalsShared.BackgroundTilemap = new TilemapShared(GlobalsShared.MaxX, GlobalsShared.MaxY, true);
+        GlobalsShared.ForegroundTilemap = new TilemapShared(GlobalsShared.MaxX, GlobalsShared.MaxY, false);
 
 
         int[,,] newWorld = new int[GlobalsShared.MaxX, GlobalsShared.MaxY, 2];
         for (int i = 0; i < GlobalsShared.MaxX; i++) {
-            newWorld[i, 59, 1] = 4;
-            newWorld[i, 58, 1] = 2;
-            newWorld[i, 57, 1] = 2;
-            newWorld[i, 56, 1] = 2;
-            newWorld[i, 55, 1] = 2;
-            newWorld[i, 54, 1] = 3;
+            newWorld[i, 0, 1] = 4;
+            newWorld[i, 1, 1] = 2;
+            newWorld[i, 2, 1] = 2;
+            newWorld[i, 3, 1] = 2;
+            newWorld[i, 4, 1] = 2;
+            newWorld[i, 5, 1] = 3;
         }
         WorldDownload testDownload = new() {
             World = newWorld,
diff --git a/Shared/Code/Block System/BlockShared.cs b/Shared/Code/Block System/BlockShared.cs
index b3bb945..a73ff12 100644
--- a/Shared/Code/Block System/BlockShared.cs	
+++ b/Shared/Code/Block System/BlockShared.cs	
@@ -21,7 +21,7 @@ public abstract class BlockShared {
     /// <summary> Whether or not a block smooths only with itself </summary>
     /// <remarks> (Use normal 8x8 sprites to prevent overlap) </remarks>
     public bool SmoothSelf = false;
-
+    
     /* METHODS */
 
     /// <summary>
diff --git a/Shared/Code/Block System/TileShared.cs b/Shared/Code/Block System/TileShared.cs
new file mode 100644
index 0000000..948ecc1
--- /dev/null
+++ b/Shared/Code/Block System/TileShared.cs	
@@ -0,0 +1,48 @@
+using LiteNetLib.Utils;
+using Microsoft.Xna.Framework;
+using Shared.Code.Components;
+namespace Shared.Code.Block_System;
+
+/// <summary>
+///     A <see cref="TilemapShared" /> is filled with tile instances, one for each grid square.
+///     They contain basic information such as name and sprite, but the behaviours and more advanced properties are found
+///     in the correlating Block classes.
+/// </summary>
+public class TileShared : INetSerializable {
+    /// <summary>
+    ///     Color of the tile.
+    /// </summary>
+    public Color Color = Color.White;
+
+    /// <summary>
+    ///     The type of block this tile is.
+    /// </summary>
+    public readonly BlockShared SourceBlock;
+
+    public readonly Transform Transform;
+
+    /// <summary>
+    ///     Creates a <see cref="TileShared" />.
+    /// </summary>
+    /// <param name="newBlock">The type of block the new tile should be.</param>
+    /// <param name="position">The position in a tilemap the tile will be.</param>
+    public TileShared(BlockShared newBlock, Vector2Int position) {
+        SourceBlock = newBlock;
+        Transform = new Transform(new Vector2Int(GlobalsShared.GridSize.X * position.X,
+            GlobalsShared.GridSize.Y * position.Y));
+    }
+
+    public void Serialize(NetDataWriter writer) {
+        writer.Put(Color.R);
+        writer.Put(Color.G);
+        writer.Put(Color.B);
+        writer.Put(Transform);
+        writer.Put(SourceBlock.BlockId);
+    }
+
+    public void Deserialize(NetDataReader reader) {
+        Color = new Color(reader.GetByte(), reader.GetByte(), reader.GetByte());
+        Transform.Deserialize(reader);
+        SourceBlock.BlockId = reader.GetInt();
+    }
+}
\ No newline at end of file
diff --git a/Shared/Code/Block System/TilemapShared.cs b/Shared/Code/Block System/TilemapShared.cs
index 4a019d4..2f25188 100644
--- a/Shared/Code/Block System/TilemapShared.cs	
+++ b/Shared/Code/Block System/TilemapShared.cs	
@@ -1,19 +1,10 @@
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using Microsoft.Xna.Framework;
+using System.Diagnostics.CodeAnalysis;
 namespace Shared.Code.Block_System;
 
 /// <summary>
 ///     A grid filled with <see cref="TileShared" />s, usually representing terrain.
 /// </summary>
 public sealed class TilemapShared {
-    /// <summary>
-    ///     A list of <see cref="Vector2Int" />s that specify which blocks should be refreshed when a tile is placed/destroyed.
-    ///     Defaults to the changed block and all cardinal directions.
-    /// </summary>
-    private static readonly List<Vector2Int> Adjacencies = new()
-        { Vector2Int.Zero, Vector2Int.Up, Vector2Int.Down, Vector2Int.Left, Vector2Int.Right };
-
     /// <summary>
     ///     The size of each cell (in pixels) in the tilemap's grid.
     /// </summary>
@@ -27,7 +18,11 @@ public sealed class TilemapShared {
     /// <summary>
     ///     The 2D array of all tiles in the tilemap.
     /// </summary>
-    public TileShared?[,] TileGrid;
+    public readonly TileShared?[,] TileGrid;
+
+    public bool Background;
+
+    public event Action<TileShared, Vector2Int>? OnTileChanged;
 
 
     /// <summary>
@@ -35,7 +30,7 @@ public sealed class TilemapShared {
     /// </summary>
     /// <param name="sizeX">The width of the tilemap in tiles.</param>
     /// <param name="sizeY">The height of the tilemap in tiles.</param>
-    public TilemapShared(int sizeX, int sizeY) {
+    public TilemapShared(int sizeX, int sizeY, bool background) {
         TilemapSize = new Vector2Int(sizeX, sizeY);
         TileGrid = new TileShared[sizeX, sizeY];
         for (int x = 0; x < sizeX; x++) {
@@ -43,6 +38,7 @@ public TilemapShared(int sizeX, int sizeY) {
                 TileGrid[x, y] = new TileShared(BlockManagerShared.AllBlocks[0], new Vector2Int(x, y)); //Fill with air
             }
         }
+        Background = background;
     }
 
     /// <summary>
@@ -61,15 +57,7 @@ public TileShared SetBlock(Vector2Int location, BlockShared newBlock) =>
     public TileShared SetTile(Vector2Int location, TileShared newTile) {
         TileGrid[location.X, location.Y] = newTile;
 
-        foreach (Vector2Int dir in Adjacencies) {
-            if (location.X + dir.X < 0 ||
-                location.X + dir.X >= TilemapSize.X ||
-                location.Y + dir.Y < 0 ||
-                location.Y + dir.Y >= TilemapSize.Y) {
-                continue;
-            }
-            TileGrid[location.X + dir.X, location.Y + dir.Y]?.UpdateAdjacencies(location + dir, this);
-        }
+        OnTileChanged?.Invoke(newTile, location);
 
         return newTile;
     }
@@ -88,96 +76,4 @@ public bool TryGetTile<T>(Vector2Int location, [NotNullWhen(true)] out T? result
         result = TileGrid[location.X, location.Y] as T;
         return result != null;
     }
-}
-
-/// <summary>
-///     A <see cref="TilemapShared" /> is filled with tile instances, one for each grid square.
-///     They contain basic information such as name and sprite, but the behaviours and more advanced properties are found
-///     in the correlating Block classes.
-/// </summary>
-public class TileShared {
-    /// <summary>
-    ///     Used for bitmask smoothing, should MAYBE not be here.
-    /// </summary>
-    public byte Bitmask;
-
-    /// <summary>
-    ///     Color of the tile.
-    /// </summary>
-    public Color Color = Color.White;
-
-    /// <summary>
-    ///     The rectangle of the tile, used for sprite rendering and collisions.
-    /// </summary>
-    public Rectangle Rectangle;
-
-    /// <summary>
-    ///     The size of the tile square's edges, in pixels (Default 8)
-    /// </summary>
-    protected byte Size = 8;
-
-    /// <summary>
-    ///     The type of block this tile is.
-    /// </summary>
-    public BlockShared SourceBlock;
-
-    /// <summary>
-    ///     Creates a <see cref="TileShared" />.
-    /// </summary>
-    /// <param name="newBlock">The type of block the new tile should be.</param>
-    /// <param name="position">The position in a tilemap the tile will be.</param>
-    public TileShared(BlockShared newBlock, Vector2Int position) {
-        SourceBlock = newBlock;
-        Rectangle = new Rectangle(GlobalsShared.GridSize.X * position.X, GlobalsShared.GridSize.Y * position.Y, Size,
-            Size); // TODO: This can probably be done better
-    }
-
-    /// <summary>
-    ///     This method is called whenever an adjacent (according to a tilemap's adjacency variable) tile is placed or removed.
-    ///     Used for smoothing.
-    /// </summary>
-    /// <param name="position">The position of the current tile.</param>
-    /// <param name="tilemap">The tilemap the tile is on.</param>
-    public void UpdateAdjacencies(Vector2Int position, TilemapShared tilemap) {
-        if (!SourceBlock.BlockSmoothing) {
-            return;
-        } // If the tile doesn't smooth, don't even try
-
-        Bitmask = 0; // Uses bitmask smoothing, look it up
-
-        if (HasSmoothableTile(position + Vector2Int.Up, tilemap)) {
-            Bitmask += 2;
-        }
-        if (HasSmoothableTile(position + Vector2Int.Down, tilemap)) {
-            Bitmask += 1;
-        }
-        if (HasSmoothableTile(position + Vector2Int.Right, tilemap)) {
-            Bitmask += 4;
-        }
-        if (HasSmoothableTile(position + Vector2Int.Left, tilemap)) {
-            Bitmask += 8;
-        }
-    }
-
-    /// <summary>
-    ///     Whether or not the tile at a certain <paramref name="position" /> can smooth with this tile.
-    /// </summary>
-    /// <param name="position">The position of the tile to check for smoothing.</param>
-    /// <param name="tilemap">The tilemap on which the tile you want to check for smoothing is.</param>
-    /// <returns>Whether or not the tile can smooth with this tile.</returns>
-    private bool HasSmoothableTile(Vector2Int position, TilemapShared tilemap) {
-        if (tilemap.TryGetTile(position, out TileShared? tile)) {
-            return SourceBlock.SmoothSelf
-                ? IsSameTileType(tile)
-                : tile.SourceBlock.BlockId != 0; // Don't smooth with air, possibly find nicer way to do this later.
-        }
-        return false;
-    }
-
-    /// <summary>
-    ///     If the tile provided is the same type (references the same block) as the current tile.
-    /// </summary>
-    /// <param name="otherTile">The other tile to check.</param>
-    /// <returns>Whether or not the other block is the same type as the current tile</returns>
-    private bool IsSameTileType(TileShared otherTile) => otherTile.SourceBlock == SourceBlock;
 }
\ No newline at end of file
diff --git a/Shared/Code/Components/Transform.cs b/Shared/Code/Components/Transform.cs
new file mode 100644
index 0000000..28b2cd4
--- /dev/null
+++ b/Shared/Code/Components/Transform.cs
@@ -0,0 +1,30 @@
+using LiteNetLib.Utils;
+using Microsoft.Xna.Framework;
+namespace Shared.Code.Components;
+
+public sealed class Transform : INetSerializable {
+    public Vector2Int Position;
+    public float Rotation;
+    public Vector2 Scale;
+    public Vector2Int Origin;
+
+    public Transform(Vector2Int position, Vector2? scale = null, Vector2Int? origin = null, float rotation = 0) {
+        Position = position;
+        Origin = origin ?? Vector2Int.Zero;
+        Scale = scale ?? Vector2.One;
+        Rotation = rotation;
+    }
+
+    public void Serialize(NetDataWriter writer) {
+        writer.Put(Position);
+        writer.Put(Rotation);
+        writer.Put(Scale.X);
+        writer.Put(Scale.Y);
+    }
+
+    public void Deserialize(NetDataReader reader) {
+        Position = reader.Get<Vector2Int>();
+        Rotation = reader.GetFloat();
+        Scale = new Vector2(reader.GetFloat(), reader.GetFloat());
+    }
+}
\ No newline at end of file
diff --git a/Shared/Code/Math.cs b/Shared/Code/Math.cs
index d60f0fa..4dfecd9 100644
--- a/Shared/Code/Math.cs
+++ b/Shared/Code/Math.cs
@@ -1,3 +1,4 @@
+using LiteNetLib.Utils;
 using Microsoft.Xna.Framework;
 namespace Shared.Code;
 
@@ -5,16 +6,16 @@ namespace Shared.Code;
 ///     Represents a vector with two integer values rather than two floating-point values.
 /// </summary>
 /// <seealso cref="Vector2" />
-public struct Vector2Int {
+public struct Vector2Int : INetSerializable {
     /// <summary>
     ///     The X coordinate of this <see cref="Vector2Int" />.
     /// </summary>
-    public readonly int X;
+    public int X { get; private set; }
 
     /// <summary>
     ///     The Y coordinate of this <see cref="Vector2Int" />.
     /// </summary>
-    public readonly int Y;
+    public int Y { get; private set; }
 
     /// <summary>
     ///     Create a <see cref="Vector2Int" />.
@@ -58,6 +59,18 @@ public Vector2Int(int x, int y) {
     public static Vector2Int operator -(Vector2Int value1, Vector2Int value2) =>
         new(value1.X - value2.X, value1.Y - value2.Y);
 
+    public static Vector2Int operator -(Vector2Int value1) =>
+        new(-value1.X, -value1.Y);
+
+    public static Vector2Int operator *(Vector2Int value1, Vector2Int value2) =>
+        new(value1.X * value2.X, value1.Y * value2.Y);
+
+    public static Vector2Int operator /(Vector2Int value1, Vector2Int value2) =>
+        new(value1.X / value2.X, value1.Y / value2.Y);
+
+    public static Vector2Int operator *(Vector2Int value, int multiplier) =>
+        new(value.X * multiplier, value.Y * multiplier);
+
     /// <inheritdoc />
     public override int GetHashCode() => X.GetHashCode() + Y.GetHashCode();
 
@@ -70,6 +83,10 @@ public Vector2Int(int x, int y) {
     public static explicit operator Vector2Int(Vector2 vector2) =>
         new((int)Math.Round(vector2.X), (int)Math.Round(vector2.Y));
 
+    public static implicit operator Point(Vector2Int vector2Int) => new(vector2Int.X, vector2Int.Y);
+
+    public static implicit operator Vector2Int(Point point) => new(point.X, point.Y);
+    
     // Preset values
     /// <summary>Returns a <see cref="Vector2Int" /> with values (0, 0).</summary>
     public static readonly Vector2Int Zero = new(0, 0);
@@ -88,4 +105,14 @@ public static explicit operator Vector2Int(Vector2 vector2) =>
 
     /// <summary>Returns a <see cref="Vector2Int" /> with values (1, 0).</summary>
     public static readonly Vector2Int Right = new(1, 0);
+
+    public void Serialize(NetDataWriter writer) {
+        writer.Put(X);
+        writer.Put(Y);
+    }
+
+    public void Deserialize(NetDataReader reader) {
+        X = reader.GetInt();
+        Y = reader.GetInt();
+    }
 }
\ No newline at end of file