using Content.Client.Rotation;
using Content.Shared.Buckle;
using Content.Shared.Buckle.Components;
+using Content.Shared.Movement.Systems;
using Content.Shared.Rotation;
using Robust.Client.GameObjects;
using Robust.Client.Graphics;
SubscribeLocalEvent<StrapComponent, MoveEvent>(OnStrapMoveEvent);
SubscribeLocalEvent<BuckleComponent, BuckledEvent>(OnBuckledEvent);
SubscribeLocalEvent<BuckleComponent, UnbuckledEvent>(OnUnbuckledEvent);
+ SubscribeLocalEvent<BuckleComponent, AttemptMobCollideEvent>(OnMobCollide);
+ }
+
+ private void OnMobCollide(Entity<BuckleComponent> ent, ref AttemptMobCollideEvent args)
+ {
+ if (ent.Comp.Buckled)
+ {
+ args.Cancelled = true;
+ }
}
private void OnStrapMoveEvent(EntityUid uid, StrapComponent component, ref MoveEvent args)
--- /dev/null
+using System.Numerics;
+using Content.Shared.CCVar;
+using Content.Shared.Movement.Components;
+using Content.Shared.Movement.Systems;
+using Robust.Client.Player;
+using Robust.Shared.Physics.Components;
+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!;
+
+ public override void Update(float frameTime)
+ {
+ if (!CfgManager.GetCVar(CCVars.MovementMobPushing))
+ return;
+
+ if (_timing.IsFirstTimePredicted)
+ {
+ var player = _player.LocalEntity;
+
+ if (MobQuery.TryComp(player, out var comp) && PhysicsQuery.TryComp(player, out var physics))
+ {
+ HandleCollisions((player.Value, comp, physics), frameTime);
+ }
+ }
+
+ base.Update(frameTime);
+ }
+
+ protected override void RaiseCollisionEvent(EntityUid uid, Vector2 direction, float speedMod)
+ {
+ RaisePredictiveEvent(new MobCollisionMessage()
+ {
+ Direction = direction,
+ SpeedModifier = speedMod,
+ });
+ }
+}
private void OnRelayPlayerAttached(Entity<RelayInputMoverComponent> entity, ref LocalPlayerAttachedEvent args)
{
- Physics.UpdateIsPredicted(entity.Owner);
- Physics.UpdateIsPredicted(entity.Comp.RelayEntity);
+ PhysicsSystem.UpdateIsPredicted(entity.Owner);
+ PhysicsSystem.UpdateIsPredicted(entity.Comp.RelayEntity);
if (MoverQuery.TryGetComponent(entity.Comp.RelayEntity, out var inputMover))
SetMoveInput((entity.Comp.RelayEntity, inputMover), MoveButtons.None);
}
private void OnRelayPlayerDetached(Entity<RelayInputMoverComponent> entity, ref LocalPlayerDetachedEvent args)
{
- Physics.UpdateIsPredicted(entity.Owner);
- Physics.UpdateIsPredicted(entity.Comp.RelayEntity);
+ PhysicsSystem.UpdateIsPredicted(entity.Owner);
+ PhysicsSystem.UpdateIsPredicted(entity.Comp.RelayEntity);
if (MoverQuery.TryGetComponent(entity.Comp.RelayEntity, out var inputMover))
SetMoveInput((entity.Comp.RelayEntity, inputMover), MoveButtons.None);
}
(CVars.NetBufferSize.Name, "0"),
(CCVars.InteractionRateLimitCount.Name, "9999999"),
(CCVars.InteractionRateLimitPeriod.Name, "0.1"),
+ (CCVars.MovementMobPushing.Name, "false"),
};
public static async Task SetupCVars(RobustIntegrationTest.IntegrationInstance instance, PoolSettings settings)
--- /dev/null
+using Content.Server.Administration;
+using Content.Shared.Administration;
+using Content.Shared.CCVar;
+using Robust.Shared.Configuration;
+using Robust.Shared.Console;
+
+namespace Content.Server.Movement.Commands;
+
+/// <summary>
+/// Temporary command to enable admins to toggle the mob collision cvar.
+/// </summary>
+[AdminCommand(AdminFlags.VarEdit)]
+public sealed class ToggleMobCollisionCommand : IConsoleCommand
+{
+ [Dependency] private readonly IConfigurationManager _cfgManager = default!;
+
+ public string Command => "toggle_mob_collision";
+ public string Description => "Toggles mob collision";
+ public string Help => Description;
+ public void Execute(IConsoleShell shell, string argStr, string[] args)
+ {
+ _cfgManager.SetCVar(CCVars.MovementMobPushing, !_cfgManager.GetCVar(CCVars.MovementMobPushing));
+ }
+}
--- /dev/null
+using System.Numerics;
+using Content.Shared.CCVar;
+using Content.Shared.Movement.Components;
+using Content.Shared.Movement.Systems;
+using Robust.Shared.Player;
+
+namespace Content.Server.Movement.Systems;
+
+public sealed class MobCollisionSystem : SharedMobCollisionSystem
+{
+ private EntityQuery<ActorComponent> _actorQuery;
+
+ public override void Initialize()
+ {
+ base.Initialize();
+ _actorQuery = GetEntityQuery<ActorComponent>();
+ SubscribeLocalEvent<MobCollisionComponent, MobCollisionMessage>(OnServerMobCollision);
+ }
+
+ private void OnServerMobCollision(Entity<MobCollisionComponent> ent, ref MobCollisionMessage args)
+ {
+ MoveMob((ent.Owner, ent.Comp, Transform(ent.Owner)), args.Direction, args.SpeedModifier);
+ }
+
+ public override void Update(float frameTime)
+ {
+ if (!CfgManager.GetCVar(CCVars.MovementMobPushing))
+ return;
+
+ var query = EntityQueryEnumerator<MobCollisionComponent>();
+
+ while (query.MoveNext(out var uid, out var comp))
+ {
+ if (_actorQuery.HasComp(uid) || !PhysicsQuery.TryComp(uid, out var physics))
+ continue;
+
+ HandleCollisions((uid, comp, physics), frameTime);
+ }
+
+ base.Update(frameTime);
+ }
+
+ protected override void RaiseCollisionEvent(EntityUid uid, Vector2 direction, float speedMod)
+ {
+ RaiseLocalEvent(uid, new MobCollisionMessage()
+ {
+ Direction = direction,
+ SpeedModifier = speedMod,
+ });
+ }
+}
--- /dev/null
+using Robust.Shared.Configuration;
+
+namespace Content.Shared.CCVar;
+
+public sealed partial class CCVars
+{
+ /// <summary>
+ /// Is mob pushing enabled.
+ /// </summary>
+ public static readonly CVarDef<bool> MovementMobPushing =
+ CVarDef.Create("movement.mob_pushing", false, CVar.SERVER | CVar.REPLICATED);
+
+ /// <summary>
+ /// Can we push mobs not moving.
+ /// </summary>
+ public static readonly CVarDef<bool> MovementPushingStatic =
+ CVarDef.Create("movement.pushing_static", true, CVar.SERVER | CVar.REPLICATED);
+
+ /// <summary>
+ /// Dot product for the pushed entity's velocity to a target entity's velocity before it gets moved.
+ /// </summary>
+ public static readonly CVarDef<float> MovementPushingVelocityProduct =
+ CVarDef.Create("movement.pushing_velocity_product", 0.0f, CVar.SERVER | CVar.REPLICATED);
+
+ /// <summary>
+ /// Cap for how much an entity can be pushed per second.
+ /// </summary>
+ public static readonly CVarDef<float> MovementPushingCap =
+ CVarDef.Create("movement.pushing_cap", 100f, CVar.SERVER | CVar.REPLICATED);
+
+ /// <summary>
+ /// Minimum pushing impulse per tick. If the value is below this it rounds to 0.
+ /// This is an optimisation to avoid pushing small values that won't actually move the mobs.
+ /// </summary>
+ public static readonly CVarDef<float> MovementMinimumPush =
+ CVarDef.Create("movement.minimum_push", 0.1f, CVar.SERVER | CVar.REPLICATED);
+
+ // Really this just exists because hot reloading is cooked on rider.
+ /// <summary>
+ /// Penetration depth cap for considering mob collisions.
+ /// </summary>
+ public static readonly CVarDef<float> MovementPenetrationCap =
+ CVarDef.Create("movement.penetration_cap", 0.3f, CVar.SERVER | CVar.REPLICATED);
+
+ /// <summary>
+ /// Based on the mass difference multiplies the push amount by this proportionally.
+ /// </summary>
+ public static readonly CVarDef<float> MovementPushMassCap =
+ CVarDef.Create("movement.push_mass_cap", 1.75f, CVar.SERVER | CVar.REPLICATED);
+}
public static readonly CVarDef<float> StopSpeed =
CVarDef.Create("physics.stop_speed", 0.1f, CVar.ARCHIVE | CVar.REPLICATED | CVar.SERVER);
-
- /// <summary>
- /// Whether mobs can push objects like lockers.
- /// </summary>
- /// <remarks>
- /// Technically client doesn't need to know about it but this may prevent a bug in the distant future so it stays.
- /// </remarks>
- public static readonly CVarDef<bool> MobPushing =
- CVarDef.Create("physics.mob_pushing", false, CVar.REPLICATED | CVar.SERVER);
}
--- /dev/null
+using System.Numerics;
+using Content.Shared.Movement.Systems;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Movement.Components;
+
+/// <summary>
+/// Handles mobs pushing against each other.
+/// </summary>
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState(fieldDeltas: true)]
+public sealed partial class MobCollisionComponent : Component
+{
+ // If you want to tweak the feel of the pushing use SpeedModifier and Strength.
+ // Strength goes both ways and affects how much the other mob is pushed by so controls static pushing a lot.
+ // Speed mod affects your own mob primarily.
+
+ /// <summary>
+ /// Is this mob currently colliding? Used for SpeedModifier.
+ /// </summary>
+ [DataField, AutoNetworkedField]
+ public bool Colliding;
+
+ // TODO: I hate this but also I couldn't quite figure out a way to avoid having to dirty it every tick.
+ // The issue is it's a time target that changes constantly so we can't just use a timespan.
+ // However that doesn't mean it should be modified every tick if we're still colliding.
+
+ /// <summary>
+ /// Buffer time for <see cref="SpeedModifier"/> to keep applying after the entities are no longer colliding.
+ /// Without this you will get jittering unless you are very specific with your values.
+ /// </summary>
+ [DataField, AutoNetworkedField]
+ public float BufferAccumulator = SharedMobCollisionSystem.BufferTime;
+
+ /// <summary>
+ /// The speed modifier for mobs currently pushing.
+ /// By setting this low you can ensure you don't have to set the push-strength too high if you can push static entities.
+ /// </summary>
+ [DataField, AutoNetworkedField]
+ public float SpeedModifier = 1f;
+
+ [DataField, AutoNetworkedField]
+ public float MinimumSpeedModifier = 0.35f;
+
+ /// <summary>
+ /// Strength of the pushback for entities. This is combined between the 2 entities being pushed.
+ /// </summary>
+ [DataField, AutoNetworkedField]
+ public float Strength = 50f;
+
+ // Yes I know, I will deal with it if I ever refactor collision layers due to misuse.
+ // If anything it probably needs some assurance on mobcollisionsystem for it.
+ /// <summary>
+ /// Fixture to listen to for mob collisions.
+ /// </summary>
+ [DataField, AutoNetworkedField]
+ public string FixtureId = "flammable";
+
+ [DataField, AutoNetworkedField]
+ public Vector2 Direction;
+}
--- /dev/null
+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;
+ 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;
+}
private void OnAfterRelayTargetState(Entity<MovementRelayTargetComponent> entity, ref AfterAutoHandleStateEvent args)
{
- Physics.UpdateIsPredicted(entity.Owner);
+ PhysicsSystem.UpdateIsPredicted(entity.Owner);
}
private void OnAfterRelayState(Entity<RelayInputMoverComponent> entity, ref AfterAutoHandleStateEvent args)
{
- Physics.UpdateIsPredicted(entity.Owner);
+ PhysicsSystem.UpdateIsPredicted(entity.Owner);
}
/// <summary>
{
oldTarget.Source = EntityUid.Invalid;
RemComp(component.RelayEntity, oldTarget);
- Physics.UpdateIsPredicted(component.RelayEntity);
+ PhysicsSystem.UpdateIsPredicted(component.RelayEntity);
}
var targetComp = EnsureComp<MovementRelayTargetComponent>(relayEntity);
{
oldRelay.RelayEntity = EntityUid.Invalid;
RemComp(targetComp.Source, oldRelay);
- Physics.UpdateIsPredicted(targetComp.Source);
+ PhysicsSystem.UpdateIsPredicted(targetComp.Source);
}
- Physics.UpdateIsPredicted(uid);
- Physics.UpdateIsPredicted(relayEntity);
+ PhysicsSystem.UpdateIsPredicted(uid);
+ PhysicsSystem.UpdateIsPredicted(relayEntity);
component.RelayEntity = relayEntity;
targetComp.Source = uid;
Dirty(uid, component);
private void OnRelayShutdown(Entity<RelayInputMoverComponent> entity, ref ComponentShutdown args)
{
- Physics.UpdateIsPredicted(entity.Owner);
- Physics.UpdateIsPredicted(entity.Comp.RelayEntity);
+ PhysicsSystem.UpdateIsPredicted(entity.Owner);
+ PhysicsSystem.UpdateIsPredicted(entity.Comp.RelayEntity);
if (TryComp<InputMoverComponent>(entity.Comp.RelayEntity, out var inputMover))
SetMoveInput((entity.Comp.RelayEntity, inputMover), MoveButtons.None);
private void OnTargetRelayShutdown(Entity<MovementRelayTargetComponent> entity, ref ComponentShutdown args)
{
- Physics.UpdateIsPredicted(entity.Owner);
- Physics.UpdateIsPredicted(entity.Comp.Source);
+ PhysicsSystem.UpdateIsPredicted(entity.Owner);
+ PhysicsSystem.UpdateIsPredicted(entity.Comp.Source);
if (Timing.ApplyingState)
return;
[Dependency] private readonly SharedContainerSystem _container = default!;
[Dependency] private readonly SharedMapSystem _mapSystem = default!;
[Dependency] private readonly SharedGravitySystem _gravity = default!;
- [Dependency] protected readonly SharedPhysicsSystem Physics = default!;
[Dependency] private readonly SharedTransformSystem _transform = default!;
[Dependency] private readonly TagSystem _tags = default!;
public override void UpdateAfterSolve(bool prediction, float frameTime)
{
base.UpdateAfterSolve(prediction, frameTime);
+
+ var query = AllEntityQuery<InputMoverComponent, PhysicsComponent>();
+
+ while (query.MoveNext(out var uid, out var _, out var physics))
+ {
+ //PhysicsSystem.SetLinearVelocity(uid, Vector2.Zero, body: physics);
+ }
+
UsedMobMovement.Clear();
}
using System.Numerics;
using Content.Shared.Conveyor;
using Content.Shared.Gravity;
-using Content.Shared.Magic;
using Content.Shared.Movement.Components;
using Content.Shared.Movement.Events;
using Content.Shared.Movement.Systems;
using Content.Shared.Hands.Components;
+using Content.Shared.Movement.Systems;
using Content.Shared.Physics;
using Content.Shared.Rotation;
using Robust.Shared.Audio.Systems;
// If StandingCollisionLayer value is ever changed to more than one layer, the logic needs to be edited.
private const int StandingCollisionLayer = (int) CollisionGroup.MidImpassable;
+ public override void Initialize()
+ {
+ base.Initialize();
+ SubscribeLocalEvent<StandingStateComponent, AttemptMobCollideEvent>(OnMobCollide);
+ SubscribeLocalEvent<StandingStateComponent, AttemptMobTargetCollideEvent>(OnMobTargetCollide);
+ }
+
+ private void OnMobTargetCollide(Entity<StandingStateComponent> ent, ref AttemptMobTargetCollideEvent args)
+ {
+ if (!ent.Comp.Standing)
+ {
+ args.Cancelled = true;
+ }
+ }
+
+ private void OnMobCollide(Entity<StandingStateComponent> ent, ref AttemptMobCollideEvent args)
+ {
+ if (!ent.Comp.Standing)
+ {
+ args.Cancelled = true;
+ }
+ }
+
public bool IsDown(EntityUid uid, StandingStateComponent? standingState = null)
{
if (!Resolve(uid, ref standingState, false))
[gateway]
generator_enabled = false
+[movement]
+mob_pushing = true
+
[physics]
# Makes mapping annoying
grid_splitting = false
[server]
rules_file = "StandardRuleset"
+[movement]
+mob_pushing = true
+
[net]
max_connections = 1024
- type: Sprite
noRot: true
drawdepth: Mobs
+ - type: MobCollision
- type: Physics
bodyType: KinematicController
- type: Fixtures
- type: Damageable
damageContainer: Inorganic
damageModifierSet: Metallic
+ - type: MobCollision
- type: Physics
bodyType: Dynamic
- type: Fixtures
!type:PhysShapeAabb
bounds: "-0.25,-0.25,0.25,0.25"
density: 190
+ hard: false
mask:
- SmallMobMask
layer:
projects / space-station-14.git / commitdiff