work on npcs

Kestrel.Framework/Client/Client.cs

···
         _gl.Enable(EnableCap.DepthTest);
         _gl.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha);
         // _gl.PolygonMode(GLEnum.FrontAndBack, GLEnum.Line);
-        clientState.Window.GL.Enable(GLEnum.CullFace);
-        clientState.Window.GL.CullFace(GLEnum.Back);
+        // clientState.Window.GL.Enable(GLEnum.CullFace);
+        // clientState.Window.GL.CullFace(GLEnum.Back);
 
         // Tell GL which triangle winding is considered "front"
-        clientState.Window.GL.FrontFace(GLEnum.Ccw);
+        // clientState.Window.GL.FrontFace(GLEnum.Ccw);
 
         // Networking
 
···
                         var playerServerId = clientState.Player.Get<ServerId>().Id;
                         if (packet.ServerId == playerServerId)
                         {
+                            Console.WriteLine("Ignoring player spawn");
                             return;
                         }
 
                         if (!clientState.ServerIdToEntity.ContainsKey(packet.ServerId))
                         {
+                            Console.WriteLine("adding entity");
                             ArchEntity archEntity = clientState.Entities.Create(new ServerId(packet.ServerId));
 
                             // entity.Key is the server ID so we add it to the dictionary
···
                                 {
                                     clientState.Player = archEntity;
                                 }
-                                clientState.Entities.Add(archEntity, component);
+
+                                switch (component)
+                                {
+                                    case Location location: clientState.Entities.Add(archEntity, location); break;
+                                    case Nametag nametag: clientState.Entities.Add(archEntity, nametag); break;
+                                    case Player playerC: clientState.Entities.Add(archEntity, playerC); break;
+                                    case Velocity velocity: clientState.Entities.Add(archEntity, velocity); break;
+                                    case Physics physics: clientState.Entities.Add(archEntity, physics); break;
+                                    case Collider collider: clientState.Entities.Add(archEntity, collider); break;
+                                }
                             }
                         }
                         else
                         {
+                            Console.WriteLine("Entity already exists");
                             // If the entity already exists we just ignore it for now we might want to change this later
                             // to check for new components etc etc
                         }
···
                         }
 
                         ArchEntity entity = clientState.ServerIdToEntity[packet.ServerId];
-                        entity.Get<Location>().Postion = new Vector3(packet.Position.X, packet.Position.Y, packet.Position.Z);
+                        entity.Get<Location>().Position = new Vector3(packet.Position.X, packet.Position.Y, packet.Position.Z);
                     }
                     break;
                 case Packet.S2CChunkResponse:
···
         var _keyboard = _input.Keyboards[0];
         float cameraSpeed = 150.0f * (float)deltaTime;
 
-        clientState.Entities.Query(new Arch.Core.QueryDescription().WithAll<Location>(), (ArchEntity entity, ref Location location) =>
+        clientState.Entities.Query(new Arch.Core.QueryDescription().WithAll<Location, Player>(), (ArchEntity entity, ref Location location, ref Player player) =>
         {
+            if (player.Name != clientState.PlayerName)
+                return;
+
             bool playerMoved = false;
+
+            var actualCameraSpeed = cameraSpeed;
+            if (_keyboard.IsKeyPressed(Key.ShiftLeft))
+                actualCameraSpeed *= 0.2f;
+
             if (_keyboard.IsKeyPressed(Key.W))
             {
                 playerMoved = true;
-                location.Postion += cameraSpeed * clientState.Camera.front.ToVector3();
+                location.Position += actualCameraSpeed * clientState.Camera.front.ToVector3();
             }
             if (_keyboard.IsKeyPressed(Key.S))
             {
                 playerMoved = true;
-                location.Postion -= cameraSpeed * clientState.Camera.front.ToVector3();
+                location.Position -= actualCameraSpeed * clientState.Camera.front.ToVector3();
             }
             if (_keyboard.IsKeyPressed(Key.A))
             {
                 playerMoved = true;
 
-                location.Postion -= glm.Normalized(glm.Cross(clientState.Camera.front, clientState.Camera.up)).ToVector3() * cameraSpeed;
+                location.Position -= glm.Normalized(glm.Cross(clientState.Camera.front, clientState.Camera.up)).ToVector3() * actualCameraSpeed;
             }
             if (_keyboard.IsKeyPressed(Key.D))
             {
-                location.Postion += glm.Normalized(glm.Cross(clientState.Camera.front, clientState.Camera.up)).ToVector3() * cameraSpeed;
+                location.Position += glm.Normalized(glm.Cross(clientState.Camera.front, clientState.Camera.up)).ToVector3() * actualCameraSpeed;
                 playerMoved = true;
             }
 
···
                     clientState.RequestChunk(new(x, y, z));
                 }
 
-                clientState.NetServer.Send(IPacket.Serialize(new C2SPlayerMove(location.Postion)), DeliveryMethod.ReliableUnordered);
+                Console.WriteLine("Sending player move packet");
+                clientState.NetServer.Send(IPacket.Serialize(new C2SPlayerMove(location.Position)), DeliveryMethod.ReliableUnordered);
             }
         });
 

