f29b38c44b
Use RMC movement values General feedback was it's too slow to push through people but this still prevents stacking so.
340 lines
11 KiB
C#
340 lines
11 KiB
C#
using System.Numerics;
|
|
using Content.Shared.CCVar;
|
|
using Content.Shared.Movement.Components;
|
|
using Robust.Shared;
|
|
using Robust.Shared.Configuration;
|
|
using Robust.Shared.Physics;
|
|
using Robust.Shared.Physics.Components;
|
|
using Robust.Shared.Physics.Systems;
|
|
using Robust.Shared.Random;
|
|
using Robust.Shared.Serialization;
|
|
using Robust.Shared.Utility;
|
|
|
|
namespace Content.Shared.Movement.Systems;
|
|
|
|
public abstract class SharedMobCollisionSystem : EntitySystem
|
|
{
|
|
[Dependency] protected readonly IConfigurationManager CfgManager = default!;
|
|
[Dependency] private readonly IRobustRandom _random = default!;
|
|
[Dependency] private readonly MovementSpeedModifierSystem _moveMod = default!;
|
|
[Dependency] protected readonly SharedPhysicsSystem Physics = default!;
|
|
[Dependency] private readonly SharedTransformSystem _xformSystem = default!;
|
|
|
|
protected EntityQuery<MobCollisionComponent> MobQuery;
|
|
protected EntityQuery<PhysicsComponent> PhysicsQuery;
|
|
|
|
/// <summary>
|
|
/// <see cref="CCVars.MovementPushingCap"/>
|
|
/// </summary>
|
|
private float _pushingCap;
|
|
|
|
/// <summary>
|
|
/// <see cref="CCVars.MovementPushingVelocityProduct"/>
|
|
/// </summary>
|
|
private float _pushingDotProduct;
|
|
|
|
/// <summary>
|
|
/// <see cref="CCVars.MovementMinimumPush"/>
|
|
/// </summary>
|
|
private float _minimumPushSquared = 0.01f;
|
|
|
|
private float _penCap;
|
|
|
|
/// <summary>
|
|
/// Time after we stop colliding with another mob before adjusting the movespeedmodifier.
|
|
/// This is required so if we stop colliding for a frame we don't fully reset and get jerky movement.
|
|
/// </summary>
|
|
public const float BufferTime = 0.2f;
|
|
|
|
private float _massDiffCap;
|
|
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
|
|
UpdatePushCap();
|
|
Subs.CVar(CfgManager, CVars.NetTickrate, _ => UpdatePushCap());
|
|
Subs.CVar(CfgManager, CCVars.MovementMinimumPush, val => _minimumPushSquared = val * val, true);
|
|
Subs.CVar(CfgManager, CCVars.MovementPenetrationCap, val => _penCap = val, true);
|
|
Subs.CVar(CfgManager, CCVars.MovementPushingCap, _ => UpdatePushCap());
|
|
Subs.CVar(CfgManager, CCVars.MovementPushingVelocityProduct,
|
|
value =>
|
|
{
|
|
_pushingDotProduct = value;
|
|
}, true);
|
|
Subs.CVar(CfgManager, CCVars.MovementPushMassCap, val => _massDiffCap = val, true);
|
|
|
|
MobQuery = GetEntityQuery<MobCollisionComponent>();
|
|
PhysicsQuery = GetEntityQuery<PhysicsComponent>();
|
|
SubscribeAllEvent<MobCollisionMessage>(OnCollision);
|
|
SubscribeLocalEvent<MobCollisionComponent, RefreshMovementSpeedModifiersEvent>(OnMoveModifier);
|
|
|
|
UpdatesBefore.Add(typeof(SharedPhysicsSystem));
|
|
}
|
|
|
|
private void UpdatePushCap()
|
|
{
|
|
_pushingCap = (1f / CfgManager.GetCVar(CVars.NetTickrate)) * CfgManager.GetCVar(CCVars.MovementPushingCap);
|
|
}
|
|
|
|
public override void Update(float frameTime)
|
|
{
|
|
base.Update(frameTime);
|
|
|
|
var query = AllEntityQuery<MobCollisionComponent>();
|
|
|
|
while (query.MoveNext(out var uid, out var comp))
|
|
{
|
|
if (!comp.Colliding)
|
|
continue;
|
|
|
|
comp.BufferAccumulator -= frameTime;
|
|
DirtyField(uid, comp, nameof(MobCollisionComponent.BufferAccumulator));
|
|
var direction = comp.Direction;
|
|
|
|
if (comp.BufferAccumulator <= 0f)
|
|
{
|
|
SetColliding((uid, comp), false, 1f);
|
|
}
|
|
// Apply the mob collision; if it's too low ignore it (e.g. if mob friction would overcome it).
|
|
// This is so we don't spam velocity changes every tick. It's not that expensive for physics but
|
|
// avoids the networking side.
|
|
else if (direction != Vector2.Zero && PhysicsQuery.TryComp(uid, out var physics))
|
|
{
|
|
DebugTools.Assert(direction.LengthSquared() >= _minimumPushSquared);
|
|
|
|
if (direction.Length() > _pushingCap)
|
|
{
|
|
direction = direction.Normalized() * _pushingCap;
|
|
}
|
|
|
|
Physics.ApplyLinearImpulse(uid, direction * physics.Mass, body: physics);
|
|
comp.Direction = Vector2.Zero;
|
|
DirtyField(uid, comp, nameof(MobCollisionComponent.Direction));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnMoveModifier(Entity<MobCollisionComponent> ent, ref RefreshMovementSpeedModifiersEvent args)
|
|
{
|
|
if (!ent.Comp.Colliding)
|
|
return;
|
|
|
|
args.ModifySpeed(ent.Comp.SpeedModifier);
|
|
}
|
|
|
|
private void SetColliding(Entity<MobCollisionComponent> entity, bool value, float speedMod)
|
|
{
|
|
if (value)
|
|
{
|
|
entity.Comp.BufferAccumulator = BufferTime;
|
|
DirtyField(entity.Owner, entity.Comp, nameof(MobCollisionComponent.BufferAccumulator));
|
|
}
|
|
else
|
|
{
|
|
DebugTools.Assert(speedMod.Equals(1f));
|
|
}
|
|
|
|
if (entity.Comp.Colliding != value)
|
|
{
|
|
entity.Comp.Colliding = value;
|
|
DirtyField(entity.Owner, entity.Comp, nameof(MobCollisionComponent.Colliding));
|
|
}
|
|
|
|
if (!entity.Comp.SpeedModifier.Equals(speedMod))
|
|
{
|
|
entity.Comp.SpeedModifier = speedMod;
|
|
_moveMod.RefreshMovementSpeedModifiers(entity.Owner);
|
|
DirtyField(entity.Owner, entity.Comp, nameof(MobCollisionComponent.SpeedModifier));
|
|
}
|
|
}
|
|
|
|
private void OnCollision(MobCollisionMessage msg, EntitySessionEventArgs args)
|
|
{
|
|
var player = args.SenderSession.AttachedEntity;
|
|
|
|
if (!MobQuery.TryComp(player, out var comp))
|
|
return;
|
|
|
|
var xform = Transform(player.Value);
|
|
|
|
// If not parented directly to a grid then fail it.
|
|
if (xform.ParentUid != xform.GridUid && xform.ParentUid != xform.MapUid)
|
|
return;
|
|
|
|
var direction = msg.Direction;
|
|
|
|
MoveMob((player.Value, comp, xform), direction, msg.SpeedModifier);
|
|
}
|
|
|
|
protected void MoveMob(Entity<MobCollisionComponent, TransformComponent> entity, Vector2 direction, float speedMod)
|
|
{
|
|
// Length too short to do anything.
|
|
var pushing = true;
|
|
|
|
if (direction.LengthSquared() < _minimumPushSquared)
|
|
{
|
|
pushing = false;
|
|
direction = Vector2.Zero;
|
|
speedMod = 1f;
|
|
}
|
|
else if (float.IsNaN(direction.X) || float.IsNaN(direction.Y))
|
|
{
|
|
direction = Vector2.Zero;
|
|
}
|
|
|
|
speedMod = Math.Clamp(speedMod, 0f, 1f);
|
|
|
|
SetColliding(entity, pushing, speedMod);
|
|
|
|
if (direction == entity.Comp1.Direction)
|
|
return;
|
|
|
|
entity.Comp1.Direction = direction;
|
|
DirtyField(entity.Owner, entity.Comp1, nameof(MobCollisionComponent.Direction));
|
|
}
|
|
|
|
protected bool HandleCollisions(Entity<MobCollisionComponent, PhysicsComponent> entity, float frameTime)
|
|
{
|
|
var physics = entity.Comp2;
|
|
|
|
if (physics.ContactCount == 0)
|
|
return false;
|
|
|
|
var ourVelocity = entity.Comp2.LinearVelocity;
|
|
|
|
if (ourVelocity == Vector2.Zero && !CfgManager.GetCVar(CCVars.MovementPushingStatic))
|
|
return false;
|
|
|
|
var xform = Transform(entity.Owner);
|
|
|
|
if (xform.ParentUid != xform.GridUid && xform.ParentUid != xform.MapUid)
|
|
return false;
|
|
|
|
var ev = new AttemptMobCollideEvent();
|
|
|
|
RaiseLocalEvent(entity.Owner, ref ev);
|
|
|
|
if (ev.Cancelled)
|
|
return false;
|
|
|
|
var (worldPos, worldRot) = _xformSystem.GetWorldPositionRotation(xform);
|
|
var ourTransform = new Transform(worldPos, worldRot);
|
|
var contacts = Physics.GetContacts(entity.Owner);
|
|
var direction = Vector2.Zero;
|
|
var contactCount = 0;
|
|
var ourMass = physics.FixturesMass;
|
|
var speedMod = 1f;
|
|
|
|
while (contacts.MoveNext(out var contact))
|
|
{
|
|
if (!contact.IsTouching)
|
|
continue;
|
|
|
|
var ourFixture = contact.OurFixture(entity.Owner);
|
|
|
|
if (ourFixture.Id != entity.Comp1.FixtureId)
|
|
continue;
|
|
|
|
var other = contact.OtherEnt(entity.Owner);
|
|
|
|
if (!MobQuery.TryComp(other, out var otherComp) || !PhysicsQuery.TryComp(other, out var otherPhysics))
|
|
continue;
|
|
|
|
var velocityProduct = Vector2.Dot(ourVelocity, otherPhysics.LinearVelocity);
|
|
|
|
// If we're moving opposite directions for example then ignore (based on cvar).
|
|
if (velocityProduct < _pushingDotProduct)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var targetEv = new AttemptMobTargetCollideEvent();
|
|
RaiseLocalEvent(other, ref targetEv);
|
|
|
|
if (targetEv.Cancelled)
|
|
continue;
|
|
|
|
// TODO: More robust overlap detection.
|
|
var otherTransform = Physics.GetPhysicsTransform(other);
|
|
var diff = ourTransform.Position - otherTransform.Position;
|
|
|
|
if (diff == Vector2.Zero)
|
|
{
|
|
diff = _random.NextVector2(0.01f);
|
|
}
|
|
|
|
// 0.7 for 0.35 + 0.35 for mob bounds (see TODO above).
|
|
// Clamp so we don't get a heap of penetration depth and suddenly lurch other mobs.
|
|
// This is also so we don't have to trigger the speed-cap above.
|
|
// Maybe we just do speedcap and dump this? Though it's less configurable and the cap is just there for cheaters.
|
|
var penDepth = Math.Clamp(0.7f - diff.Length(), 0f, _penCap);
|
|
|
|
// Sum the strengths so we get pushes back the same amount (impulse-wise, ignoring prediction).
|
|
var mobMovement = penDepth * diff.Normalized() * (entity.Comp1.Strength + otherComp.Strength);
|
|
|
|
// Big mob push smaller mob, needs fine-tuning and potentially another co-efficient.
|
|
if (_massDiffCap > 0f)
|
|
{
|
|
var modifier = Math.Clamp(
|
|
otherPhysics.FixturesMass / ourMass,
|
|
1f / _massDiffCap,
|
|
_massDiffCap);
|
|
|
|
mobMovement *= modifier;
|
|
|
|
var speedReduction = 1f - entity.Comp1.MinimumSpeedModifier;
|
|
speedReduction /= _penCap / penDepth;
|
|
var speedModifier = Math.Clamp(
|
|
1f - speedReduction * modifier,
|
|
entity.Comp1.MinimumSpeedModifier, 1f);
|
|
|
|
speedMod = MathF.Min(speedModifier, 1f);
|
|
}
|
|
|
|
// Need the push strength proportional to penetration depth.
|
|
direction += mobMovement;
|
|
contactCount++;
|
|
}
|
|
|
|
if (direction == Vector2.Zero)
|
|
{
|
|
return contactCount > 0;
|
|
}
|
|
|
|
direction *= frameTime;
|
|
RaiseCollisionEvent(entity.Owner, direction, speedMod);
|
|
return true;
|
|
}
|
|
|
|
protected abstract void RaiseCollisionEvent(EntityUid uid, Vector2 direction, float speedmodifier);
|
|
|
|
/// <summary>
|
|
/// Raised from client -> server indicating mob push direction OR server -> server for NPC mob pushes.
|
|
/// </summary>
|
|
[Serializable, NetSerializable]
|
|
protected sealed class MobCollisionMessage : EntityEventArgs
|
|
{
|
|
public Vector2 Direction;
|
|
public float SpeedModifier;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raised on the entity itself when attempting to handle mob collisions.
|
|
/// </summary>
|
|
[ByRefEvent]
|
|
public record struct AttemptMobCollideEvent
|
|
{
|
|
public bool Cancelled;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Raised on the other entity when attempting mob collisions.
|
|
/// </summary>
|
|
[ByRefEvent]
|
|
public record struct AttemptMobTargetCollideEvent
|
|
{
|
|
public bool Cancelled;
|
|
}
|