started reworking collission system

AABB.cs

@@ -24,11 +24,34 @@ namespace Voxel
             return new AABB(center - half, center + new Vector3(half.X, height, half.Z));
         }
 
+        public void Move(float x, float y, float z)
+        {
+            Min.X += x;
+            Max.X += x;
+            Min.Y += y;
+            Max.Y += y;
+            Min.Z += z;
+            Max.Z += z;
+        }
+
         public bool Intersects(AABB other)
         {
-            return (Min.X <= other.Max.X && Max.X >= other.Min.X) &&
-                   (Min.Y <= other.Max.Y && Max.Y >= other.Min.Y) &&
-                   (Min.Z <= other.Max.Z && Max.Z >= other.Min.Z);
+            return IntersectsX(other) && IntersectsY(other) && IntersectsZ(other);
+        }
+
+        public bool IntersectsX(AABB other)
+        {
+            return Min.X < other.Max.X && Max.X > other.Max.X;
+        }
+
+        public bool IntersectsY(AABB other)
+        {
+            return Min.Y < other.Max.Y && Max.Y > other.Max.Y;
+        }
+
+        public bool IntersectsZ(AABB other)
+        {
+            return Min.Z < other.Max.Z && Max.Z > other.Max.Z;
         }
 
         public bool Contains(Vector3 point)
@@ -37,5 +60,152 @@ namespace Voxel
                    (point.Y >= Min.Y && point.Y <= Max.Y) &&
                    (point.Z >= Min.Z && point.Z <= Max.Z);
         }
+
+        public float GetClipX(AABB other, float deltaX)
+        {
+            if (IntersectsY(other) && IntersectsZ(other))
+            {
+                if (deltaX > 0 && Max.X <= other.Min.X)
+                {
+                    float clip = other.Min.X - other.Min.X;
+
+                    if (deltaX > clip)
+                        deltaX = clip;
+                }
+
+                if (deltaX < 0 && Min.X >= other.Max.X)
+                {
+                    float clip = other.Max.X - Max.X;
+                    if (deltaX < clip)
+                            deltaX = clip;
+                }
+                return deltaX;
+            }
+            return deltaX;
+        }
+        public float GetClipY(AABB other, float deltaY)
+        {
+            if (IntersectsX(other) && IntersectsZ(other))
+            {
+                if (deltaY > 0 && Max.Y <= other.Min.Y)
+                {
+                    float clip = other.Min.Y - other.Min.Y;
+
+                    if (deltaY > clip)
+                        deltaY = clip;
+                }
+
+                if (deltaY < 0 && Min.X >= other.Max.X)
+                {
+                    float clip = other.Max.X - Max.X;
+                    if (deltaY < clip)
+                        deltaY = clip;
+                }
+                return deltaY;
+            }
+            return deltaY;
+        }
+        public float GetClipZ(AABB other, float deltaZ)
+        {
+            if (IntersectsX(other) && IntersectsY(other))
+            {
+                if (deltaZ > 0 && Max.Z <= other.Min.Z)
+                {
+                    float clip = other.Min.Z - other.Min.Z;
+
+                    if (deltaZ > clip)
+                        deltaZ = clip;
+                }
+
+                if (deltaZ < 0 && Min.Z >= other.Max.Z)
+                {
+                    float clip = other.Max.Z - Max.Z;
+                    if (deltaZ < clip)
+                        deltaZ = clip;
+                }
+                return deltaZ;
+            }
+            return deltaZ;
+        }
+
+        public float GetBlockClipX(int blockX, int blockY, int blockZ, float deltaX)
+        {
+            // Use the current AABB as the collider (no new allocation)
+            AABB collider = this;
+
+            // Block bounds
+            float blockMinX = blockX;
+            float blockMaxX = blockX + 1;
+
+            // Quick reject: if player is not overlapping the block in Y and Z, no collision.
+            if (!(collider.Min.Y < blockY + 1 && collider.Max.Y > blockY) ||
+                !(collider.Min.Z < blockZ + 1 && collider.Max.Z > blockZ))
+                return deltaX;
+
+            // Moving right (positive delta)
+            if (deltaX > 0 && collider.Max.X <= blockMinX)
+            {
+                float clip = blockMinX - collider.Max.X;
+                if (deltaX > clip) deltaX = clip;
+            }
+            // Moving left (negative delta)
+            else if (deltaX < 0 && collider.Min.X >= blockMaxX)
+            {
+                float clip = blockMaxX - collider.Min.X; // negative distance
+                if (deltaX < clip) deltaX = clip;
+            }
+
+            return deltaX;
+        }
+
+        public float GetBlockClipY(int blockX, int blockY, int blockZ, float deltaY)
+        {
+            AABB collider = this;
+
+            float blockMinY = blockY;
+            float blockMaxY = blockY + 1;
+
+            if (!(collider.Min.X < blockX + 1 && collider.Max.X > blockX) ||
+                !(collider.Min.Z < blockZ + 1 && collider.Max.Z > blockZ))
+                return deltaY;
+
+            if (deltaY > 0 && collider.Max.Y <= blockMinY)
+            {
+                float clip = blockMinY - collider.Max.Y;
+                if (deltaY > clip) deltaY = clip;
+            }
+            else if (deltaY < 0 && collider.Min.Y >= blockMaxY)
+            {
+                float clip = blockMaxY - collider.Min.Y;
+                if (deltaY < clip) deltaY = clip;
+            }
+
+            return deltaY;
+        }
+
+        public float GetBlockClipZ(int blockX, int blockY, int blockZ, float deltaZ)
+        {
+            AABB collider = this;
+
+            float blockMinZ = blockZ;
+            float blockMaxZ = blockZ + 1;
+
+            if (!(collider.Min.X < blockX + 1 && collider.Max.X > blockX) ||
+                !(collider.Min.Y < blockY + 1 && collider.Max.Y > blockY))
+                return deltaZ;
+
+            if (deltaZ > 0 && collider.Max.Z <= blockMinZ)
+            {
+                float clip = blockMinZ - collider.Max.Z;
+                if (deltaZ > clip) deltaZ = clip;
+            }
+            else if (deltaZ < 0 && collider.Min.Z >= blockMaxZ)
+            {
+                float clip = blockMaxZ - collider.Min.Z;
+                if (deltaZ < clip) deltaZ = clip;
+            }
+
+            return deltaZ;
+        }
     }
 }