Kestrel.Framework/Client/ClientState.cs

···
 using Kestrel.Framework.Client.Graphics.Camera;
 using Kestrel.Framework.Networking.Packets;
 using Kestrel.Framework.Networking.Packets.C2S;
-using Kestrel.Framework.Server.Player;
 using Kestrel.Framework.Utils;
 using KestrelWorld = Kestrel.Framework.World.World;
 using LiteNetLib;

Kestrel.Framework/Client/Graphics/Buffers/ChunkRenderer.cs

···
 using GlmSharp;
 using Kestrel.Framework.Client.Graphics.Shaders;
 using Kestrel.Framework.Entity.Components;
-using Kestrel.Framework.Server.Player;
 using Kestrel.Framework.Utils;
 using Kestrel.Framework.World;
 using Silk.NET.Maths;
···
         }
 
         cube.Bind();
+        // Console.WriteLine("Before");
         clientState.Entities.Query(new Arch.Core.QueryDescription().WithAll<Location>(), (ArchEntity entity, ref Location location) =>
         {
-            vec3 pos = location.Postion.ToVec3();
+            vec3 pos = location.Position.ToVec3();
+            if (entity.Has<Player>() && entity.Get<Player>().Name == clientState.PlayerName)
+            {
+                return;
+            }
             mat4 model = mat4.Identity * mat4.Translate(pos);
             fixed (float* ptr = model.Values1D)
                 clientState.Window.GL.UniformMatrix4(_shader.GetUniformLocation("model"), 1, false, ptr);
···
             clientState.Window.GL.DrawArrays(PrimitiveType.Triangles, 0, 36);
         });
 
-        {
-            vec3 pos = clientState.Player.Get<Location>().Postion.ToVec3();
-            mat4 model = mat4.Identity * mat4.Translate(pos);
-            fixed (float* ptr = model.Values1D)
-                clientState.Window.GL.UniformMatrix4(_shader.GetUniformLocation("model"), 1, false, ptr);
+        // {
+        //     vec3 pos = clientState.Player.Get<Location>().Postion.ToVec3();
+        //     mat4 model = mat4.Identity * mat4.Translate(pos);
+        //     fixed (float* ptr = model.Values1D)
+        //         clientState.Window.GL.UniformMatrix4(_shader.GetUniformLocation("model"), 1, false, ptr);
 
-            clientState.Window.GL.DrawArrays(PrimitiveType.Triangles, 0, 36);
-        }
+        //     clientState.Window.GL.DrawArrays(PrimitiveType.Triangles, 0, 36);
+        // }
     }
 }

Kestrel.Framework/Client/Graphics/Camera/Camera.cs

···
         get
         {
             vec3 playerLocation;
-            playerLocation = clientState.Player.Get<Location>().Postion.ToVec3();
+            playerLocation = clientState.Player.Get<Location>().Position.ToVec3();
 
             return mat4.LookAt(playerLocation, playerLocation + front, up);
         }

Kestrel.Framework/Client/Graphics/Camera/ThirdPersonCamera.cs

