player and entity physics improvements
This commit is contained in:
418
Entity.cs
418
Entity.cs
@@ -17,89 +17,412 @@ namespace Voxel
|
||||
public float Width;
|
||||
public float Height;
|
||||
|
||||
private float _airDrag = 2f;
|
||||
private float _groundDrag = 8f;
|
||||
private float _gravity = 0.08f;
|
||||
private float _terminalVelocity = -3.92f;
|
||||
private float _airMultiplier = 0.98f;
|
||||
private float _groundMultiplier = 0.91f;
|
||||
|
||||
private World _world;
|
||||
private const float COLLISION_EPSILON = 0.01f;
|
||||
|
||||
protected World _world;
|
||||
|
||||
public Entity(Vector3 position, float width, float height, World world)
|
||||
{
|
||||
Position = position;
|
||||
Width = width;
|
||||
Height = height;
|
||||
|
||||
_world = world;
|
||||
}
|
||||
|
||||
public void Tick(float deltaTime)
|
||||
public void Tick()
|
||||
{
|
||||
Console.WriteLine(OnGround);
|
||||
Vector3 desiredMovement = Velocity;
|
||||
Vector3 newPosition = Position;
|
||||
|
||||
CheckAndResolveCollisions(ref newPosition, desiredMovement);
|
||||
|
||||
Position = newPosition;
|
||||
|
||||
if (!OnGround)
|
||||
{
|
||||
Console.WriteLine("Velocity: " + Velocity.Y.ToString());
|
||||
|
||||
Velocity -= new Vector3(
|
||||
Velocity.X * _airDrag * deltaTime,
|
||||
1.6f * deltaTime,
|
||||
Velocity.Z * _airDrag * deltaTime);
|
||||
Vector3 acceleration = new Vector3(0, -_gravity, 0);
|
||||
Velocity = (Velocity + acceleration) * _airMultiplier;
|
||||
|
||||
if (Velocity.Y < _terminalVelocity)
|
||||
{
|
||||
Velocity.Y = _terminalVelocity;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Velocity = new Vector3(Velocity.X, 0, Velocity.Z);
|
||||
Velocity -= new Vector3(
|
||||
Velocity.X * _groundDrag * deltaTime,
|
||||
0,
|
||||
Velocity.Z * _groundDrag * deltaTime);
|
||||
Velocity = new Vector3(
|
||||
Velocity.X * _groundMultiplier,
|
||||
0f,
|
||||
Velocity.Z * _groundMultiplier
|
||||
);
|
||||
}
|
||||
|
||||
UpdateOnGround();
|
||||
}
|
||||
|
||||
Position += Velocity;
|
||||
Console.WriteLine("Position: " + Position.Y.ToString());
|
||||
public void CheckAndResolveCollisions(ref Vector3 position, Vector3 movement)
|
||||
{
|
||||
Vector3 originalPosition = position;
|
||||
|
||||
// Try full movement first
|
||||
AABB futureBox = GetBoundingBoxAt(originalPosition + movement);
|
||||
|
||||
if (!HasCollision(futureBox))
|
||||
{
|
||||
// No collision, apply full movement
|
||||
position = originalPosition + movement;
|
||||
return;
|
||||
}
|
||||
|
||||
// Collision detected, resolve each axis separately but independently
|
||||
position = originalPosition;
|
||||
|
||||
// Resolve Y collision (always first for ground detection)
|
||||
ResolveYCollisionIndependent(ref position, movement.Y);
|
||||
|
||||
// Resolve X and Z collisions independently of each other
|
||||
Vector3 tempPosX = new Vector3(position.X + movement.X, position.Y, position.Z);
|
||||
if (!HasCollision(GetBoundingBoxAt(tempPosX)))
|
||||
{
|
||||
position.X = tempPosX.X;
|
||||
}
|
||||
else
|
||||
{
|
||||
ResolveXCollisionIndependent(ref position, movement.X);
|
||||
}
|
||||
|
||||
Vector3 tempPosZ = new Vector3(position.X, position.Y, position.Z + movement.Z);
|
||||
if (!HasCollision(GetBoundingBoxAt(tempPosZ)))
|
||||
{
|
||||
position.Z = tempPosZ.Z;
|
||||
}
|
||||
else
|
||||
{
|
||||
ResolveZCollisionIndependent(ref position, movement.Z);
|
||||
}
|
||||
}
|
||||
|
||||
private void ResolveYCollisionIndependent(ref Vector3 position, float velocityY)
|
||||
{
|
||||
if (velocityY == 0) return;
|
||||
|
||||
Vector3 testPos = new Vector3(position.X, position.Y + velocityY, position.Z);
|
||||
AABB testBox = GetBoundingBoxAt(testPos);
|
||||
|
||||
if (HasCollision(testBox))
|
||||
{
|
||||
if (velocityY > 0) // Hitting ceiling
|
||||
{
|
||||
float ceilingY = GetCeilingHeight(testBox);
|
||||
position.Y = ceilingY - (Height / 2) - COLLISION_EPSILON;
|
||||
Velocity.Y = 0;
|
||||
}
|
||||
else // Hitting floor
|
||||
{
|
||||
float floorY = GetFloorHeight(testBox);
|
||||
position.Y = floorY + (Height / 2) + COLLISION_EPSILON;
|
||||
Velocity.Y = 0;
|
||||
OnGround = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
position.Y += velocityY;
|
||||
}
|
||||
}
|
||||
|
||||
private void ResolveXCollisionIndependent(ref Vector3 position, float velocityX)
|
||||
{
|
||||
if (velocityX == 0) return;
|
||||
|
||||
// Check if we're already inside a block at current position
|
||||
AABB currentBox = GetBoundingBoxAt(new Vector3(position.X, position.Y, position.Z));
|
||||
if (HasCollision(currentBox))
|
||||
{
|
||||
// Already inside a block, allow movement to escape
|
||||
position.X += velocityX;
|
||||
return;
|
||||
}
|
||||
|
||||
float direction = Math.Sign(velocityX);
|
||||
float checkDistance = Math.Abs(velocityX) + COLLISION_EPSILON;
|
||||
|
||||
for (float offset = 0; offset <= checkDistance; offset += 0.01f)
|
||||
{
|
||||
float testX = position.X + (offset * direction);
|
||||
AABB testBox = GetBoundingBoxAt(new Vector3(testX, position.Y, position.Z));
|
||||
|
||||
if (HasCollision(testBox))
|
||||
{
|
||||
if (direction > 0) // Moving right
|
||||
{
|
||||
position.X = GetRightWallPosition(testBox) - (Width / 2) - COLLISION_EPSILON;
|
||||
}
|
||||
else // Moving left
|
||||
{
|
||||
position.X = GetLeftWallPosition(testBox) + (Width / 2) + COLLISION_EPSILON;
|
||||
}
|
||||
Velocity.X = 0;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// No collision found, apply full movement
|
||||
position.X += velocityX;
|
||||
}
|
||||
|
||||
private void ResolveZCollisionIndependent(ref Vector3 position, float velocityZ)
|
||||
{
|
||||
if (velocityZ == 0) return;
|
||||
|
||||
// Check if we're already inside a block at current position
|
||||
AABB currentBox = GetBoundingBoxAt(new Vector3(position.X, position.Y, position.Z));
|
||||
if (HasCollision(currentBox))
|
||||
{
|
||||
// Already inside a block, allow movement to escape
|
||||
position.Z += velocityZ;
|
||||
return;
|
||||
}
|
||||
|
||||
float direction = Math.Sign(velocityZ);
|
||||
float checkDistance = Math.Abs(velocityZ) + COLLISION_EPSILON;
|
||||
|
||||
for (float offset = 0; offset <= checkDistance; offset += 0.01f)
|
||||
{
|
||||
float testZ = position.Z + (offset * direction);
|
||||
AABB testBox = GetBoundingBoxAt(new Vector3(position.X, position.Y, testZ));
|
||||
|
||||
if (HasCollision(testBox))
|
||||
{
|
||||
if (direction > 0) // Moving forward
|
||||
{
|
||||
position.Z = GetFrontWallPosition(testBox) - (Width / 2) - COLLISION_EPSILON;
|
||||
}
|
||||
else // Moving backward
|
||||
{
|
||||
position.Z = GetBackWallPosition(testBox) + (Width / 2) + COLLISION_EPSILON;
|
||||
}
|
||||
Velocity.Z = 0;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// No collision found, apply full movement
|
||||
position.Z += velocityZ;
|
||||
}
|
||||
|
||||
private float GetFloorHeight(AABB box)
|
||||
{
|
||||
int minX = (int)MathF.Floor(box.Min.X);
|
||||
int maxX = (int)MathF.Floor(box.Max.X);
|
||||
int minZ = (int)MathF.Floor(box.Min.Z);
|
||||
int maxZ = (int)MathF.Floor(box.Max.Z);
|
||||
int checkY = (int)MathF.Floor(box.Min.Y);
|
||||
|
||||
float highestFloor = float.MinValue;
|
||||
|
||||
for (int x = minX; x <= maxX; x++)
|
||||
{
|
||||
for (int z = minZ; z <= maxZ; z++)
|
||||
{
|
||||
Blocks block = _world.GetBlock(x, checkY, z);
|
||||
if (block != Blocks.Air)
|
||||
{
|
||||
highestFloor = Math.Max(highestFloor, checkY + 1); // Top of the block
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return highestFloor != float.MinValue ? highestFloor : box.Min.Y;
|
||||
}
|
||||
|
||||
private float GetCeilingHeight(AABB box)
|
||||
{
|
||||
int minX = (int)MathF.Floor(box.Min.X);
|
||||
int maxX = (int)MathF.Floor(box.Max.X);
|
||||
int minZ = (int)MathF.Floor(box.Min.Z);
|
||||
int maxZ = (int)MathF.Floor(box.Max.Z);
|
||||
int checkY = (int)MathF.Floor(box.Max.Y);
|
||||
|
||||
float lowestCeiling = float.MaxValue;
|
||||
|
||||
for (int x = minX; x <= maxX; x++)
|
||||
{
|
||||
for (int z = minZ; z <= maxZ; z++)
|
||||
{
|
||||
Blocks block = _world.GetBlock(x, checkY, z);
|
||||
if (block != Blocks.Air)
|
||||
{
|
||||
lowestCeiling = Math.Min(lowestCeiling, checkY); // Bottom of the block
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return lowestCeiling != float.MaxValue ? lowestCeiling : box.Max.Y;
|
||||
}
|
||||
|
||||
private float GetLeftWallPosition(AABB box)
|
||||
{
|
||||
int minY = (int)MathF.Floor(box.Min.Y);
|
||||
int maxY = (int)MathF.Floor(box.Max.Y);
|
||||
int minZ = (int)MathF.Floor(box.Min.Z);
|
||||
int maxZ = (int)MathF.Floor(box.Max.Z);
|
||||
int checkX = (int)MathF.Floor(box.Min.X);
|
||||
|
||||
float rightmostWall = float.MinValue;
|
||||
|
||||
for (int y = minY; y <= maxY; y++)
|
||||
{
|
||||
for (int z = minZ; z <= maxZ; z++)
|
||||
{
|
||||
Blocks block = _world.GetBlock(checkX, y, z);
|
||||
if (block != Blocks.Air)
|
||||
{
|
||||
rightmostWall = Math.Max(rightmostWall, checkX + 1); // Right side of the block
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return rightmostWall != float.MinValue ? rightmostWall : box.Min.X;
|
||||
}
|
||||
|
||||
private float GetRightWallPosition(AABB box)
|
||||
{
|
||||
int minY = (int)MathF.Floor(box.Min.Y);
|
||||
int maxY = (int)MathF.Floor(box.Max.Y);
|
||||
int minZ = (int)MathF.Floor(box.Min.Z);
|
||||
int maxZ = (int)MathF.Floor(box.Max.Z);
|
||||
int checkX = (int)MathF.Floor(box.Max.X);
|
||||
|
||||
float leftmostWall = float.MaxValue;
|
||||
|
||||
for (int y = minY; y <= maxY; y++)
|
||||
{
|
||||
for (int z = minZ; z <= maxZ; z++)
|
||||
{
|
||||
Blocks block = _world.GetBlock(checkX, y, z);
|
||||
if (block != Blocks.Air)
|
||||
{
|
||||
leftmostWall = Math.Min(leftmostWall, checkX); // Left side of the block
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return leftmostWall != float.MaxValue ? leftmostWall : box.Max.X;
|
||||
}
|
||||
|
||||
private float GetBackWallPosition(AABB box)
|
||||
{
|
||||
int minX = (int)MathF.Floor(box.Min.X);
|
||||
int maxX = (int)MathF.Floor(box.Max.X);
|
||||
int minY = (int)MathF.Floor(box.Min.Y);
|
||||
int maxY = (int)MathF.Floor(box.Max.Y);
|
||||
int checkZ = (int)MathF.Floor(box.Min.Z);
|
||||
|
||||
float frontmostWall = float.MinValue;
|
||||
|
||||
for (int x = minX; x <= maxX; x++)
|
||||
{
|
||||
for (int y = minY; y <= maxY; y++)
|
||||
{
|
||||
Blocks block = _world.GetBlock(x, y, checkZ);
|
||||
if (block != Blocks.Air)
|
||||
{
|
||||
frontmostWall = Math.Max(frontmostWall, checkZ + 1); // Front side of the block
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return frontmostWall != float.MinValue ? frontmostWall : box.Min.Z;
|
||||
}
|
||||
|
||||
private float GetFrontWallPosition(AABB box)
|
||||
{
|
||||
int minX = (int)MathF.Floor(box.Min.X);
|
||||
int maxX = (int)MathF.Floor(box.Max.X);
|
||||
int minY = (int)MathF.Floor(box.Min.Y);
|
||||
int maxY = (int)MathF.Floor(box.Max.Y);
|
||||
int checkZ = (int)MathF.Floor(box.Max.Z);
|
||||
|
||||
float backmostWall = float.MaxValue;
|
||||
|
||||
for (int x = minX; x <= maxX; x++)
|
||||
{
|
||||
for (int y = minY; y <= maxY; y++)
|
||||
{
|
||||
Blocks block = _world.GetBlock(x, y, checkZ);
|
||||
if (block != Blocks.Air)
|
||||
{
|
||||
backmostWall = Math.Min(backmostWall, checkZ); // Back side of the block
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return backmostWall != float.MaxValue ? backmostWall : box.Max.Z;
|
||||
}
|
||||
|
||||
public bool HasCollision(AABB box)
|
||||
{
|
||||
int minX = (int)MathF.Floor(box.Min.X);
|
||||
int maxX = (int)MathF.Floor(box.Max.X);
|
||||
int minY = (int)MathF.Floor(box.Min.Y);
|
||||
int maxY = (int)MathF.Floor(box.Max.Y);
|
||||
int minZ = (int)MathF.Floor(box.Min.Z);
|
||||
int maxZ = (int)MathF.Floor(box.Max.Z);
|
||||
|
||||
for (int x = minX; x <= maxX; x++)
|
||||
{
|
||||
for (int y = minY; y <= maxY; y++)
|
||||
{
|
||||
for (int z = minZ; z <= maxZ; z++)
|
||||
{
|
||||
Blocks block = _world.GetBlock(x, y, z);
|
||||
if (block != Blocks.Air)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public void ApplyImpulse(Vector3 force)
|
||||
{
|
||||
Velocity += force;
|
||||
}
|
||||
|
||||
public AABB GetBoundingBox()
|
||||
{
|
||||
return GetBoundingBoxAt(Position);
|
||||
}
|
||||
|
||||
public AABB GetBoundingBoxAt(Vector3 position)
|
||||
{
|
||||
float halfWidth = Width / 2;
|
||||
float halfHeight = Height / 2;
|
||||
|
||||
Vector3 min = new Vector3(
|
||||
Position.X - halfWidth,
|
||||
Position.Y - Height,
|
||||
Position.Z - halfWidth
|
||||
position.X - halfWidth,
|
||||
position.Y - halfHeight, // Center Y minus half height
|
||||
position.Z - halfWidth
|
||||
);
|
||||
|
||||
Vector3 max = new Vector3(
|
||||
Position.X + halfWidth,
|
||||
Position.Y + Height,
|
||||
Position.Z + halfWidth
|
||||
position.X + halfWidth,
|
||||
position.Y + halfHeight, // Center Y plus half height
|
||||
position.Z + halfWidth
|
||||
);
|
||||
|
||||
return new AABB(min, max);
|
||||
}
|
||||
|
||||
private bool IsCollidingSide(Vector3 direction)
|
||||
{
|
||||
AABB box = GetBoundingBox();
|
||||
|
||||
// Determine which axis we’re checking
|
||||
int checkX = direction.X > 0 ? (int)MathF.Floor(box.Max.X) : (int)MathF.Floor(box.Min.X);
|
||||
int checkZ = direction.Z > 0 ? (int)MathF.Floor(box.Max.Z) : (int)MathF.Floor(box.Min.Z);
|
||||
|
||||
int minY = (int)MathF.Floor(box.Min.Y);
|
||||
int maxY = (int)MathF.Floor(box.Max.Y);
|
||||
|
||||
// Sweep along vertical range
|
||||
for (int y = minY; y <= maxY; y++)
|
||||
{
|
||||
if (_world.GetBlock(checkX, y, checkZ) != Blocks.Air)
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
public void UpdateOnGround()
|
||||
{
|
||||
AABB box = GetBoundingBox();
|
||||
@@ -124,6 +447,5 @@ namespace Voxel
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user