Mob collisions

Content.Client/Movement/Systems/MobCollisionSystem.cs

@@ -0,0 +1,66 @@
+using System.Numerics;
+using Content.Shared.Movement.Components;
+using Content.Shared.Movement.Systems;
+using Robust.Client.Player;
+using Robust.Shared.Physics;
+using Robust.Shared.Physics.Components;
+using Robust.Shared.Physics.Systems;
+using Robust.Shared.Timing;
+
+namespace Content.Client.Movement.Systems;
+
+public sealed class MobCollisionSystem : SharedMobCollisionSystem
+{
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly IPlayerManager _player = default!;
+    [Dependency] private readonly SharedPhysicsSystem _physics = default!;
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        if (!_timing.IsFirstTimePredicted)
+            return;
+
+        var player = _player.LocalEntity;
+
+        if (!HasComp<MobCollisionComponent>(player) || !TryComp(player, out PhysicsComponent? physics))
+            return;
+
+        if (physics.ContactCount == 0)
+            return;
+
+        var ourTransform = _physics.GetPhysicsTransform(player.Value);
+        var contacts = _physics.GetContacts(player.Value);
+        var direction = Vector2.Zero;
+
+        while (contacts.MoveNext(out var contact))
+        {
+            if (!contact.IsTouching)
+                continue;
+
+            var other = contact.OtherEnt(player.Value);
+
+            if (!HasComp<MobCollisionComponent>(other))
+                continue;
+
+            // TODO: Get overlap amount
+            var otherTransform = _physics.GetRelativePhysicsTransform(ourTransform, other);
+
+            var diff = otherTransform.Position;
+
+            var penDepth = MathF.Max(0f, 0.7f - diff.LengthSquared());
+
+            // Need the push strength proportional to penetration depth.
+            direction += penDepth * diff.Normalized() * 1f * frameTime;
+        }
+
+        if (direction == Vector2.Zero)
+            return;
+
+        RaisePredictiveEvent(new MobCollisionMessage()
+        {
+            Direction = direction,
+        });
+    }
+}

Content.Server/Movement/Systems/MobCollisionSystem.cs

@@ -0,0 +1,8 @@
+using Content.Shared.Movement.Systems;
+
+namespace Content.Server.Movement.Systems;
+
+public sealed class MobCollisionSystem : SharedMobCollisionSystem
+{
+
+}

Content.Shared/Movement/Components/MobCollisionComponent.cs

@@ -0,0 +1,14 @@
+using Robust.Shared.GameStates;
+using Robust.Shared.Physics.Collision.Shapes;
+
+namespace Content.Shared.Movement.Components;
+
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class MobCollisionComponent : Component
+{
+    /// <summary>
+    /// Shape to give this entity for mob collisions.
+    /// </summary>
+    [DataField, AutoNetworkedField]
+    public IPhysShape Shape = new PhysShapeCircle(radius: 0.35f);
+}

Content.Shared/Movement/Systems/SharedMobCollisionSystem.cs

@@ -0,0 +1,48 @@
+using System.Numerics;
+using Content.Shared.Movement.Components;
+using Content.Shared.Physics;
+using Robust.Shared.Physics.Systems;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Movement.Systems;
+
+public abstract class SharedMobCollisionSystem : EntitySystem
+{
+    [Dependency] private readonly FixtureSystem _fixtures = default!;
+    [Dependency] private readonly SharedPhysicsSystem _physics = default!;
+    [Dependency] private readonly SharedTransformSystem _xformSystem = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeAllEvent<MobCollisionMessage>(OnCollision);
+        SubscribeLocalEvent<MobCollisionComponent, ComponentStartup>(OnCollisionStartup);
+    }
+
+    private void OnCollisionStartup(Entity<MobCollisionComponent> ent, ref ComponentStartup args)
+    {
+        _fixtures.TryCreateFixture(ent.Owner,
+            ent.Comp.Shape,
+            "mob_collision",
+            hard: false,
+            collisionLayer: (int) CollisionGroup.MidImpassable,
+            collisionMask: (int) CollisionGroup.MidImpassable);
+    }
+
+    private void OnCollision(MobCollisionMessage msg, EntitySessionEventArgs args)
+    {
+        var player = args.SenderSession.AttachedEntity;
+
+        if (!HasComp<MobCollisionComponent>(player) || !TryComp(player.Value, out TransformComponent? xform))
+            return;
+
+        // TODO: Validation
+        _xformSystem.SetLocalPosition(player.Value, xform.LocalPosition + msg.Direction);
+    }
+
+    [Serializable, NetSerializable]
+    protected sealed class MobCollisionMessage : EntityEventArgs
+    {
+        public Vector2 Direction;
+    }
+}