···
         get
         {
             // point we want to look at (player “head”)
-            var target = clientState.Player.Get<Location>().Postion.ToVec3() + new vec3(0, ShoulderHeight, 0);
+            var target = clientState.Player.Get<Location>().Position.ToVec3() + new vec3(0, ShoulderHeight, 0);
 
             // spherical orbit offset from yaw/pitch/distance
             float yawR = glm.Radians(yaw);

Kestrel.Framework/Client/Player/ClientPlayer.cs

···
-using System.Numerics;
-using GlmSharp;
-using Kestrel.Framework.Utils;
-using Kestrel.Framework.World;
-
-namespace Kestrel.Framework.Server.Player;
-
-public class ClientPlayer
-{
-    public string Name { get; set; }
-    public Vector3 Location { get; set; }
-    public Vector3I LastFrameChunkPos { get; set; }
-}

Kestrel.Framework/Entity/ComponentRegistry.cs

···
         Register(new Location());
         Register(new Player());
         Register(new Velocity());
+        Register(new Physics());
+        Register(new Collider());
     }
 
     public static void Register(INetworkableComponent component)

Kestrel.Framework/Entity/Components/Collider.cs

···
+using LiteNetLib.Utils;
+
+namespace Kestrel.Framework.Entity.Components;
+
+public record struct Collider : INetworkableComponent
+{
+    public readonly ushort PacketId => 6;
+
+    public bool IsOnGround = false;
+
+    public Collider()
+    {
+    }
+
+    public void Deserialize(NetDataReader reader)
+    {
+    }
+
+    public void Serialize(NetDataWriter writer)
+    {
+    }
+}

Kestrel.Framework/Entity/Components/EntityAi.cs

···
+using System.Numerics;
+using LiteNetLib.Utils;
+
+namespace Kestrel.Framework.Entity.Components;
+
+public abstract record EntityState
+{
+    public float? StateTime = null;
+};
+
+public record EntityIdle : EntityState
+{
+    public EntityIdle()
+    {
+        StateTime = 5f;
+    }
+};
+
+public record EntityWalking : EntityState
+{
+    public Vector3 TargetLocation;
+
+    public EntityWalking(Vector3 location)
+    {
+        TargetLocation = location;
+        StateTime = 5f;
+    }
+};
+
+public record struct EntityAi
+{
+    public EntityState State;
+    public DateTime LastStateChange;
+
+    public EntityAi(EntityState State)
+    {
+        this.State = State;
+        LastStateChange = DateTime.Now;
+    }
+};

Kestrel.Framework/Entity/Components/Location.cs

···
 {
     public readonly ushort PacketId => 1;
 
-    public Vector3 Postion
-    {
-        get => new(X, Y, Z);
-        set
-        {
-            X = value.X;
-            Y = value.Y;
-            Z = value.Z;
-        }
-    }
+    public Vector3 Position = new();
 
-    public float X;
-    public float Y;
-    public float Z;
+    public float X { readonly get { return Position.X; } set { Position.X = value; } }
+    public float Y { readonly get { return Position.Y; } set { Position.Y = value; } }
+    public float Z { readonly get { return Position.Z; } set { Position.Z = value; } }
 
     public float LastUpdatedX;
     public float LastUpdatedY;
···
         writer.Put(X);
         writer.Put(Y);
         writer.Put(Z);
-        Console.WriteLine("Serialized X{0} Y{1} Z{2}", X, Y, Z);
     }
 
     public void Deserialize(NetDataReader reader)
···
         X = reader.GetFloat();
         Y = reader.GetFloat();
         Z = reader.GetFloat();
-        Console.WriteLine("Deserialized X{0} Y{1} Z{2}", X, Y, Z);
     }
 };

Kestrel.Framework/Entity/Components/Physics.cs

···
+using LiteNetLib.Utils;
+
+namespace Kestrel.Framework.Entity.Components;
+
+public record struct Physics : INetworkableComponent
+{
+    public readonly ushort PacketId => 5;
+
+    // 9.98 / 20, 20 = ticks/seconds, 9.92 = Gravity
+    public const float GRAVITY = -0.491f;
+
+    public void Deserialize(NetDataReader reader)
+    {
+    }
+
+    public void Serialize(NetDataWriter writer)
+    {
+    }
+}

Kestrel.Framework/Entity/Components/Velocity.cs

···
 namespace Kestrel.Framework.Entity.Components;
 
+using System.Numerics;
 using LiteNetLib.Utils;
 
