mirror of
https://github.com/ClassiCube/ClassiCube.git
synced 2025-10-07 04:56:04 -04:00
266 lines
10 KiB
C#
266 lines
10 KiB
C#
// ClassicalSharp copyright 2014-2016 UnknownShadow200 | Licensed under MIT
|
|
using System;
|
|
using OpenTK;
|
|
|
|
namespace ClassicalSharp.Entities {
|
|
|
|
/// <summary> Entity component that performs collision detection. </summary>
|
|
public sealed class PhysicsComponent {
|
|
|
|
bool useLiquidGravity = false; // used by BlockDefinitions.
|
|
bool canLiquidJump = true;
|
|
internal bool firstJump, secondJump, jumping;
|
|
Entity entity;
|
|
Game game;
|
|
BlockInfo info;
|
|
internal float jumpVel = 0.42f, serverJumpVel = 0.42f;
|
|
internal HacksComponent hacks;
|
|
internal CollisionsComponent collisions;
|
|
|
|
public PhysicsComponent( Game game, Entity entity ) {
|
|
this.game = game;
|
|
this.entity = entity;
|
|
info = game.BlockInfo;
|
|
}
|
|
|
|
public void UpdateVelocityState( float xMoving, float zMoving ) {
|
|
if( !hacks.NoclipSlide && (hacks.Noclip && xMoving == 0 && zMoving == 0) )
|
|
entity.Velocity = Vector3.Zero;
|
|
if( hacks.Flying || hacks.Noclip ) {
|
|
entity.Velocity.Y = 0; // eliminate the effect of gravity
|
|
int dir = (hacks.FlyingUp || jumping) ? 1 : (hacks.FlyingDown ? -1 : 0);
|
|
|
|
entity.Velocity.Y += 0.12f * dir;
|
|
if( hacks.Speeding && hacks.CanSpeed ) entity.Velocity.Y += 0.12f * dir;
|
|
if( hacks.HalfSpeeding && hacks.CanSpeed ) entity.Velocity.Y += 0.06f * dir;
|
|
} else if( jumping && entity.TouchesAnyRope() && entity.Velocity.Y > 0.02f ) {
|
|
entity.Velocity.Y = 0.02f;
|
|
}
|
|
|
|
if( !jumping ) {
|
|
canLiquidJump = false; return;
|
|
}
|
|
|
|
bool touchWater = entity.TouchesAnyWater();
|
|
bool touchLava = entity.TouchesAnyLava();
|
|
if( touchWater || touchLava ) {
|
|
AABB bounds = entity.CollisionBounds;
|
|
int feetY = Utils.Floor( bounds.Min.Y ), bodyY = feetY + 1;
|
|
int headY = Utils.Floor( bounds.Max.Y );
|
|
if( bodyY > headY ) bodyY = headY;
|
|
|
|
bounds.Max.Y = bounds.Min.Y = feetY;
|
|
bool liquidFeet = entity.TouchesAny( bounds, StandardLiquid );
|
|
bounds.Min.Y = Math.Min( bodyY, headY );
|
|
bounds.Max.Y = Math.Max( bodyY, headY );
|
|
bool liquidRest = entity.TouchesAny( bounds, StandardLiquid );
|
|
|
|
bool pastJumpPoint = liquidFeet && !liquidRest && (entity.Position.Y % 1 >= 0.4);
|
|
if( !pastJumpPoint ) {
|
|
canLiquidJump = true;
|
|
entity.Velocity.Y += 0.04f;
|
|
if( hacks.Speeding && hacks.CanSpeed ) entity.Velocity.Y += 0.04f;
|
|
if( hacks.HalfSpeeding && hacks.CanSpeed ) entity.Velocity.Y += 0.02f;
|
|
} else if( pastJumpPoint ) {
|
|
// either A) jump bob in water B) climb up solid on side
|
|
if( collisions.HorCollision )
|
|
entity.Velocity.Y += touchLava ? 0.30f : 0.13f;
|
|
else if( canLiquidJump )
|
|
entity.Velocity.Y += touchLava ? 0.20f : 0.10f;
|
|
canLiquidJump = false;
|
|
}
|
|
} else if( useLiquidGravity ) {
|
|
entity.Velocity.Y += 0.04f;
|
|
if( hacks.Speeding && hacks.CanSpeed ) entity.Velocity.Y += 0.04f;
|
|
if( hacks.HalfSpeeding && hacks.CanSpeed ) entity.Velocity.Y += 0.02f;
|
|
canLiquidJump = false;
|
|
} else if( entity.TouchesAnyRope() ) {
|
|
entity.Velocity.Y += (hacks.Speeding && hacks.CanSpeed) ? 0.15f : 0.10f;
|
|
canLiquidJump = false;
|
|
} else if( entity.onGround ) {
|
|
DoNormalJump();
|
|
}
|
|
}
|
|
|
|
public void DoNormalJump() {
|
|
entity.Velocity.Y = jumpVel;
|
|
if( hacks.Speeding && hacks.CanSpeed ) entity.Velocity.Y += jumpVel;
|
|
if( hacks.HalfSpeeding && hacks.CanSpeed ) entity.Velocity.Y += jumpVel / 2;
|
|
canLiquidJump = false;
|
|
}
|
|
|
|
bool StandardLiquid( byte block ) {
|
|
return info.Collide[block] == CollideType.SwimThrough;
|
|
}
|
|
|
|
static Vector3 waterDrag = new Vector3( 0.8f, 0.8f, 0.8f ),
|
|
lavaDrag = new Vector3( 0.5f, 0.5f, 0.5f ),
|
|
ropeDrag = new Vector3( 0.5f, 0.85f, 0.5f ),
|
|
normalDrag = new Vector3( 0.91f, 0.98f, 0.91f ),
|
|
airDrag = new Vector3( 0.6f, 1f, 0.6f );
|
|
const float liquidGrav = 0.02f, ropeGrav = 0.034f, normalGrav = 0.08f;
|
|
internal const float Gravity = normalGrav;
|
|
|
|
public void PhysicsTick( float xMoving, float zMoving ) {
|
|
if( hacks.Noclip ) entity.onGround = false;
|
|
float multiply = GetBaseMultiply( true );
|
|
float yMultiply = GetBaseMultiply( hacks.CanSpeed );
|
|
float modifier = LowestSpeedModifier();
|
|
|
|
float yMul = Math.Max( 1f, yMultiply / 5 ) * modifier;
|
|
float horMul = multiply * modifier;
|
|
if( !(hacks.Flying || hacks.Noclip) ) {
|
|
if( secondJump ) { horMul *= 93f; yMul *= 10f; }
|
|
else if( firstJump ) { horMul *= 46.5f; yMul *= 7.5f; }
|
|
}
|
|
|
|
if( entity.TouchesAnyWater() && !hacks.Flying && !hacks.Noclip ) {
|
|
MoveNormal( xMoving, zMoving, 0.02f * horMul, waterDrag, liquidGrav, yMul );
|
|
} else if( entity.TouchesAnyLava() && !hacks.Flying && !hacks.Noclip ) {
|
|
MoveNormal( xMoving, zMoving, 0.02f * horMul, lavaDrag, liquidGrav, yMul );
|
|
} else if( entity.TouchesAnyRope() && !hacks.Flying && !hacks.Noclip ) {
|
|
MoveNormal( xMoving, zMoving, 0.02f * 1.7f, ropeDrag, ropeGrav, yMul );
|
|
} else {
|
|
float factor = !(hacks.Flying || hacks.Noclip) && entity.onGround ? 0.1f : 0.02f;
|
|
float gravity = useLiquidGravity ? liquidGrav : normalGrav;
|
|
if( hacks.Flying || hacks.Noclip )
|
|
MoveFlying( xMoving, zMoving, factor * horMul, normalDrag, gravity, yMul );
|
|
else
|
|
MoveNormal( xMoving, zMoving, factor * horMul, normalDrag, gravity, yMul );
|
|
|
|
if( entity.BlockUnderFeet == Block.Ice && !(hacks.Flying || hacks.Noclip) ) {
|
|
// limit components to +-0.25f by rescaling vector to [-0.25, 0.25]
|
|
if( Math.Abs( entity.Velocity.X ) > 0.25f || Math.Abs( entity.Velocity.Z ) > 0.25f ) {
|
|
float scale = Math.Min(
|
|
Math.Abs( 0.25f / entity.Velocity.X ), Math.Abs( 0.25f / entity.Velocity.Z ) );
|
|
entity.Velocity.X *= scale;
|
|
entity.Velocity.Z *= scale;
|
|
}
|
|
} else if( entity.onGround || hacks.Flying ) {
|
|
entity.Velocity *= airDrag; // air drag or ground friction
|
|
}
|
|
}
|
|
|
|
if( entity.onGround ) { firstJump = false; secondJump = false; }
|
|
}
|
|
|
|
void AdjHeadingVelocity( float x, float z, float factor ) {
|
|
float dist = (float)Math.Sqrt( x * x + z * z );
|
|
if( dist < 0.00001f ) return;
|
|
if( dist < 1 ) dist = 1;
|
|
|
|
float multiply = factor / dist;
|
|
entity.Velocity += Utils.RotateY( x * multiply, 0, z * multiply, entity.HeadYawRadians );
|
|
}
|
|
|
|
void MoveFlying( float xMoving, float zMoving, float factor, Vector3 drag, float gravity, float yMul ) {
|
|
AdjHeadingVelocity( zMoving, xMoving, factor );
|
|
float yVel = (float)Math.Sqrt( entity.Velocity.X * entity.Velocity.X + entity.Velocity.Z * entity.Velocity.Z );
|
|
// make horizontal speed the same as vertical speed.
|
|
if( (xMoving != 0 || zMoving != 0) && yVel > 0.001f ) {
|
|
entity.Velocity.Y = 0;
|
|
yMul = 1;
|
|
if( hacks.FlyingUp || jumping ) entity.Velocity.Y += yVel;
|
|
if( hacks.FlyingDown ) entity.Velocity.Y -= yVel;
|
|
}
|
|
Move( xMoving, zMoving, factor, drag, gravity, yMul );
|
|
}
|
|
|
|
void MoveNormal( float xMoving, float zMoving, float factor, Vector3 drag, float gravity, float yMul ) {
|
|
AdjHeadingVelocity( zMoving, xMoving, factor );
|
|
Move( xMoving, zMoving, factor, drag, gravity, yMul );
|
|
}
|
|
|
|
void Move( float xMoving, float zMoving, float factor, Vector3 drag, float gravity, float yMul ) {
|
|
entity.Velocity.Y *= yMul;
|
|
if( !hacks.Noclip )
|
|
collisions.MoveAndWallSlide();
|
|
entity.Position += entity.Velocity;
|
|
|
|
entity.Velocity.Y /= yMul;
|
|
entity.Velocity *= drag;
|
|
entity.Velocity.Y -= gravity;
|
|
}
|
|
|
|
float GetBaseMultiply( bool canSpeed ) {
|
|
float multiply = 0;
|
|
if( hacks.Flying || hacks.Noclip ) {
|
|
if( hacks.Speeding && canSpeed ) multiply += hacks.SpeedMultiplier * 8;
|
|
if( hacks.HalfSpeeding && canSpeed ) multiply += hacks.SpeedMultiplier * 8 / 2;
|
|
if( multiply == 0 ) multiply = 8f;
|
|
} else {
|
|
if( hacks.Speeding && canSpeed ) multiply += hacks.SpeedMultiplier;
|
|
if( hacks.HalfSpeeding && canSpeed ) multiply += hacks.SpeedMultiplier / 2;
|
|
if( multiply == 0 ) multiply = 1;
|
|
}
|
|
return hacks.CanSpeed ? multiply : Math.Min( multiply, hacks.MaxSpeedMultiplier );
|
|
}
|
|
|
|
const float inf = float.PositiveInfinity;
|
|
float LowestSpeedModifier() {
|
|
AABB bounds = entity.CollisionBounds;
|
|
useLiquidGravity = false;
|
|
float baseModifier = LowestModifier( bounds, false );
|
|
bounds.Min.Y -= 0.5f/16f; // also check block standing on
|
|
float solidModifier = LowestModifier( bounds, true );
|
|
|
|
if( baseModifier == inf && solidModifier == inf ) return 1;
|
|
return baseModifier == inf ? solidModifier : baseModifier;
|
|
}
|
|
|
|
float LowestModifier( AABB bounds, bool checkSolid ) {
|
|
Vector3I bbMin = Vector3I.Floor( bounds.Min );
|
|
Vector3I bbMax = Vector3I.Floor( bounds.Max );
|
|
float modifier = inf;
|
|
|
|
for( int y = bbMin.Y; y <= bbMax.Y; y++ )
|
|
for( int z = bbMin.Z; z <= bbMax.Z; z++ )
|
|
for( int x = bbMin.X; x <= bbMax.X; x++ )
|
|
{
|
|
byte block = game.World.SafeGetBlock( x, y, z );
|
|
if( block == 0 ) continue;
|
|
CollideType type = info.Collide[block];
|
|
if( type == CollideType.Solid && !checkSolid )
|
|
continue;
|
|
|
|
Vector3 min = new Vector3( x, y, z ) + info.MinBB[block];
|
|
Vector3 max = new Vector3( x, y, z ) + info.MaxBB[block];
|
|
AABB blockBB = new AABB( min, max );
|
|
if( !blockBB.Intersects( bounds ) ) continue;
|
|
|
|
modifier = Math.Min( modifier, info.SpeedMultiplier[block] );
|
|
if( block >= BlockInfo.CpeCount && type == CollideType.SwimThrough )
|
|
useLiquidGravity = true;
|
|
}
|
|
return modifier;
|
|
}
|
|
|
|
/// <summary> Calculates the jump velocity required such that when a client presses
|
|
/// the jump binding they will be able to jump up to the given height. </summary>
|
|
internal void CalculateJumpVelocity( float jumpHeight ) {
|
|
jumpVel = 0;
|
|
if( jumpHeight >= 256 ) jumpVel = 10.0f;
|
|
if( jumpHeight >= 512 ) jumpVel = 16.5f;
|
|
if( jumpHeight >= 768 ) jumpVel = 22.5f;
|
|
|
|
while( GetMaxHeight( jumpVel ) <= jumpHeight )
|
|
jumpVel += 0.001f;
|
|
}
|
|
|
|
public static double GetMaxHeight( float u ) {
|
|
// equation below comes from solving diff(x(t, u))= 0
|
|
// We only work in discrete timesteps, so test both rounded up and down.
|
|
double t = 49.49831645 * Math.Log( 0.247483075 * u + 0.9899323 );
|
|
return Math.Max( YPosAt( (int)t, u ), YPosAt( (int)t + 1, u ) );
|
|
}
|
|
|
|
static double YPosAt( int t, float u ) {
|
|
// v(t, u) = (4 + u) * (0.98^t) - 4, where u = initial velocity
|
|
// x(t, u) = Σv(t, u) from 0 to t (since we work in discrete timesteps)
|
|
// plugging into Wolfram Alpha gives 1 equation as
|
|
// (0.98^t) * (-49u - 196) - 4t + 50u + 196
|
|
double a = Math.Exp( -0.0202027 * t ); //~0.98^t
|
|
return a * ( -49 * u - 196 ) - 4 * t + 50 * u + 196;
|
|
}
|
|
}
|
|
} |