[Fix] Waddle / Походка Клоуна

Content.Client/_White/Animations/WaddleAnimationSystem.cs

@@ -0,0 +1,100 @@
+using System.Numerics;
+using Content.Client.Buckle;
+using Content.Client.Gravity;
+using Content.Shared._White.Animations;
+using Content.Shared.Movement.Components;
+using Content.Shared.Standing;
+using Robust.Client.Animations;
+using Robust.Client.GameObjects;
+using Robust.Shared.Animations;
+
+namespace Content.Client._White.Animations;
+
+public sealed class WaddleAnimationSystem : SharedWaddleAnimationSystem
+{
+    [Dependency] private readonly AnimationPlayerSystem _animation = default!;
+    [Dependency] private readonly StandingStateSystem _standingState = default!;
+    [Dependency] private readonly GravitySystem _gravity = default!;
+    [Dependency] private readonly BuckleSystem _buckle = default!;
+
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<WaddleAnimationComponent, AnimationCompletedEvent>(OnAnimationCompleted);
+
+        SubscribeAllEvent<StartedWaddlingEvent>(ev => PlayAnimation(GetEntity(ev.User)));
+        SubscribeAllEvent<StoppedWaddlingEvent>(ev => StopAnimation(GetEntity(ev.User)));
+    }
+
+    protected override void PlayAnimation(EntityUid uid)
+    {
+        if (!Timing.IsFirstTimePredicted
+            || !TryComp<WaddleAnimationComponent>(uid, out var component)
+            || !TryComp<InputMoverComponent>(uid, out var mover)
+            || _animation.HasRunningAnimation(uid, component.KeyName)
+            || _standingState.IsDown(uid)
+            || _gravity.IsWeightless(uid)
+            || _buckle.IsBuckled(uid))
+            return;
+
+        var tumbleIntensity = component.LastStep ? 360 - component.TumbleIntensity : component.TumbleIntensity;
+        var len = mover.Sprinting ? component.AnimationLength * component.RunAnimationLengthMultiplier : component.AnimationLength;
+
+        component.LastStep = !component.LastStep;
+        component.IsCurrentlyWaddling = true;
+
+        var animation = new Animation()
+        {
+            Length = TimeSpan.FromSeconds(len),
+            AnimationTracks =
+            {
+                new AnimationTrackComponentProperty()
+                {
+                    ComponentType = typeof(SpriteComponent),
+                    Property = nameof(SpriteComponent.Rotation),
+                    InterpolationMode = AnimationInterpolationMode.Linear,
+                    KeyFrames =
+                    {
+                        new AnimationTrackProperty.KeyFrame(Angle.FromDegrees(0), 0),
+                        new AnimationTrackProperty.KeyFrame(Angle.FromDegrees(tumbleIntensity), len/3),
+                        new AnimationTrackProperty.KeyFrame(Angle.FromDegrees(0), len/3),
+                    }
+                },
+                new AnimationTrackComponentProperty()
+                {
+                    ComponentType = typeof(SpriteComponent),
+                    Property = nameof(SpriteComponent.Offset),
+                    InterpolationMode = AnimationInterpolationMode.Linear,
+                    KeyFrames =
+                    {
+                        new AnimationTrackProperty.KeyFrame(new Vector2(), 0),
+                        new AnimationTrackProperty.KeyFrame(component.HopIntensity, len/3),
+                        new AnimationTrackProperty.KeyFrame(new Vector2(), len/3),
+                    }
+                }
+            }
+        };
+
+        _animation.Play(uid, animation, component.KeyName);
+    }
+
+    protected override void StopAnimation(EntityUid uid)
+    {
+        if (!TryComp<WaddleAnimationComponent>(uid, out var component)
+            || !TryComp<SpriteComponent>(uid, out var sprite))
+            return;
+
+        _animation.Stop(uid, component.KeyName);
+
+        sprite.Offset = new Vector2();
+        sprite.Rotation = Angle.FromDegrees(0);
+        component.IsCurrentlyWaddling = false;
+    }
+
+    private void OnAnimationCompleted(EntityUid uid, WaddleAnimationComponent component, AnimationCompletedEvent args)
+    {
+        if (args.Key != component.KeyName)
+            return;
+
+        PlayAnimation(uid);
+    }
+}

Content.Server/_White/Animations/WaddleAnimationSystem.cs