-public record struct Velocity(float X, float Y, float Z) : INetworkableComponent
+public record struct Velocity : INetworkableComponent
 {
     public readonly ushort PacketId => 2;
+
+    public Vector3 Vel = new();
+    public Vector3 WishVel = new();
+
+    public float X { readonly get { return Vel.X; } set { Vel.X = value; } }
+    public float Y { readonly get { return Vel.Y; } set { Vel.Y = value; } }
+    public float Z { readonly get { return Vel.Z; } set { Vel.Z = value; } }
+
+
+    public float DistanceMoved = 0;
+
+    public Velocity(float X, float Y, float Z)
+    {
+        Vel.X = X;
+        Vel.Y = Y;
+        Vel.Z = Z;
+    }
 
     public void Deserialize(NetDataReader reader)
     {
-        X = reader.GetFloat();
-        Y = reader.GetFloat();
-        Z = reader.GetFloat();
+        Vel.X = reader.GetFloat();
+        Vel.Y = reader.GetFloat();
+        Vel.Z = reader.GetFloat();
+
+        WishVel.X = reader.GetFloat();
+        WishVel.Y = reader.GetFloat();
+        WishVel.Z = reader.GetFloat();
     }
 
     public void Serialize(NetDataWriter writer)
     {
-        writer.Put(X);
-        writer.Put(Y);
-        writer.Put(Z);
+        writer.Put(Vel.X);
+        writer.Put(Vel.Y);
+        writer.Put(Vel.Z);
+
+        writer.Put(WishVel.X);
+        writer.Put(WishVel.Y);
+        writer.Put(WishVel.Z);
     }
 }

Kestrel.Framework/Networking/Packets/C2S/C2SChunkRequest.cs

···
 using System.Text;
 using Kestrel.Framework.Networking.Packets.S2C;
 using Kestrel.Framework.Server;
-using Kestrel.Framework.Server.Player;
 using Kestrel.Framework.Utils;
 using Kestrel.Framework.World;
 using LiteNetLib;

Kestrel.Framework/Networking/Packets/C2S/C2SPlayerLoginRequest.cs

···
 using Kestrel.Framework.Entity.Components;
 using Kestrel.Framework.Networking.Packets.S2C;
 using Kestrel.Framework.Server;
-using Kestrel.Framework.Server.Player;
 using LiteNetLib;
 using LiteNetLib.Utils;
 using ArchEntity = Arch.Core.Entity;

Kestrel.Framework/Networking/Packets/C2S/C2SPlayerMove.cs

···
 using Kestrel.Framework.Entity.Components;
 using Kestrel.Framework.Networking.Packets.S2C;
 using Kestrel.Framework.Server;
-using Kestrel.Framework.Server.Player;
 using LiteNetLib;
 using LiteNetLib.Utils;
 using ArchEntity = Arch.Core.Entity;

Kestrel.Framework/Networking/Packets/S2C/S2CBroadcastEntityMove.cs

···
 using Arch.Core.Extensions;
 using GlmSharp;
 using Kestrel.Framework.Entity.Components;
-using Kestrel.Framework.Server.Player;
 using LiteNetLib;
 using LiteNetLib.Utils;
 using ArchEntity = Arch.Core.Entity;

Kestrel.Framework/Networking/Packets/S2C/S2CBroadcastEntitySpawn.cs

···
 using GlmSharp;
 using Kestrel.Framework.Entity;
 using Kestrel.Framework.Entity.Components;
-using Kestrel.Framework.Server.Player;
 using LiteNetLib;
 using LiteNetLib.Utils;
 using ArchEntity = Arch.Core.Entity;

Kestrel.Framework/Networking/Packets/S2C/S2CBroadcastPlayerJoin.cs

···
 // using System.Numerics;
 // using GlmSharp;
-// using Kestrel.Framework.Server.Player;
-// using LiteNetLib;
+// // using LiteNetLib;
 // using LiteNetLib.Utils;
 
 // namespace Kestrel.Framework.Networking.Packets.S2C;

Kestrel.Framework/Networking/Packets/S2C/S2CChunkResponse.cs

···
 using System.Numerics;
 using GlmSharp;
 using Kestrel.Framework.Client.Graphics.Buffers;
-using Kestrel.Framework.Server.Player;
 using Kestrel.Framework.Utils;
 using Kestrel.Framework.World;
 using LiteNetLib;

Kestrel.Framework/Networking/Packets/S2C/S2CPlayerLoginSuccess.cs

···
 using GlmSharp;
 using Kestrel.Framework.Entity;
 using Kestrel.Framework.Networking.Packets.C2S;
-using Kestrel.Framework.Server.Player;
 using Kestrel.Framework.Utils;
 using Kestrel.Framework.World;
 using LiteNetLib;

Kestrel.Framework/Server/Server.cs

