Ляжания

Content.Client/Input/ContentContexts.cs

@@ -81,6 +81,7 @@ public static void SetupContexts(IInputContextContainer contexts)
             human.AddFunction(ContentKeyFunctions.Arcade1);
             human.AddFunction(ContentKeyFunctions.Arcade2);
             human.AddFunction(ContentKeyFunctions.Arcade3);
+            human.AddFunction(ContentKeyFunctions.LieDownStandUp);
 
             // actions should be common (for ghosts, mobs, etc)
             common.AddFunction(ContentKeyFunctions.OpenActionsMenu);

Content.Client/Options/UI/Tabs/KeyRebindTab.xaml.cs

@@ -181,6 +181,7 @@ void AddCheckBox(string checkBoxName, bool currentState, Action<BaseButton.Butto
             AddButton(ContentKeyFunctions.Drop);
             AddButton(ContentKeyFunctions.ExamineEntity);
             AddButton(ContentKeyFunctions.SwapHands);
+            AddButton(ContentKeyFunctions.LieDownStandUp);
             AddButton(ContentKeyFunctions.MoveStoredItem);
             AddButton(ContentKeyFunctions.RotateStoredItem);
             AddButton(ContentKeyFunctions.SaveItemLocation);

Content.Shared/Input/ContentKeyFunctions.cs

@@ -56,6 +56,7 @@ public static class ContentKeyFunctions
         public static readonly BoundKeyFunction ZoomOut = "ZoomOut";
         public static readonly BoundKeyFunction ZoomIn = "ZoomIn";
         public static readonly BoundKeyFunction ResetZoom = "ResetZoom";
+        public static readonly BoundKeyFunction LieDownStandUp = "LieDownStandUp";
 
         public static readonly BoundKeyFunction ArcadeUp = "ArcadeUp";
         public static readonly BoundKeyFunction ArcadeDown = "ArcadeDown";

Content.Shared/LieDown/LyingDownComponent.cs

@@ -0,0 +1,25 @@
+using Content.Shared.Actions;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
+
+namespace Content.Shared.LieDown;
+
+/// <summary>
+///     Makes the target to lie down.
+/// </summary>
+[Access(typeof(SharedLieDownSystem))]
+[RegisterComponent, NetworkedComponent()]
+public sealed partial class LyingDownComponent : Component
+{
+    /// <summary>
+    ///     The action to lie down or stand up.
+    /// </summary>
+    [DataField("make-to-stand-up-action", customTypeSerializer: typeof(PrototypeIdSerializer<EntityPrototype>))]
+    public string? MakeToStandUpAction = "action-name-make-standup";
+}
+
+[Serializable, NetSerializable]
+public sealed class ChangeStandingStateEvent : EntityEventArgs {}

Content.Shared/LieDown/SharedLieDownSystem.cs

@@ -0,0 +1,167 @@
+using Content.Shared.Actions;
+using Content.Shared.Examine;
+using Content.Shared.IdentityManagement;
+using Content.Shared.Input;
+using Content.Shared.Interaction;
+using Content.Shared.Movement.Systems;
+using Content.Shared.Standing;
+using Content.Shared.Verbs;
+using Robust.Shared.Input.Binding;
+using Robust.Shared.IoC;
+using Robust.Shared.Player;
+
+namespace Content.Shared.LieDown
+{
+    public class SharedLieDownSystem : EntitySystem
+    {
+        [Dependency] private readonly SharedActionsSystem _actions = default!;
+        [Dependency] private readonly MovementSpeedModifierSystem _movement = default!;
+        [Dependency] private readonly StandingStateSystem _standing = default!;
+
+        public override void Initialize()
+        {
+            SubscribeLocalEvent<LyingDownComponent, InteractHandEvent>(OnInteractHand);
+            SubscribeLocalEvent<LyingDownComponent, GetVerbsEvent<AlternativeVerb>>(AddStandUpVerb);
+            SubscribeLocalEvent<LyingDownComponent, ExaminedEvent>(OnExamined);
+            SubscribeLocalEvent<LyingDownComponent, RefreshMovementSpeedModifiersEvent>(OnRefresh);
+
+            SubscribeLocalEvent<LyingDownComponent, ComponentStartup>(OnComponentStartup);
+            SubscribeLocalEvent<LyingDownComponent, ComponentShutdown>(OnComponentShutdown);
+
+            // Bind keybinds to lie down action
+            SubscribeNetworkEvent<ChangeStandingStateEvent>(OnChangeAction);
+            CommandBinds.Builder
+                .Bind(ContentKeyFunctions.LieDownStandUp, InputCmdHandler.FromDelegate(ChangeLyingState))
+                .Register<SharedLieDownSystem>();
+        }
+
+        private void OnComponentShutdown(EntityUid uid, LyingDownComponent component, ComponentShutdown args)
+        {
+            SwitchActions(uid);
+            _movement.RefreshMovementSpeedModifiers(uid);
+        }
+
+        private void OnComponentStartup(EntityUid uid, LyingDownComponent component, ComponentStartup args)
+        {
+            SwitchActions(uid);
+            _movement.RefreshMovementSpeedModifiers(uid);
+        }
+
+        /// <summary>
+        ///     Send an update event when player pressed keybind.
+        /// </summary>
+        private void ChangeLyingState(ICommonSession? session)
+        {
+            RaiseNetworkEvent(new ChangeStandingStateEvent());
+        }
+
+        /// <summary>
+        ///     Process player event, that pressed keybind.
+        /// </summary>
+        private void OnChangeAction(ChangeStandingStateEvent msg, EntitySessionEventArgs args)
+        {
+            if (!args.SenderSession.AttachedEntity.HasValue)
+                return;
+
+            var uid = args.SenderSession.AttachedEntity.Value;
+            if (_standing.IsDown(uid))
+            {
+                TryStandUp(uid);
+            }
+            else
+            {
+                TryLieDown(uid);
+            }
+        }
+
+        /// <summary>
+        ///     Update movement speed according to the lying state.
+        /// </summary>
+        private void OnRefresh(EntityUid uid, LyingDownComponent component, RefreshMovementSpeedModifiersEvent args)
+        {
+            if (_standing.IsDown(uid))
+            {
+                args.ModifySpeed(0.4f, 0.4f);
+            }
+            else
+            {
+                args.ModifySpeed(1f, 1f);
+            }
+        }
+
+        /// <summary>
+        ///     Change available to player actions.
+        /// </summary>
+        private void SwitchActions(EntityUid uid)
+        {
+            var standingComponent = Comp<StandingStateComponent>(uid);
+            _actions.AddAction(uid, ref standingComponent.ToggleActionEntity, standingComponent.ToggleAction);
+        }
+
+        /// <summary>
+        ///     When interacting with a lying down person, add ability to make him stand up.
+        /// </summary>
+        private void OnInteractHand(EntityUid uid, LyingDownComponent component, InteractHandEvent args)
+        {
+            TryStandUp(args.Target);
+        }
+
+        /// <summary>
+        ///     Add a verb to player menu to make him stand up.
+        /// </summary>
+        private void AddStandUpVerb(EntityUid uid, LyingDownComponent component, GetVerbsEvent<AlternativeVerb> args)
+        {
+            if (!args.CanInteract || !args.CanAccess)
+                return;
+
+            if (args.Target == args.User)
+                return;
+
+            if (!_standing.IsDown(uid))
+                return;
+
+            AlternativeVerb verb = new()
+            {
+                Act = () =>
+                {
+                    TryStandUp(uid);
+                },
+                Text = Loc.GetString(component.MakeToStandUpAction!),
+                Priority = 2
+            };
+
+            args.Verbs.Add(verb);
+        }
+
+        /// <summary>
+        ///     If somebody examined a lying down person, add description.
+        /// </summary>
+        private void OnExamined(EntityUid uid, LyingDownComponent component, ExaminedEvent args)
+        {
+            if (args.IsInDetailsRange && _standing.IsDown(uid))
+            {
+                args.PushMarkup(Loc.GetString("lying-down-examined", ("target", Identity.Entity(uid, EntityManager))));
+            }
+        }
+
+        public void TryStandUp(EntityUid uid)
+        {
+            if (!_standing.IsDown(uid) || !_standing.Stand(uid))
+                return;
+
+            Logger.Debug("{uid} tried to stand up", uid);
+
+            RemCompDeferred<LyingDownComponent>(uid);
+        }
+
+        public void TryLieDown(EntityUid uid)
+        {
+            if (_standing.IsDown(uid) || !_standing.Down(uid, false, false))
+                return;
+
+            Logger.Debug("{uid} tried to lie down", uid);
+
+            EnsureComp<LyingDownComponent>(uid);
+        }
+    }
+}

Content.Shared/Standing/StandingStateComponent.cs

@@ -1,9 +1,12 @@
+using Content.Shared.Actions;
 using Robust.Shared.Audio;
 using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
 
 namespace Content.Shared.Standing
 {
-    [RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+    [RegisterComponent, NetworkedComponent(), AutoGenerateComponentState]
     [Access(typeof(StandingStateSystem))]
     public sealed partial class StandingStateComponent : Component
     {
@@ -20,5 +23,18 @@ public sealed partial class StandingStateComponent : Component
         /// </summary>
         [DataField, AutoNetworkedField]
         public List<string> ChangedFixtures = new();
+
+        [DataField]
+        public EntProtoId ToggleAction = "ActionToggleLieDown";
+
+        [DataField, AutoNetworkedField]
+        public EntityUid? ToggleActionEntity;
+
+
+        [DataField("IsDown"), AutoNetworkedField]
+        public bool IsDown = false;
     }
+
+    public sealed partial class LieDownActionEvent : InstantActionEvent {}
+    public sealed partial class StandUpActionEvent : InstantActionEvent {}
 }

Content.Shared/Standing/StandingStateSystem.cs

@@ -1,4 +1,7 @@
+using Content.Shared.Actions;
 using Content.Shared.Hands.Components;
+using Content.Shared.LieDown;
+using Content.Shared.Movement.Systems;
 using Content.Shared.Physics;
 using Content.Shared.Rotation;
 using Robust.Shared.Audio;
@@ -13,18 +16,54 @@ public sealed class StandingStateSystem : EntitySystem
         [Dependency] private readonly SharedAppearanceSystem _appearance = default!;
         [Dependency] private readonly SharedAudioSystem _audio = default!;
         [Dependency] private readonly SharedPhysicsSystem _physics = default!;
+        [Dependency] private readonly SharedActionsSystem _actions = default!;
+        [Dependency] private readonly SharedLieDownSystem _lieDown = default!;
 
         // 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()
+        {
+            SubscribeLocalEvent<StandingStateComponent, ComponentStartup>(OnComponentInit);
+
+            SubscribeLocalEvent<StandingStateComponent, LieDownActionEvent>(OnLieDownAction);
+            SubscribeLocalEvent<StandingStateComponent, StandUpActionEvent>(OnStandUpAction);
+        }
         public bool IsDown(EntityUid uid, StandingStateComponent? standingState = null)
         {
             if (!Resolve(uid, ref standingState, false))
                 return false;
 
+            if (HasComp<LyingDownComponent>(uid))
+                RemComp<LyingDownComponent>(uid);
+
             return !standingState.Standing;
         }
 
+        /// <summary>
+        ///     When component is added to player, add an action.
+        /// </summary>
+        private void OnComponentInit(EntityUid uid, StandingStateComponent component, ComponentStartup args)
+        {
+            _actions.AddAction(uid, ref component.ToggleActionEntity, component.ToggleAction);
+        }
+
+        /// <summary>
+        ///     Event that being risen on lie down attempt.
+        /// </summary>
+        private void OnLieDownAction(EntityUid uid, StandingStateComponent component, LieDownActionEvent args)
+        {
+            _lieDown.TryLieDown(uid);
+        }
+
+        /// <summary>
+        ///     Event that being risen on stand up attempt.
+        /// </summary>
+        private void OnStandUpAction(EntityUid uid, StandingStateComponent component, StandUpActionEvent args)
+        {
+            _lieDown.TryStandUp(uid);
+        }
+
         public bool Down(EntityUid uid, bool playSound = true, bool dropHeldItems = true,
             StandingStateComponent? standingState = null,
             AppearanceComponent? appearance = null,

Resources/Locale/en-US/actions/actions/lie-down.ftl

@@ -0,0 +1,5 @@
+action-name-liedown = Lie down
+action-name-standup = Stand up
+action-name-make-standup = Make to stand up
+lying-down-examined = [color=lightblue]{CAPITALIZE(SUBJECT($target))} {CONJUGATE-BE($target)} is lying down.[/color]
+ui-options-function-lie-down-stand-up = Lie on the ground

Resources/Locale/ru-RU/actions/actions/lie-down.ftl

@@ -0,0 +1,5 @@
+action-name-liedown = Lie down
+action-name-standup = Stand up
+action-name-make-standup = Make to stand up
+lying-down-examined = [color=lightblue]{CAPITALIZE(SUBJECT($target))} {CONJUGATE-BE($target)} is lying down.[/color]
+ui-options-function-lie-down-stand-up = Lie on the ground

Resources/Prototypes/Entities/Mobs/Species/base.yml

@@ -174,6 +174,22 @@
   - type: SleepEmitSound
   - type: SSDIndicator
   - type: StandingState
+    lie-down-action:
+      type: instantAction
+      id: LieDown
+      icon: Interface/Actions/lie-down-state.png
+      name: action-name-liedown
+      itemIconStyle: NoItem
+      event: !type:LieDownActionEvent
+      checkCanInteract: true
+    stand-up-action:
+      type: instantAction
+      id: StandUp
+      icon: Interface/Actions/stand-up-state.png
+      name: action-name-standup
+      itemIconStyle: NoItem
+      event: !type:StandUpActionEvent
+      checkCanInteract: true
   - type: Fingerprint
   - type: Dna
   - type: MindContainer
@@ -216,7 +232,7 @@
   - type: MobPrice
     price: 1500 # Kidnapping a living person and selling them for cred is a good move.
     deathPenalty: 0.01 # However they really ought to be living and intact, otherwise they're worth 100x less.
-  - type: CanEscapeInventory # Carrying system from nyanotrasen.  
+  - type: CanEscapeInventory # Carrying system from nyanotrasen.
   - type: Tag
     tags:
     - CanPilot

Resources/keybinds.yml

@@ -1,4 +1,4 @@
-version: 1 # Not used right now, whatever.
+version: 1 # Not used right now, whatever.
 binds:
 - function: UIClick
   type: State
@@ -120,6 +120,10 @@ binds:
   type: State
   mod1: Shift
   key: Num9
+- function: LieDownStandUp
+  type: State
+  key: Z
+  mod1: Shift
 - function: FocusOOCWindow
   type: State
   key: LBracket