diff --git a/Game.Client/C_BasePlayer.cs b/Game.Client/C_BasePlayer.cs index 48448b37..0bb29b46 100644 --- a/Game.Client/C_BasePlayer.cs +++ b/Game.Client/C_BasePlayer.cs @@ -551,6 +551,7 @@ public override void Dispose() { public float GetStepSize() => Local.StepSize; float OldPlayerZ; + float OldPlayerViewOffsetZ; bool WasFreezeFraming; Vector3 FreezeFrameStart; TimeUnit_t FreezeFrameStartTime; diff --git a/Game.Server/AI_BaseNPC.cs b/Game.Server/AI_BaseNPC.cs index c7aeec05..f5ee04c3 100644 --- a/Game.Server/AI_BaseNPC.cs +++ b/Game.Server/AI_BaseNPC.cs @@ -9085,6 +9085,8 @@ public void UpdateEfficiency(bool inPVS) { SetEfficiency((AI_Efficiency)Math.Clamp((int)efficiency, (int)minEfficiency, (int)maxEfficiency)); } + public virtual void PlayerPenetratingVPhysics() => PerformAvoidance = true; + public void GetPlayerAvoidBounds(out Vector3 mins, out Vector3 maxs) { mins = WorldAlignMins(); maxs = WorldAlignMaxs(); diff --git a/Game.Server/BaseCombatCharacter.cs b/Game.Server/BaseCombatCharacter.cs index 9187c5a2..9d78bd25 100644 --- a/Game.Server/BaseCombatCharacter.cs +++ b/Game.Server/BaseCombatCharacter.cs @@ -6,6 +6,7 @@ using Source.Common.Engine; using Source.Common.Formats.BSP; using Source.Common.Mathematics; +using Source.Common.Physics; using System.Numerics; using System.Runtime.CompilerServices; @@ -354,6 +355,63 @@ public virtual int IRelationPriority(BaseEntity? target) { public void SetImpactEnergyScale(float scale) => ImpactEnergyScale = scale; + static readonly ConVar phys_stressbodyweights = new("phys_stressbodyweights", "5.0"); + + static readonly float MaxStressDamageForce = BitConverter.Int32BitsToSingle(0x5f0ede49); + + public override void VPhysicsUpdate(IPhysicsObject physics) { + ApplyStressDamage(physics, false); + base.VPhysicsUpdate(physics); + } + + public virtual float CalculatePhysicsStressDamage(out VPhysicsObjectStress stressOut, IPhysicsObject physics) { + float mass = physics.GetMass(); + CalculateObjectStress(physics, this, out stressOut); + float stress = (stressOut.ReceivedStress * ImpactEnergyScale) / mass; + + if (stressOut.HasNonStaticStress && stress > phys_stressbodyweights.GetFloat()) { + if ((physics.GetGameFlags() & PhysicsFlags.Penetrating) == 0) + return 200; + } + + return 0; + } + + public virtual void ApplyStressDamage(IPhysicsObject physics, bool requireLargeObject) { + if (Classify() == Class_T.PlayerAlly || Classify() == Class_T.PlayerAllyVital) { + if (hl2_episodic.GetBool()) + return; + } + + float damage = CalculatePhysicsStressDamage(out VPhysicsObjectStress stressOut, physics); + if (damage > 0) { + if (requireLargeObject && !stressOut.HasLargeObjectContact) + return; + + TakeDamageInfo dmgInfo = new(GetWorldEntity(), GetWorldEntity(), vec3_origin, vec3_origin, damage, DamageType.Crush); + float force = -stressOut.ReceivedStress * GetCurrentGravity() * (float)gpGlobals.FrameTime; + if (force > -MaxStressDamageForce && force < MaxStressDamageForce) + dmgInfo.SetDamageForce(new Vector3(0, 0, force)); + dmgInfo.SetDamagePosition(GetAbsOrigin()); + + if (stressOut.StressObject?.GetGameData() is BaseEntity stressEntity) { + dmgInfo.SetInflictor(stressEntity); + dmgInfo.SetAttacker(stressEntity); + + BaseEntity? owner = stressEntity.GetOwnerEntity(); + if (owner != null) + dmgInfo.SetAttacker(owner); + else { + BasePlayer? physicsAttacker = stressEntity.HasPhysicsAttacker(1.0); + if (physicsAttacker != null) + dmgInfo.SetAttacker(physicsAttacker); + } + } + + TakeDamage(dmgInfo); + } + } + public AI_HullType GetHullType() => Hull; public void SetHullType(AI_HullType hullType) => Hull = hullType; diff --git a/Game.Server/BaseEntity.cs b/Game.Server/BaseEntity.cs index 980311b7..d5e2273d 100644 --- a/Game.Server/BaseEntity.cs +++ b/Game.Server/BaseEntity.cs @@ -1372,7 +1372,7 @@ public static void EmitSound(scoped in IRF filter, int entIndex, scoped in public int GetTeamNumber() => TeamNum; IPhysicsObject? PhysicsObject = null!; - public void VPhysicsUpdate(IPhysicsObject physics) { + public virtual void VPhysicsUpdate(IPhysicsObject physics) { switch (GetMoveType()) { case Source.MoveType.VPhysics: { if (GetMoveParent() != null) { @@ -1431,6 +1431,10 @@ public void PhysicsRelinkChildren(TimeUnit_t dt) { public virtual void VPhysicsShadowCollision(int index, ref GameVCollisionEvent ev) { } + public virtual void VPhysicsShadowUpdate(IPhysicsObject physics) { } + + public virtual BasePlayer? HasPhysicsAttacker(TimeUnit_t dt) => null; + public virtual void VPhysicsCollision(int index, ref GameVCollisionEvent ev) { int otherIndex = index == 0 ? 1 : 0; BaseEntity hitEntity = ev.Entities[otherIndex]!; @@ -1474,6 +1478,16 @@ public void VPhysicsSetObject(IPhysicsObject? physics) { PhysicsObject = physics; } + public void VPhysicsSwapObject(IPhysicsObject? swap) { + if (swap == null) + PhysRemoveShadow(this); + + if (PhysicsObject == null) + Warning($"Bad vphysics swap for {GetClassname()}\n"); + + PhysicsObject = swap; + } + bool VPhysicsInitSetup() { // don't support logical ents if (Edict() == null || IsMarkedForDeletion()) diff --git a/Game.Server/EntityList.cs b/Game.Server/EntityList.cs index 0b471fd3..03ee0af5 100644 --- a/Game.Server/EntityList.cs +++ b/Game.Server/EntityList.cs @@ -38,7 +38,7 @@ internal class EntItem public class EntityList { int NumItems; - EntItem? ItemList; + internal EntItem? ItemList; public void AddEntity(BaseEntity ent) { // check if it's already in the list; if not, add it diff --git a/Game.Server/Physics.cs b/Game.Server/Physics.cs index 56c79361..8710bad3 100644 --- a/Game.Server/Physics.cs +++ b/Game.Server/Physics.cs @@ -34,6 +34,13 @@ public static class PhysicsHookGlobals { public const float VPHYSICS_LARGE_OBJECT_MASS = 500.0f; + public static readonly ConVar phys_timescale = new("phys_timescale", "1", FCvar.Replicated, "Scale time for physics", callback: TimescaleChanged); + public static float g_GMOD_PhysTimeScale = 1.0f; + + static void TimescaleChanged(IConVar var, in ConVarChangeContext ctx) => physenv?.ResetSimulationClock(); + + public static float GMOD_PhysicsGetTotalTimeScale() => phys_timescale.GetFloat() * g_GMOD_PhysTimeScale; + static PhysicsHookGlobals(){ SetPhysicsGameSystem(g_PhysicsHook); } @@ -251,6 +258,7 @@ public static bool PhysIsInCallback(){ public static void PhysAddShadow(BaseEntity entity) => g_ShadowEntities!.AddEntity(entity); public static void PhysRemoveShadow(BaseEntity entity) => g_ShadowEntities!.DeleteEntity(entity); + public static void PhysGetListOfPenetratingEntities(BaseEntity search, List list) => g_Collisions.GetListOfPenetratingEntities(search, list); public static void PhysOnCleanupDeleteList() { g_Collisions.FlushQueuedOperations(); @@ -440,6 +448,18 @@ void PhysFrame(TimeUnit_t deltaTime) { ArrayPool.Shared.Return(activeList, true); } + for (EntItem? item = g_ShadowEntities!.ItemList; item != null; item = item.Next) { + BaseEntity? entity = item.Ent.Get(); + if (entity == null) { + Msg("Dangling pointer to physics entity!!!\n"); + continue; + } + + IPhysicsObject? physics = entity.VPhysicsGetObject(); + if (physics != null && !physics.IsAsleep()) + entity.VPhysicsShadowUpdate(physics); + } + g_Collisions.BufferTouchEvents(false); g_Collisions.FrameUpdate(); } diff --git a/Game.Server/PhysicsImpactDamage.cs b/Game.Server/PhysicsImpactDamage.cs new file mode 100644 index 00000000..7f3a44cc --- /dev/null +++ b/Game.Server/PhysicsImpactDamage.cs @@ -0,0 +1,194 @@ +global using static Game.Server.PhysicsImpactDamage; + +using Game.Shared; + +using Source; +using Source.Common.Mathematics; +using Source.Common.Physics; + +using System.Numerics; + +namespace Game.Server; + +public struct VPhysicsObjectStress +{ + public float ExertedStress; + public float ReceivedStress; + public bool HasNonStaticStress; + public bool HasLargeObjectContact; + public IPhysicsObject? StressObject; +} + +public static class PhysicsImpactDamage +{ + static bool IsPhysicallyControlled(BaseEntity entity, IPhysicsObject physics) { + bool isPhysical = false; + if (entity.GetMoveType() == Source.MoveType.VPhysics) + isPhysical = true; + else { + IPhysicsShadowController? shadow = physics.GetShadowController(); + if (shadow != null) + isPhysical = shadow.IsPhysicallyControlled(); + } + return isPhysical; + } + + public static float CalculateObjectStress(IPhysicsObject obj, BaseEntity inputOwnerEntity, out VPhysicsObjectStress output) { + List objectList = []; + List objectForce = []; + bool hasLargeObject = false; + IPhysicsObject? stressObject = null; + + objectList.Add(null); + objectForce.Add(vec3_origin); + objectList.Add(null); + objectForce.Add(vec3_origin); + + BaseCombatCharacter? bcc = inputOwnerEntity.MyCombatCharacterPointer(); + + IPhysicsFrictionSnapshot snapshot = obj.CreateFrictionSnapshot(); + float objMass = obj.GetMass(); + while (snapshot.IsValid()) { + float force = snapshot.GetNormalForce(); + if (force > 0.0f) { + IPhysicsObject other = snapshot.GetObject(1)!; + BaseEntity? otherEntity = other.GetGameData() as BaseEntity; + otherEntity ??= GetWorldEntity()!; + + BaseEntity otherOwner = otherEntity; + if (otherEntity.GetOwnerEntity() != null) + otherOwner = otherEntity.GetOwnerEntity()!; + + int outIndex = 0; + if (!other.IsMoveable()) + outIndex = 0; + else if (bcc != null && (bcc.IRelationType(otherOwner) == Disposition.LI || otherEntity.IsNavIgnored())) + outIndex = 1; + else if ((other.GetGameFlags() & PhysicsFlags.PlayerHeld) != 0) + outIndex = 1; + else { + if (other.GetMass() >= VPHYSICS_LARGE_OBJECT_MASS) { + if (inputOwnerEntity.GetGroundEntity() != otherEntity) + hasLargeObject = true; + } + + outIndex = objectList.Count; + for (int i = objectList.Count - 1; i >= 2; --i) { + if (objectList[i] == otherOwner) { + outIndex = i; + break; + } + } + + if (outIndex == objectList.Count) { + objectList.Add(otherOwner); + objectForce.Add(vec3_origin); + stressObject ??= other; + } + } + + if (outIndex != 0 && inputOwnerEntity.GetMoveType() != Source.MoveType.VPhysics && !IsPhysicallyControlled(otherEntity, other)) + force = 0.0f; + + snapshot.GetSurfaceNormal(out Vector3 normal); + objectForce[outIndex] += normal * force; + } + snapshot.NextFrictionData(); + } + obj.DestroyFrictionSnapshot(snapshot); + + objectForce[1] = vec3_origin; + + float sum = 0; + Vector3 negativeForce = vec3_origin; + Vector3 positiveForce = vec3_origin; + + Assert(objectList.Count == objectForce.Count); + for (int objectIndex = objectList.Count - 1; objectIndex >= 0; --objectIndex) { + Vector3 force = objectForce[objectIndex]; + sum += force.Length(); + for (int i = 0; i < 3; i++) { + if (force[i] < 0) + negativeForce[i] -= force[i]; + else + positiveForce[i] += force[i]; + } + } + + Vector3 internalForce = vec3_origin; + Vector3 externalForce = vec3_origin; + + for (int i = 0; i < 3; i++) { + if (negativeForce[i] < positiveForce[i]) { + internalForce[i] = positiveForce[i] - negativeForce[i]; + externalForce[i] = negativeForce[i]; + } + else { + internalForce[i] = negativeForce[i] - positiveForce[i]; + externalForce[i] = positiveForce[i]; + } + } + + physenv.GetGravity(out Vector3 gravVector); + float gravity = gravVector.Length(); + if (inputOwnerEntity.GetMoveType() != Source.MoveType.VPhysics && obj.IsMoveable()) { + Vector3 lastVel = vec3_origin; + IPhysicsShadowController? shadow = obj.GetShadowController(); + if (shadow != null) + shadow.GetLastImpulse(out lastVel); + else { + if ((obj.GetCallbackFlags() & CallbackFlags.IsPlayerController) != 0) { + BasePlayer? player = ToBasePlayer(inputOwnerEntity); + IPhysicsPlayerController? controller = player?.GetPhysicsController(); + controller?.GetLastImpulse(out lastVel); + } + } + + float inputLen = lastVel.Length() * (1.0f / (float)physenv.GetSimulationTimestep()) * objMass; + if (inputLen > 0.0f) { + float internalLen = internalForce.Length(); + if (internalLen < inputLen) { + float ratio = internalLen / inputLen; + Vector3 delta = internalForce * (1.0f - ratio); + internalForce += delta; + float deltaLen = delta.Length(); + sum -= deltaLen; + float extLen = MathLib.VectorNormalize(ref externalForce) - deltaLen; + if (extLen < 0) + extLen = 0; + + externalForce *= extLen; + } + } + } + + float invGravity = gravity; + if (invGravity <= 0) + invGravity = 1.0f; + else + invGravity = 1.0f / invGravity; + + sum *= invGravity; + internalForce *= invGravity; + externalForce *= invGravity; + if (!obj.IsMoveable()) { + externalForce = internalForce; + internalForce = vec3_origin; + + if (!obj.IsStatic()) + sum += objMass; + } + else { + if (sum > objMass) + sum = objMass + (sum - objMass) * 0.5f; + } + + output.ExertedStress = internalForce.Length(); + output.ReceivedStress = externalForce.Length(); + output.HasNonStaticStress = objectList.Count > 2; + output.HasLargeObjectContact = hasLargeObject; + output.StressObject = stressObject; + + return sum; + } +} diff --git a/Game.Server/Player.cs b/Game.Server/Player.cs index 2511ab3e..0da87e0a 100644 --- a/Game.Server/Player.cs +++ b/Game.Server/Player.cs @@ -1,4 +1,4 @@ -global using static Game.Server.PlayerConvars; +global using static Game.Server.PlayerConvars; using Game.Shared; @@ -236,6 +236,13 @@ public void SetLocalOrigin(in Vector3 origin) { } [Flags] +public enum VPhysicsCollisionState +{ + Walk, + Crouch, + Noclip, +} + public enum PlayerPhysFlag { DirOverride = 1 << 0, @@ -394,6 +401,8 @@ public void SetPhysicsFlag(PlayerPhysFlag flag, bool set) { int LastDmageAmount; Vector3 DmgOrigin; Vector3 OldOrigin; + float OldPlayerZ; + float OldPlayerViewOffsetZ; bool ForceOrigin; Vector3 ForcedOrigin; Vector3 SmoothedVelocity; @@ -1451,10 +1460,10 @@ public override void PhysicsSimulate() { for (int i = 0; i < commandsToRun; ++i) { PlayerRunCommand(vecAvailCommands[i], MoveHelperServer.s_MoveHelperServer); - // if (PhysicsController != null) { // todo - // // UpdateVPhysicsPosition(vNewVPhysicsPosition, vNewVPhysicsVelocity, vphysicsArrivalTime); - // vphysicsArrivalTime += TICK_INTERVAL; - // } + if (PhysicsController != null) { + UpdateVPhysicsPosition(NewVPhysicsPosition, NewVPhysicsVelocity, (float)vphysicsArrivalTime); + vphysicsArrivalTime += TICK_INTERVAL; + } } IPredictionSystem.SuppressHostEvents(null); @@ -1497,6 +1506,9 @@ private void RunLastCommand() { MoveHelperServer.s_MoveHelperServer.SetHost(this); PlayerRunCommand(cmd, MoveHelperServer.s_MoveHelperServer); + if (PhysicsController != null) + UpdateVPhysicsPosition(NewVPhysicsPosition, NewVPhysicsVelocity, (float)TICK_INTERVAL); + if (VecPlayerSimInfo.Count > 0) { PlayerSimInfo pi = VecPlayerSimInfo[VecPlayerSimInfo.Count - 1]; pi.Time = Platform.Time; @@ -1740,58 +1752,381 @@ public virtual void PostThink() { } IPhysicsPlayerController? PhysicsController; + IPhysicsObject? ShadowStand; + IPhysicsObject? ShadowCrouch; + VPhysicsCollisionState CollisionState; + Vector3 NewVPhysicsPosition; + Vector3 NewVPhysicsVelocity; + + public IPhysicsPlayerController? GetPhysicsController() => PhysicsController; public void InitVCollision(in Vector3 vecAbsOrigin, in Vector3 vecAbsVelocity) { VPhysicsDestroyObject(); - PhysCollide model = physcollision.BBoxToCollide(GetPlayerMins(), GetPlayerMaxs()); + PhysCollide? model = PhysCreateBbox(VEC_HULL_MIN_SCALED(this), VEC_HULL_MAX_SCALED(this)); + PhysCollide? crouchModel = PhysCreateBbox(VEC_DUCK_HULL_MIN_SCALED(this), VEC_DUCK_HULL_MAX_SCALED(this)); - ObjectParams solid = g_PhysDefaultObjectParams; - solid.GameData = this; - solid.Name = "player"; - solid.Mass = 85.0f; - solid.Inertia = 1e24f; - solid.EnableCollisions = true; - solid.DragCoefficient = 0; + SetupVPhysicsShadow(vecAbsOrigin, vecAbsVelocity, model, "player_stand", crouchModel, "player_crouch"); + } - IPhysicsObject? shadow = physenv.CreatePolyObject(model, (int)physprops.GetSurfaceIndex("player"), vecAbsOrigin, vec3_angle, ref solid); - if (shadow == null) + public void SetupVPhysicsShadow(in Vector3 vecAbsOrigin, in Vector3 vecAbsVelocity, PhysCollide? standModel, ReadOnlySpan standHullName, PhysCollide? crouchModel, ReadOnlySpan crouchHullName) { + if (standModel == null || crouchModel == null) { + Warning("Failed to create player physics shadow due to invalid collision model! Are player hull values valid?\n"); return; + } - VPhysicsSetObject(shadow); - PhysAddShadow(this); + if (ShadowStand != null) + Error("CBasePlayer m_pShadowStand already exists?\n"); + if (ShadowCrouch != null) + Error("CBasePlayer m_pShadowCrouch already exists?\n"); + if (PhysicsController != null) + Error("CBasePlayer m_pPhysicsController already exists?\n"); + + Solid solid = default; + strcpy(solid.SurfaceProp, "player"); + solid.Params = g_PhysDefaultObjectParams; + solid.Params.Mass = 85.0f; + solid.Params.Inertia = 1e24f; + solid.Params.EnableCollisions = false; + solid.Params.DragCoefficient = 0; + + ShadowStand = PhysModelCreateCustom(this, standModel, GetLocalOrigin(), GetLocalAngles(), standHullName, false, ref solid); + ShadowStand!.SetCallbackFlags(CallbackFlags.GlobalCollision | CallbackFlags.ShadowCollision); + + ShadowCrouch = PhysModelCreateCustom(this, crouchModel, GetLocalOrigin(), GetLocalAngles(), crouchHullName, false, ref solid); + ShadowCrouch!.SetCallbackFlags(CallbackFlags.GlobalCollision | CallbackFlags.ShadowCollision); - PhysicsController = physenv.CreatePlayerController(shadow); + VPhysicsSetObject(ShadowStand); + + PhysAddShadow(this); + PhysicsController = physenv.CreatePlayerController(ShadowStand); PhysicsController.SetPushMassLimit(350.0f); PhysicsController.SetPushSpeedLimit(50.0f); - shadow.SetPosition(vecAbsOrigin, vec3_angle, true); + UpdatePhysicsShadowToPosition(vecAbsOrigin); + + SetVCollisionState(vecAbsOrigin, vecAbsVelocity, (GetFlags() & EntityFlags.Ducking) != 0 ? VPhysicsCollisionState.Crouch : VPhysicsCollisionState.Walk); } - bool ShadowCollisionsDisabled; + public override void VPhysicsDestroyObject() { + IPhysicsObject? physics = VPhysicsGetObject(); + if (physics == ShadowStand || physics == ShadowCrouch) + VPhysicsSetObject(null); - void UpdateVPhysicsShadowState() { - IPhysicsObject? shadow = VPhysicsGetObject(); - if (shadow == null) - return; + PhysRemoveShadow(this); - MoveType mt = (MoveType)GetMoveType(); - bool noclip = mt == Source.MoveType.Noclip || mt == Source.MoveType.Observer; - if (noclip != ShadowCollisionsDisabled) { - ShadowCollisionsDisabled = noclip; - shadow.EnableCollisions(!noclip); + if (PhysicsController != null) { + physenv.DestroyPlayerController(PhysicsController); + PhysicsController = null; + } + + if (ShadowStand != null) { + ShadowStand.EnableCollisions(false); + PhysDestroyObject(ShadowStand, null!); + ShadowStand = null; + } + + if (ShadowCrouch != null) { + ShadowCrouch.EnableCollisions(false); + PhysDestroyObject(ShadowCrouch, null!); + ShadowCrouch = null; + } + + base.VPhysicsDestroyObject(); + } + + public void SetVCollisionState(in Vector3 vecAbsOrigin, in Vector3 vecAbsVelocity, VPhysicsCollisionState collisionState) { + CollisionState = collisionState; + switch (collisionState) { + case VPhysicsCollisionState.Walk: + ShadowStand!.SetPosition(vecAbsOrigin, vec3_angle, true); + ShadowStand.SetVelocity(vecAbsVelocity, new Vector3(float.NaN)); + ShadowCrouch!.EnableCollisions(false); + PhysicsController!.SetObject(ShadowStand); + VPhysicsSwapObject(ShadowStand); + ShadowStand.EnableCollisions(true); + break; + + case VPhysicsCollisionState.Crouch: + ShadowCrouch!.SetPosition(vecAbsOrigin, vec3_angle, true); + ShadowCrouch.SetVelocity(vecAbsVelocity, new Vector3(float.NaN)); + ShadowStand!.EnableCollisions(false); + PhysicsController!.SetObject(ShadowCrouch); + VPhysicsSwapObject(ShadowCrouch); + ShadowCrouch.EnableCollisions(true); + break; + + case VPhysicsCollisionState.Noclip: + ShadowCrouch!.EnableCollisions(false); + ShadowStand!.EnableCollisions(false); + break; } } + public bool IsRideablePhysics(IPhysicsObject? physics) { + if (physics != null) { + if (physics.GetMass() > (VPhysicsGetObject()!.GetMass() * 2)) + return true; + } + + return false; + } + + public IPhysicsObject? GetGroundVPhysics() { + BaseEntity? groundEntity = GetGroundEntity(); + if (groundEntity != null && groundEntity.GetMoveType() == Source.MoveType.VPhysics) { + IPhysicsObject? physGround = groundEntity.VPhysicsGetObject(); + if (physGround != null && physGround.IsMoveable()) + return physGround; + } + + return null; + } + + public void SetTouchedPhysics(bool touch) => TouchedPhysObject = touch; + public bool TouchedPhysics() => TouchedPhysObject; + + public override void Touch(BaseEntity? other) { + if (other == GetGroundEntity()) + return; + + if (other!.GetMoveType() != Source.MoveType.VPhysics || other.GetSolid() != SolidType.VPhysics || (other.GetSolidFlags() & SolidFlags.Trigger) != 0) + return; + + IPhysicsObject? phys = other.VPhysicsGetObject(); + if (phys == null || !phys.IsMoveable()) + return; + + SetTouchedPhysics(true); + } + public void PostThinkVPhysics() { if (PhysicsController == null) return; - UpdateVPhysicsShadowState(); + Vector3 newPosition = GetAbsOrigin(); + float frametime = (float)gpGlobals.FrameTime; + if (frametime <= 0 || frametime > 0.1f) + frametime = 0.1f; + + IPhysicsObject? physGround = GetGroundVPhysics(); + + if (physGround == null && TouchedPhysObject && g_MoveData.StepHeight <= 0.0f && (GetFlags() & EntityFlags.OnGround) != 0) { + newPosition = OldOrigin + frametime * g_MoveData.WishVel; + newPosition = (GetAbsOrigin() * 0.5f) + (newPosition * 0.5f); + } + + VPhysicsCollisionState collisionState = VPhysicsCollisionState.Walk; + if (GetMoveType() == Source.MoveType.Noclip || GetMoveType() == Source.MoveType.Observer) + collisionState = VPhysicsCollisionState.Noclip; + else if ((GetFlags() & EntityFlags.Ducking) != 0) + collisionState = VPhysicsCollisionState.Crouch; + + if (collisionState != CollisionState) + SetVCollisionState(GetAbsOrigin(), GetAbsVelocity(), collisionState); + + if (!(TouchedPhysics() || physGround != null)) { + float maxSpeed = Maxspeed > 0.0f ? Maxspeed : sv_maxspeed.GetFloat(); + g_MoveData.WishVel = new(maxSpeed, maxSpeed, maxSpeed); + } + + if (g_MoveData.StepHeight > 0.1f) { + if (g_MoveData.StepHeight > 4.0f) + VPhysicsGetObject()!.SetPosition(GetAbsOrigin(), vec3_angle, true); + else { + VPhysicsGetObject()!.GetPosition(out Vector3 position, out _); + Vector3 end = position; + end.Z += g_MoveData.StepHeight; + Util.TraceEntity(this, position, end, Mask.PlayerSolid, this, Source.CollisionGroup.PlayerMovement, out Trace trace); + if (trace.DidHit()) + g_MoveData.StepHeight = trace.EndPos.Z - position.Z; + + PhysicsController.StepUp(g_MoveData.StepHeight); + } + PhysicsController.Jump(); + } + g_MoveData.StepHeight = 0.0f; + + NewVPhysicsPosition = newPosition; + NewVPhysicsVelocity = g_MoveData.WishVel; + + OldOrigin = GetAbsOrigin(); + } + public void UpdateVPhysicsPosition(in Vector3 position, in Vector3 velocity, float secondsToArrival) { bool onground = (GetFlags() & EntityFlags.OnGround) != 0; - IPhysicsObject? ground = GetGroundEntity()?.VPhysicsGetObject(); - PhysicsController.Update(GetAbsOrigin(), GetAbsVelocity(), (float)gpGlobals.FrameTime, onground, ground!); + IPhysicsObject? physGround = GetGroundVPhysics(); + + if (!IsRideablePhysics(physGround)) + physGround = null; + + PhysicsController?.Update(position, velocity, secondsToArrival, onground, physGround!); + } + + public void UpdatePhysicsShadowToPosition(in Vector3 vecAbsOrigin) => UpdateVPhysicsPosition(vecAbsOrigin, vec3_origin, (float)gpGlobals.FrameTime); + + public virtual bool IsFollowingPhysics() => false; + + public override void VPhysicsUpdate(IPhysicsObject physics) { + float savedImpact = ImpactEnergyScale; + + ImpactEnergyScale *= 0.125f; + ApplyStressDamage(physics, true); + ImpactEnergyScale = savedImpact; + } + + static readonly ConVar physicsshadowupdate_render = new("physicsshadowupdate_render", "0"); + + const float VPHYS_MAX_DISTANCE = 2.0f; + const float VPHYS_MAX_VELOCITY = 10.0f; + const float VPHYS_MAX_DISTSQR = VPHYS_MAX_DISTANCE * VPHYS_MAX_DISTANCE; + const float VPHYS_MAX_VELSQR = VPHYS_MAX_VELOCITY * VPHYS_MAX_VELOCITY; + + const double ShadowAngleResetTolerance = 0.05; + + static void ResetShadowAngles(IPhysicsObject shadow) { + shadow.GetPosition(out Vector3 position, out QAngle angles); + float angleLength = MathF.Sqrt(angles.X * angles.X + angles.Y * angles.Y + angles.Z * angles.Z); + if (Math.Abs(angleLength % 360.0) > ShadowAngleResetTolerance) + shadow.SetPosition(position, vec3_angle, false); + } + + public override void VPhysicsShadowUpdate(IPhysicsObject physics) { + bool physicsUpdated = PhysicsController!.GetShadowPosition(out Vector3 newPosition, out _) > 0; + + if ((physics.GetGameFlags() & Source.Common.Physics.PhysicsFlags.Penetrating) != 0) { + List list = []; + PhysGetListOfPenetratingEntities(this, list); + for (int i = list.Count - 1; i >= 0; --i) { + if (list[i].GetMoveType() == Source.MoveType.VPhysics) + TouchedPhysObject = true; + + AI_BaseNPC? npc = list[i].MyNPCPointer(); + npc?.PlayerPenetratingVPhysics(); + } + } + + bool checkStuck = false; + if ((PhysicsFlags & PlayerPhysFlag.GamePhysicsRotPush) != 0) { + checkStuck = true; + PhysicsFlags &= ~PlayerPhysFlag.GamePhysicsRotPush; + } + + if (PhysicsController.IsInContact() || (PhysicsFlags & PlayerPhysFlag.VPhysicsMotionController) != 0) + TouchedPhysObject = true; + + if (IsFollowingPhysics()) + TouchedPhysObject = true; + + if (GetMoveType() == Source.MoveType.Noclip || pl.DeadFlag) { + OldOrigin = GetAbsOrigin(); + return; + } + + if (GMOD_PhysicsGetTotalTimeScale() == 0.0f) + return; + + if (!physicsUpdated) + return; + + ResetShadowAngles(ShadowStand!); + ResetShadowAngles(ShadowCrouch!); + + IPhysicsObject? physGround = GetGroundVPhysics(); + + physics.GetPosition(out newPosition, out _); + PhysicsController.GetShadowVelocity(out Vector3 newVelocity); + Vector3 lastValidPosition = newPosition; + + if (physicsshadowupdate_render.GetBool()) { + Game.Shared.DebugOverlay.Box(GetAbsOrigin(), WorldAlignMins(), WorldAlignMaxs(), 255, 0, 0, 24, 15.0f); + Game.Shared.DebugOverlay.Box(newPosition, WorldAlignMins(), WorldAlignMaxs(), 0, 0, 255, 24, 15.0f); + } + + Vector3 tmp = GetAbsOrigin() - newPosition; + if (!TouchedPhysObject && (GetFlags() & EntityFlags.OnGround) == 0) + tmp.Z *= 0.5f; + + float dist = tmp.LengthSquared(); + float deltaV = (newVelocity - GetAbsVelocity()).LengthSquared(); + + float maxDistErrorSqr = VPHYS_MAX_DISTSQR; + float maxVelErrorSqr = VPHYS_MAX_VELSQR; + if (IsRideablePhysics(physGround)) { + maxDistErrorSqr *= 0.25f; + maxVelErrorSqr *= 0.25f; + } + + Trace trace; + if (PhysicsController.WasFrozen()) { + PhysicsWasFrozen = true; + + Util.TraceEntity(this, GetAbsOrigin(), GetAbsOrigin(), Mask.PlayerSolid, this, Source.CollisionGroup.PlayerMovement, out trace); + if (!trace.StartSolid) + return; + + Util.TraceEntity(this, newPosition, GetAbsOrigin(), Mask.PlayerSolid, this, Source.CollisionGroup.PlayerMovement, out trace); + if (!trace.StartSolid) { + SetAbsOrigin(trace.EndPos); + UpdateVPhysicsPosition(trace.EndPos, vec3_origin, 0); + return; + } + } + + if (dist >= maxDistErrorSqr || deltaV >= maxVelErrorSqr || (physGround != null && !TouchedPhysObject)) { + if (TouchedPhysObject || physGround != null) { + if (deltaV >= maxVelErrorSqr && !PhysicsWasFrozen) { + Vector3 dir = GetAbsVelocity(); + float len = MathLib.VectorNormalize(ref dir); + float dot = Vector3.Dot(newVelocity, dir); + if (dot > len) + dot = len; + else if (dot < -len) + dot = -len; + + newVelocity += -dot * dir; + + if ((PhysicsFlags & PlayerPhysFlag.VPhysicsMotionController) != 0) { + float val = MathLib.Lerp(0.1f, len, dot); + newVelocity += (val - len) * dir; + } + + if (!IsRideablePhysics(physGround)) { + if ((PhysicsFlags & PlayerPhysFlag.VPhysicsMotionController) == 0 && IsSimulatingOnAlternateTicks()) + newVelocity *= 0.5f; + + ApplyAbsVelocityImpulse(newVelocity); + } + } + + Util.TraceEntity(this, newPosition, newPosition, Mask.PlayerSolid, this, Source.CollisionGroup.PlayerMovement, out trace); + if (!trace.AllSolid && !trace.StartSolid) + SetAbsOrigin(newPosition); + } + else + checkStuck = true; + } + else { + if (TouchedPhysObject) { + Util.TraceEntity(this, GetAbsOrigin(), GetAbsOrigin(), Mask.PlayerSolid, this, Source.CollisionGroup.PlayerMovement, out trace); + + if (trace.AllSolid || trace.StartSolid) { + checkStuck = true; + lastValidPosition = OldOrigin; + SetAbsOrigin(newPosition); + } + } + } + + if (checkStuck) { + Util.TraceEntity(this, GetAbsOrigin(), GetAbsOrigin(), Mask.PlayerSolid, this, Source.CollisionGroup.PlayerMovement, out trace); + + if (trace.AllSolid || trace.StartSolid) + SetAbsOrigin(lastValidPosition); + } + + OldOrigin = GetAbsOrigin(); + PhysicsWasFrozen = false; } public float GeigerRange = 1000; // range to nearest radiation source diff --git a/Game.Server/Props.cs b/Game.Server/Props.cs index f85907c0..5b531866 100644 --- a/Game.Server/Props.cs +++ b/Game.Server/Props.cs @@ -229,7 +229,7 @@ public virtual Vector3 PhysGunLaunchAngularImpulse() { public virtual Vector3 PhysGunLaunchVelocity(in Vector3 forward, float mass) => Pickup.DefaultPhysGunLaunchVelocity(forward, mass); - public virtual BasePlayer? HasPhysicsAttacker(TimeUnit_t dt) { + public override BasePlayer? HasPhysicsAttacker(TimeUnit_t dt) { if (gpGlobals.CurTime - dt <= LastPhysicsInfluenceTime) return PhysicsAttacker.Get(); diff --git a/Game.Shared/BaseEntityShared.cs b/Game.Shared/BaseEntityShared.cs index ee185f39..82de77ac 100644 --- a/Game.Shared/BaseEntityShared.cs +++ b/Game.Shared/BaseEntityShared.cs @@ -381,7 +381,7 @@ public void VPhysicsInitShadow(bool allowPhysicsMovement, bool allowPhysicsRotat #endif } public void VPhysicsInitShadow(bool allowPhysicsMovement, bool allowPhysicsRotation) => VPhysicsInitShadow(allowPhysicsMovement, allowPhysicsRotation, ref Unsafe.NullRef()); - public void VPhysicsDestroyObject() { + public virtual void VPhysicsDestroyObject() { if (PhysicsObject != null) { #if !CLIENT_DLL PhysRemoveShadow(this); diff --git a/Game.Shared/BasePlayerShared.cs b/Game.Shared/BasePlayerShared.cs index 7ac47d86..fc442dde 100644 --- a/Game.Shared/BasePlayerShared.cs +++ b/Game.Shared/BasePlayerShared.cs @@ -215,10 +215,57 @@ public virtual void CalcViewModelView(in Vector3 eyeOrigin, in QAngle eyeAngles) public void CalcViewRoll(ref QAngle angles) { // todo } + static readonly ConVar smoothstairs = new("smoothstairs", "1", FCvar.Replicated, "Smooth player eye z coordinate when traversing stairs."); + + public void SmoothViewOnStairs(ref Vector3 eyeOrigin) { + BaseEntity? groundEntity = GetGroundEntity(); + float currentPlayerZ = GetLocalOrigin().Z; + float currentPlayerViewOffsetZ = GetViewOffset().Z; + + if ((groundEntity != null && groundEntity.GetMoveType() == Source.MoveType.None) && (currentPlayerZ != OldPlayerZ) && smoothstairs.GetBool() && + OldPlayerViewOffsetZ == currentPlayerViewOffsetZ) { + int dir = (currentPlayerZ > OldPlayerZ) ? 1 : -1; + + float steptime = (float)gpGlobals.FrameTime; + if (steptime < 0) + steptime = 0; + + OldPlayerZ += steptime * 150 * dir; + + float stepSize = GetStepSize(); + + if (dir > 0) { + if (OldPlayerZ > currentPlayerZ) + OldPlayerZ = currentPlayerZ; + if (currentPlayerZ - OldPlayerZ > stepSize) + OldPlayerZ = currentPlayerZ - stepSize; + } + else { + if (OldPlayerZ < currentPlayerZ) + OldPlayerZ = currentPlayerZ; + if (currentPlayerZ - OldPlayerZ < -stepSize) + OldPlayerZ = currentPlayerZ + stepSize; + } + + eyeOrigin.Z += OldPlayerZ - currentPlayerZ; + } + else { + OldPlayerZ = currentPlayerZ; + OldPlayerViewOffsetZ = currentPlayerViewOffsetZ; + } + } + private void CalcPlayerView(ref Vector3 eyeOrigin, ref QAngle eyeAngles, ref float fov) { eyeOrigin = EyePosition(); eyeAngles = EyeAngles(); +#if CLIENT_DLL + if (!prediction.InPrediction()) +#endif + { + SmoothViewOnStairs(ref eyeOrigin); + } + Vector3 vecBaseEyePosition = eyeOrigin; CalcViewRoll(ref eyeAngles);