···
 using Kestrel.Framework.Networking.Packets.S2C;
 using Arch.Core.Extensions;
 using Kestrel.Framework.Entity;
+using System.Reflection.Metadata.Ecma335;
+using System.Net;
 
 namespace Kestrel.Framework.Server;
 
···
                         else
                         {
                             var guid = Guid.NewGuid();
-                            player = ServerState.Entities.Create(new ServerId(guid), new Entity.Components.Player(packet.PlayerName!), new Location(ServerState.World, -416, 100, 383), new Nametag(packet.PlayerName!), new Velocity(0, 0, 0));
+                            player = ServerState.Entities.Create(new ServerId(guid), new Entity.Components.Player(packet.PlayerName!), new Location(ServerState.World, -416, 100, 383), new Nametag(packet.PlayerName!), new Velocity(0, 0, 0), new Physics());
 
                             ServerState.PlayersByName.TryAdd(packet.PlayerName!, player);
                             ServerState.PlayersByConnection.TryAdd(client, player);
···
                         Console.WriteLine("Found {0} eligible entities to send.", ServerState.NetworkableEntities.Count);
                         foreach (var entity in ServerState.NetworkableEntities)
                         {
-                            List<INetworkableComponent> serializedComponents = [];
-                            var entityComponents = ServerState.Entities.GetAllComponents(entity.Value);
-
-                            foreach (var _component in entityComponents)
-                            {
-                                if (_component is INetworkableComponent component)
-                                {
-                                    serializedComponents.Add(component);
-                                }
-                            }
-                            serializedEntities.Add(entity.Key, [.. serializedComponents]);
+                            var serializedComponents = ServerState.GetNetworkableComponents(entity.Value);
+                            serializedEntities.Add(entity.Key, serializedComponents);
                         }
                         var loginSuccess = new S2CPlayerLoginSuccess
                         {
···
                         }, (i) =>
                         {
                             var chunkPos = chunks[i];
-                            generatedChunks[i] = ServerState.World.GetChunkOrGenerate(chunkPos.X, chunkPos.Y, chunkPos.Z);
+                            var chunk = ServerState.World.GetChunkOrGenerate(chunkPos.X, chunkPos.Y, chunkPos.Z, out var generated);
+                            generatedChunks[i] = chunk;
+                            bool addedEntity = false;
+                            if (generated)
+                            {
+                                for (int lx = 0; lx < ServerState.World.ChunkSize && !addedEntity; lx++)
+                                {
+                                    for (int ly = 0; ly < ServerState.World.ChunkSize && !addedEntity; ly++)
+                                    {
+                                        for (int lz = 0; lz < ServerState.World.ChunkSize && !addedEntity; lz++)
+                                        {
+                                            var block = chunk.GetBlock(lx, ly, lz);
+                                            var below = chunk.GetBlock(lx, ly - 1, lz);
+
+                                            if (below.HasValue && block.HasValue)
+                                            {
+                                                if (below.Value == World.BlockType.Grass && block.Value == World.BlockType.Air)
+                                                {
+                                                    (int wx, int wy, int wz) = chunk.ChunkToWorld(lx, ly, lz);
+                                                    ServerState.SpawnEntity(wx, wy, wz);
+                                                    addedEntity = true;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
                         });
 
                         client.Send(IPacket.Serialize(new S2CChunkResponse(generatedChunks)), DeliveryMethod.ReliableUnordered);
···
                             Console.WriteLine($"Client not found in context.");
                             return;
                         }
-                        player.Get<Location>().Postion = packet.Location;
+                        player.Get<Location>().Position = packet.Location;
                         var playerServerId = player.Get<ServerId>().Id;
 
                         ServerState.NetServer.SendToAll(IPacket.Serialize(new S2CBroadcastEntityMove()
                         {
                             ServerId = playerServerId,
                             Position = new Vector3(packet.Location.X, packet.Location.Y, packet.Location.Z)
-                        }), DeliveryMethod.ReliableOrdered);
+                        }), DeliveryMethod.Unreliable);
                     }
                     break;
             }
···
         }
                 ;
 