@@ -0,0 +1,17 @@
+using Content.Shared._White.Animations;
+using Content.Shared.Movement.Components;
+
+namespace Content.Server._White.Animations;
+
+public sealed class WaddleAnimationSystem : SharedWaddleAnimationSystem
+{
+    protected override void PlayAnimation(EntityUid user)
+    {
+        RaiseNetworkEvent(new StartedWaddlingEvent(GetNetEntity(user)));
+    }
+
+    protected override void StopAnimation(EntityUid user)
+    {
+        RaiseNetworkEvent(new StoppedWaddlingEvent(GetNetEntity(user)));
+    }
+}

Content.Shared/Movement/Components/WaddleAnimationComponent.cs

@@ -1,26 +1,29 @@
 using System.Numerics;
+using Robust.Shared.Serialization;
 
 namespace Content.Shared.Movement.Components;
 
+// WD EDIT START
 /// <summary>
 /// Declares that an entity has started to waddle like a duck/clown.
 /// </summary>
-/// <param name="Entity">The newly be-waddled.</param>
-[ByRefEvent]
-public record struct StartedWaddlingEvent(EntityUid Entity)
+/// <param name="user">The newly be-waddled.</param>
+[Serializable, NetSerializable]
+public sealed class StartedWaddlingEvent(NetEntity user) : EntityEventArgs
 {
-    public EntityUid Entity = Entity;
+    public NetEntity User = user;
 }
 
 /// <summary>
 /// Declares that an entity has stopped waddling like a duck/clown.
 /// </summary>
-/// <param name="Entity">The former waddle-er.</param>
-[ByRefEvent]
-public record struct StoppedWaddlingEvent(EntityUid Entity)
+/// <param name="user">The former waddle-er.</param>
+[Serializable, NetSerializable]
+public sealed class StoppedWaddlingEvent(NetEntity user) : EntityEventArgs
 {
-    public EntityUid Entity = Entity;
+    public NetEntity User = user;
 }
+// WD EDIT END
 
 /// <summary>
 /// Defines something as having a waddle animation when it moves.

Content.Shared/_White/Animations/SharedWaddleAnimationSystem.cs

@@ -0,0 +1,51 @@
+using Content.Shared.Buckle;
+using Content.Shared.Gravity;
+using Content.Shared.Movement.Components;
+using Content.Shared.Movement.Events;
+using Content.Shared.Standing;
+using Robust.Shared.Timing;
+
+namespace Content.Shared._White.Animations;
+
+public abstract class SharedWaddleAnimationSystem : EntitySystem
+{
+    [Dependency] protected readonly IGameTiming Timing = default!;
+    [Dependency] private readonly StandingStateSystem _standingState = default!;
+    [Dependency] private readonly SharedGravitySystem _gravity = default!;
+    [Dependency] private readonly SharedBuckleSystem _buckle = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<WaddleAnimationComponent, MoveInputEvent>(OnMovementInput);
+    }
+
+    private void OnMovementInput(EntityUid uid, WaddleAnimationComponent component, MoveInputEvent args)
+    {
+        if (!Timing.IsFirstTimePredicted
+            || _standingState.IsDown(uid)
+            || _gravity.IsWeightless(uid)
+            || _buckle.IsBuckled(uid))
+            return;
+
+        if (!args.HasDirectionalMovement && component.IsCurrentlyWaddling)
+        {
+            component.IsCurrentlyWaddling = false;
+            StopAnimation(uid);
+
+            return;
+        }
+
+        if (component.IsCurrentlyWaddling || !args.HasDirectionalMovement)
+            return;
+
+        component.IsCurrentlyWaddling = true;
+
+        PlayAnimation(uid);
+    }
+
+    protected abstract void PlayAnimation(EntityUid user);
+
+    protected abstract void StopAnimation(EntityUid user);
+}

Content.Client/Clothing/Systems/WaddleClothingSystem.cs → Content.Shared/_White/Clothing/EntitySystems/WaddleClothingSystem.cs

@@ -2,7 +2,7 @@
 using Content.Shared.Movement.Components;
 using Content.Shared.Inventory.Events;
 
-namespace Content.Client.Clothing.Systems;
+namespace Content.Shared._White.Clothing.EntitySystems;
 
 public sealed class WaddleClothingSystem : EntitySystem
 {