+        const int targetTickRate = 20;          // 20 ticks per second
+        const double tickInterval = 1000.0 / targetTickRate; // in ms
+        var stopwatch = new System.Diagnostics.Stopwatch();
+        stopwatch.Start();
+        double accumulated = 0;
 
         while (!Console.KeyAvailable)
         {
             ServerState.NetServer.PollEvents();
 
-            ServerState.Entities.Query(new QueryDescription().WithAll<Location>(), (ArchEntity entity, ref Location location) =>
+            accumulated += stopwatch.Elapsed.TotalMilliseconds;
+            stopwatch.Restart();
+
+            while (accumulated >= tickInterval)
             {
-                if (LocationUtil.Distance(new(location.X, location.Y, location.Z), new(location.LastUpdatedX, location.LastUpdatedY, location.LastUpdatedZ)) > 5)
-                {
+                Tick();
+                accumulated -= tickInterval;
+            }
 
-                }
-            });
+            // Thread.Sleep(1);
         }
         ServerState.NetServer.Stop();
+    }
+
+    public void Tick()
+    {
+        ServerState.Entities.Query(new QueryDescription().WithAll<Velocity, Physics>(), (ArchEntity entity, ref Velocity velocity, ref Physics physics) =>
+        {
+            if (entity.Has<Player>())
+                return;
+
+            velocity.Y += Physics.GRAVITY;
+
+            // Cap y velocity
+            velocity.Y = MathF.Min(velocity.Y, 3);
+        });
+
+        ServerState.Entities.Query(new QueryDescription().WithAll<EntityAi>(), (ArchEntity entity, ref EntityAi entityAi) =>
+        {
+            var secondsSinceLastStateChange = (DateTime.Now - entityAi.LastStateChange).Milliseconds / 1000f;
+            if (entityAi.State.StateTime < secondsSinceLastStateChange)
+            {
+                var random = new Random();
+                if (random.NextDouble() < 0.5)
+                {
+                    entityAi.State = new EntityIdle();
+                }
+                else
+                {
+                    entityAi.State = new EntityWalking();
+                }
+            }
+        });
+
+        ServerState.Entities.Query(
+            new QueryDescription().WithAll<Location, Velocity, Collider>(),
+            (ArchEntity entity, ref Location location, ref Velocity velocity, ref Collider collider) =>
+        {
+            if (entity.Has<Player>())
+                return;
+
+            Vector3 startPos = location.Position;
+
+            collider.IsOnGround = false;
+
+            // TODO: Add deltatime
+            Vector3 move = velocity.Vel;
+
+            AxisResolver.MoveAxis(ServerState.World, ref location, ref velocity, ref collider, AxisResolver.Axis.Y, move.Y);
+            AxisResolver.MoveAxis(ServerState.World, ref location, ref velocity, ref collider, AxisResolver.Axis.X, move.X);
+            AxisResolver.MoveAxis(ServerState.World, ref location, ref velocity, ref collider, AxisResolver.Axis.Z, move.Z);
+
+            Vector3 displacement = location.Position - startPos;
+            float distanceMoved = displacement.Length();
+            velocity.DistanceMoved += distanceMoved;
+
+            // velocity.DistanceMoved > 1f &&
+            if (entity.Has<ServerId>())
+            {
+                var serverId = entity.Get<ServerId>();
+
+                var packet = new S2CBroadcastEntityMove
+                {
+                    ServerId = serverId.Id,
+                    Position = location.Position
+                };
+
+                velocity.DistanceMoved = 0f;
+                ServerState.NetServer.SendToAll(IPacket.Serialize(packet), DeliveryMethod.Unreliable);
+            }
+        });
     }
 }

Kestrel.Framework/Server/ServerState.cs

···
 using System.Collections.Concurrent;
-using Kestrel.Framework.Server.Player;
 using Kestrel.Framework.World;
 using LiteNetLib;
 using ArchWorld = Arch.Core.World;
 using ArchEntity = Arch.Core.Entity;
+using Kestrel.Framework.Entity.Components;
+using Arch.Core.Extensions;
+using Kestrel.Framework.Networking.Packets.S2C;
+using Kestrel.Framework.Entity;
+using System.Net;
+using Kestrel.Framework.Networking.Packets;
 
 namespace Kestrel.Framework.Server;
 
···
     public ArchWorld Entities;
     public ConcurrentDictionary<Guid, ArchEntity> NetworkableEntities = [];
 
-    public void SpawnEntity()
+    public INetworkableComponent[] GetNetworkableComponents(ArchEntity entity)
     {
+        List<INetworkableComponent> serializedComponents = [];
+        var entityComponents = Entities.GetAllComponents(entity);
 
+        foreach (var _component in entityComponents)
+        {
+            if (_component is INetworkableComponent component)
+            {
+                serializedComponents.Add(component);
+            }
+        }
+
+        return [.. serializedComponents];
+    }
+
+    public void SpawnEntity(int x, int y, int z)
+    {
+        var guid = Guid.NewGuid();
+        ArchEntity entity = Entities.Create(new ServerId(guid), new Location(World, x, y + 20, z), new Velocity(0, 0, 0), new Physics(), new Collider(), new EntityAi(new EntityIdle()));
+        NetworkableEntities.TryAdd(guid, entity);
+
+        var spawnPacket = new S2CBroadcastEntitySpawn
+        {
+            ServerId = guid,
+            Components = GetNetworkableComponents(entity)
+        };
+        NetServer.SendToAll(IPacket.Serialize(spawnPacket), DeliveryMethod.Unreliable);
     }
 }

Kestrel.Framework/Utils/AxisResolver.cs

···
+using System.Numerics;
+using Kestrel.Framework.Entity.Components;
+using Kestrel.Framework.World;
+
+namespace Kestrel.Framework.Utils;
+
+public static class AxisResolver
+{
+    public enum Axis { X, Y, Z }
+
+    public static void MoveAxis(World.World world, ref Location pos, ref Velocity vel, ref Collider col, Axis axis, float delta)
+    {
+        if (delta == 0f) return;
+
+        float sign = MathF.Sign(delta);
+        float remaining = MathF.Abs(delta);
+
+        while (remaining > 0f)
+        {
+            float step = MathF.Min(remaining, 1f);
+            Vector3 newPos = pos.Position;
+
+            switch (axis)
+            {
+                case Axis.X: newPos.X += sign * step; break;
+                case Axis.Y: newPos.Y += sign * step; break;
+                case Axis.Z: newPos.Z += sign * step; break;
+            }
+
+            (var isColliding, var collidingPos) = IsColliding(world, newPos);
+            if (isColliding && collidingPos.HasValue)
+            {
+                switch (axis)
+                {
+                    case Axis.X:
+                        vel.X = 0f; pos.X = collidingPos.Value.X;
+                        break;
+                    case Axis.Y:
+                        if (sign < 0) col.IsOnGround = true;
+                        pos.Y = collidingPos.Value.Y;
+                        vel.Y = 0f; break;
+                    case Axis.Z:
+                        vel.Z = 0f; pos.Z = collidingPos.Value.Z;
+                        break;
+                }
+                return;
+            }
+
+            pos.Position = newPos;
+            remaining -= step;
+        }
+    }
+
+    public static (bool, Vector3?) IsColliding(World.World world, Vector3 pos)
+    {
+        int minX = (int)MathF.Floor(pos.X);
+        int maxX = (int)MathF.Floor(pos.X);
+        int minY = (int)MathF.Floor(pos.Y);
+        int maxY = (int)MathF.Floor(pos.Y);
+        int minZ = (int)MathF.Floor(pos.Z);
+        int maxZ = (int)MathF.Floor(pos.Z);
+
+        for (int x = minX; x <= maxX; x++)
+            for (int y = minY; y <= maxY; y++)
+                for (int z = minZ; z <= maxZ; z++)
+                {
+                    var block = world.GetBlock(x, y, z);
+                    if (block.IsSolid())
+                        return (true, new(x + 1, y + 1, z + 1));
+                }
+
+        return (false, null);
+    }
+
+}

Kestrel.Framework/World/BlockType.cs

···
     Grass = 3,
     Water = 4,
     Leaves = 5
+}
+
+public static class BlockTypeExtensions
+{
+    public static bool IsSolid(this BlockType? blockType) => blockType != BlockType.Air;
+    public static bool IsSolid(this BlockType blockType) => blockType != BlockType.Air;
 }

Kestrel.Framework/World/Chunk.cs

···
         });
     }
 
-    public BlockType? GetBlock(int x, int y, int z)
+    public BlockType? GetBlock(int lx, int ly, int lz)
     {
-        if (x < 0 || x >= World.ChunkSize ||
-            y < 0 || y >= World.ChunkSize ||
-            z < 0 || z >= World.ChunkSize)
+        if (lx < 0 || lx >= World.ChunkSize ||
+            ly < 0 || ly >= World.ChunkSize ||
+            lz < 0 || lz >= World.ChunkSize)
         {
             return null;
         }
-        return Blocks[ChunkToIndex(x, y, z)];
+        return Blocks[ChunkToIndex(lx, ly, lz)];
     }
 
     public void SetBlock(int lx, int ly, int lz, BlockType block)

Kestrel.Framework/World/World.cs

···
         Generator = new(this);
     }
 
-    public Chunk GetChunkOrGenerate(int cx, int cy, int cz)
+    public Chunk GetChunkOrGenerate(int cx, int cy, int cz, out bool generated)
     {
         Vector3I chunkPos = new(cx, cy, cz);
         if (_chunks.TryGetValue(chunkPos, out var chunk))
         {
+            generated = false;
             return chunk;
         }
 
         Chunk newChunk = new(this, cx, cy, cz);
         newChunk.Generate();
         _chunks.TryAdd(chunkPos, newChunk);
+        generated = true;
         return newChunk;
     }
 
···
 
     public void SetChunk(int cx, int cy, int cz, Chunk chunk) =>
         _chunks[new Vector3I(cx, cy, cz)] = chunk;
+
+    public BlockType? GetBlock(int wx, int wy, int wz)
+    {
+        WorldToChunk(wx, wy, wz, out var chunkPos, out var localPos);
+        var chunk = GetChunk(chunkPos.X, chunkPos.Y, chunkPos.Z);
+        if (chunk == null)
+            return null;
+
+        return chunk.GetBlock(localPos.lx, localPos.ly, localPos.lz);
+    }
 
     public static void WorldToChunk(int wx, int wy, int wz, int chunkSize,
                                    out Vector3I cpos, out (int lx, int ly, int lz) local)

Kestrel.Framework/obj/Debug/net8.0/Kestrel.Framework.AssemblyInfo.cs

···
 [assembly: System.Reflection.AssemblyCompanyAttribute("Kestrel.Framework")]
 [assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]
 [assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
-[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+043631eed54cefe8c936a522f98924f0e5de1d39")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+03aefa68cc89324991f72372f45e23b26e6af377")]
 [assembly: System.Reflection.AssemblyProductAttribute("Kestrel.Framework")]
 [assembly: System.Reflection.AssemblyTitleAttribute("Kestrel.Framework")]
 [assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]

Kestrel.Framework/obj/Debug/net8.0/Kestrel.Framework.AssemblyInfoInputs.cache

···
-462c289644be15e5f833b48314aea9a303b052a9e228356a827b30e4e88e2338
+7aa652efadbe480e9f1948dced67b3118a495d342ba47eacd7e935369f8c9db0

Kestrel.Framework/obj/Debug/net8.0/Kestrel.Framework.csproj.CoreCompileInputs.cache

···
-f44061e7c827b18837aa748c268d8054bfe867690d340a6d687e1a022367c6a3
+e71efa90d0651cf4e94cb789845a4e38cb78f02265a6c43f946689478340b9ee

Kestrel.Game.Client/obj/Debug/net8.0/Kestrel.Game.Client.AssemblyInfo.cs

···
 [assembly: System.Reflection.AssemblyCompanyAttribute("Kestrel.Game.Client")]
 [assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]
 [assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
-[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+043631eed54cefe8c936a522f98924f0e5de1d39")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+03aefa68cc89324991f72372f45e23b26e6af377")]
 [assembly: System.Reflection.AssemblyProductAttribute("Kestrel.Game.Client")]
 [assembly: System.Reflection.AssemblyTitleAttribute("Kestrel.Game.Client")]
 [assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]

Kestrel.Game.Client/obj/Debug/net8.0/Kestrel.Game.Client.AssemblyInfoInputs.cache

···
-914ddb5c62ff20df059e345c93e4dd890feb5d6fe17f883656005c68a571063f
+6d2445ecad05f08d23a7362331f26c836109134a3faaed7bd91a21d873132553

Kestrel.Game.Client/obj/Debug/net8.0/Kestrel.Game.Client.sourcelink.json

···
-{"documents":{"/home/keii/Coding/voxel/*":"https://raw.githubusercontent.com/dinkelspiel/kestrel/043631eed54cefe8c936a522f98924f0e5de1d39/*"}}
+{"documents":{"/home/keii/Coding/voxel/*":"https://raw.githubusercontent.com/dinkelspiel/kestrel/03aefa68cc89324991f72372f45e23b26e6af377/*"}}