Add space ferrets as a midround event

Content.Client/DeltaV/SpaceFerret/CanBackflipSystem.cs

@@ -0,0 +1,55 @@
+using Content.Shared.DeltaV.SpaceFerret;
+using Content.Shared.DeltaV.SpaceFerret.Events;
+using Robust.Client.Animations;
+using Robust.Client.Audio;
+using Robust.Client.GameObjects;
+using Robust.Shared.Animations;
+using Robust.Shared.Audio;
+using Robust.Shared.Player;
+
+namespace Content.Client.DeltaV.SpaceFerret;
+
+public sealed class CanBackflipSystem : EntitySystem
+{
+    [Dependency] private readonly AnimationPlayerSystem _animation = default!;
+    [Dependency] private readonly AudioSystem _audio = default!;
+
+    public const string BackflipKey = "backflip";
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeNetworkEvent<DoABackFlipEvent>(OnBackflipEvent);
+    }
+
+    public void OnBackflipEvent(DoABackFlipEvent args)
+    {
+        if (!TryGetEntity(args.Actioner, out var uid) || !TryComp<CanBackflipComponent>(uid, out var comp))
+        {
+            return;
+        }
+
+        _animation.Play(uid.Value, new Animation
+        {
+            Length = TimeSpan.FromSeconds(0.66),
+            AnimationTracks =
+            {
+                new AnimationTrackComponentProperty()
+                {
+                    ComponentType = typeof(SpriteComponent),
+                    Property = nameof(SpriteComponent.Rotation),
+                    InterpolationMode = AnimationInterpolationMode.Linear,
+                    KeyFrames =
+                    {
+                        new AnimationTrackProperty.KeyFrame(Angle.FromDegrees(0), 0f),
+                        new AnimationTrackProperty.KeyFrame(Angle.FromDegrees(180), 0.33f),
+                        new AnimationTrackProperty.KeyFrame(Angle.FromDegrees(360), 0.33f),
+                    }
+                }
+            }
+        }, BackflipKey);
+
+        _audio.PlayPvs(comp.ClappaSfx, uid.Value);
+    }
+}

Content.Client/DeltaV/SpaceFerret/CanHibernateSystem.cs

@@ -0,0 +1,29 @@
+using Content.Client.DamageState;
+using Content.Shared.DeltaV.SpaceFerret;
+using Robust.Client.GameObjects;
+
+namespace Content.Client.DeltaV.SpaceFerret;
+
+public sealed class CanHibernateSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeNetworkEvent<EntityHasHibernated>(OnHibernateEvent);
+    }
+
+    public void OnHibernateEvent(EntityHasHibernated args)
+    {
+        if (!TryGetEntity(args.Hibernator, out var uid) | !TryComp<CanHibernateComponent>(uid, out var comp))
+            return;
+
+        if (!TryComp<SpriteComponent>(uid, out var sprite))
+            return;
+
+        if (!sprite.TryGetLayer((int) DamageStateVisualLayers.Base, out var layer))
+            return;
+
+        layer.SetState(comp!.SpriteStateId);
+    }
+}

Content.Server/DeltaV/SpaceFerret/Components/SpaceFerretRoleComponent.cs

@@ -0,0 +1,7 @@
+using Content.Server.DeltaV.SpaceFerret.Systems;
+using Content.Shared.Roles;
+
+namespace Content.Server.DeltaV.SpaceFerret.Components;
+
+[RegisterComponent, Access(typeof(SpaceFerretSystem)), ExclusiveAntagonist]
+public sealed partial class SpaceFerretRoleComponent : AntagonistRoleComponent;

Content.Server/DeltaV/SpaceFerret/Systems/CanBackflipSystem.cs

@@ -0,0 +1,30 @@
+using Content.Server.Actions;
+using Content.Shared.DeltaV.SpaceFerret;
+using Content.Shared.DeltaV.SpaceFerret.Events;
+
+namespace Content.Server.DeltaV.SpaceFerret.Systems;
+
+public sealed class CanBackflipSystem : EntitySystem
+{
+    [Dependency] private readonly ActionsSystem _actions = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<CanBackflipComponent, MapInitEvent>(OnInit);
+        SubscribeLocalEvent<CanBackflipComponent, BackflipActionEvent>(OnBackflipAction);
+    }
+
+    private void OnInit(EntityUid uid, CanBackflipComponent component, MapInitEvent args)
+    {
+        _actions.AddAction(uid, ref component.BackflipActionEntity, component.BackflipAction, uid);
+    }
+
+    public void OnBackflipAction(EntityUid uid, CanBackflipComponent comp, BackflipActionEvent args)
+    {
+        RaiseNetworkEvent(new DoABackFlipEvent(GetNetEntity(uid)));
+
+        args.Handled = true;
+    }
+}

Content.Server/DeltaV/SpaceFerret/Systems/CanHibernateSystem.cs

@@ -0,0 +1,86 @@
+using Content.Server.Actions;
+using Content.Server.Atmos.Piping.Unary.Components;
+using Content.Server.GameTicking;
+using Content.Server.Ghost.Roles.Components;
+using Content.Server.Popups;
+using Content.Shared.DeltaV.SpaceFerret;
+using Content.Shared.Interaction.Components;
+using Content.Shared.Mind;
+using Content.Shared.NPC;
+using Content.Shared.Popups;
+using Robust.Server.Audio;
+using Robust.Shared.Audio;
+
+namespace Content.Server.DeltaV.SpaceFerret.Systems;
+
+public sealed class CanHibernateSystem : EntitySystem
+{
+    [Dependency] private readonly ActionsSystem _actions = default!;
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+    [Dependency] private readonly PopupSystem _popup = default!;
+    [Dependency] private readonly SharedMindSystem _mind = default!;
+    [Dependency] private readonly GameTicker _ticker = default!;
+    [Dependency] private readonly AudioSystem _audio = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<CanHibernateComponent, MapInitEvent>(OnInit);
+        SubscribeLocalEvent<CanHibernateComponent, EepyActionEvent>(OnEepyAction);
+    }
+
+    private void OnInit(EntityUid uid, CanHibernateComponent component, MapInitEvent args)
+    {
+        _actions.AddAction(uid, ref component.EepyActionEntity, component.EepyAction, uid);
+    }
+
+    public void OnEepyAction(EntityUid uid, CanHibernateComponent comp, EepyActionEvent args)
+    {
+        // If you require food before hibernating, assert that this condition has been fulfilled.
+        if (_mind.TryGetObjectiveComp<ConsumeNutrientsConditionComponent>(uid, out var nutrientsCondition) && nutrientsCondition.NutrientsConsumed / nutrientsCondition.NutrientsRequired < 1.0)
+        {
+            _popup.PopupEntity(Loc.GetString(comp.NotEnoughNutrientsMessage), uid, PopupType.SmallCaution);
+
+            return;
+        }
+
+        // Assert that you're near a hibernation point (scrubbers)
+        var scrubbers = _lookup.GetEntitiesInRange<GasVentScrubberComponent>(Transform(uid).Coordinates, 2f);
+        if (scrubbers.Count <= 0)
+        {
+            _popup.PopupEntity(Loc.GetString(comp.TooFarFromHibernationSpot), uid, PopupType.SmallCaution);
+
+            return;
+        }
+
+        if (_mind.TryGetObjectiveComp<HibernateConditionComponent>(uid, out var hibernateCondition))
+        {
+            _audio.PlayPvs(hibernateCondition.SuccessSfx, uid);
+            _popup.PopupEntity(Loc.GetString(hibernateCondition.SuccessMessage), uid, PopupType.Large);
+            hibernateCondition.Hibernated = true;
+        }
+
+        // Kick player out
+        var mind = _mind.GetMind(uid);
+        if (mind != null)
+        {
+            _ticker.OnGhostAttempt(mind.Value, false);
+        }
+
+        // End ghost-role
+        AddComp<BlockMovementComponent>(uid);
+        RemComp<ActiveNPCComponent>(uid);
+        RemComp<GhostTakeoverAvailableComponent>(uid);
+
+        // Notify
+        RaiseNetworkEvent(new EntityHasHibernated(GetNetEntity(uid)));
+
+        args.Handled = true;
+    }
+}
+
+public struct EntityHibernateAttemptSuccessEvent(EntityUid entity)
+{
+    public EntityUid Entity = entity;
+}

Content.Server/DeltaV/SpaceFerret/Systems/ConsumeNutrientsObjective.cs

@@ -0,0 +1,19 @@
+using Content.Shared.DeltaV.SpaceFerret;
+using Content.Shared.Objectives.Components;
+
+namespace Content.Server.DeltaV.SpaceFerret.Systems;
+
+public sealed class ConsumeNutrientsObjectiveSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<ConsumeNutrientsConditionComponent, ObjectiveGetProgressEvent>(OnConsumeNutrientsGetProgress);
+    }
+
+    private static void OnConsumeNutrientsGetProgress(EntityUid uid, ConsumeNutrientsConditionComponent comp, ref ObjectiveGetProgressEvent args)
+    {
+        args.Progress = comp.NutrientsConsumed / comp.NutrientsRequired;
+    }
+}

Content.Server/DeltaV/SpaceFerret/Systems/HibernateObjectiveSystem.cs

@@ -0,0 +1,19 @@
+using Content.Shared.DeltaV.SpaceFerret;
+using Content.Shared.Objectives.Components;
+
+namespace Content.Server.DeltaV.SpaceFerret.Systems;
+
+public sealed class HibernateObjectiveSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<HibernateConditionComponent, ObjectiveGetProgressEvent>(OnHibernateGetProgress);
+    }
+
+    private static void OnHibernateGetProgress(EntityUid uid, HibernateConditionComponent comp, ref ObjectiveGetProgressEvent args)
+    {
+        args.Progress = comp.Hibernated ? 1.0f : 0.0f;
+    }
+}

Content.Server/DeltaV/SpaceFerret/Systems/SpaceFerretSystem.cs

@@ -0,0 +1,62 @@
+using Content.Server.Chat.Managers;
+using Content.Server.DeltaV.SpaceFerret.Components;
+using Content.Server.GenericAntag;
+using Content.Server.Roles;
+using Content.Shared.DeltaV.Interaction.Events;
+using Content.Shared.DeltaV.Nutrition;
+using Content.Shared.DeltaV.SpaceFerret;
+using Content.Shared.DeltaV.SpaceFerret.Events;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Mind;
+using Content.Shared.Nutrition;
+
+namespace Content.Server.DeltaV.SpaceFerret.Systems;
+
+public sealed class SpaceFerretSystem : EntitySystem
+{
+    [Dependency] private readonly RoleSystem _role = default!;
+    [Dependency] private readonly IChatManager _chatMan = default!;
+    [Dependency] private readonly SharedMindSystem _mind = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<SpaceFerretComponent, GenericAntagCreatedEvent>(OnInit);
+        SubscribeLocalEvent<SpaceFerretComponent, InteractionAttemptFailed>(OnInteractFailed);
+        SubscribeLocalEvent<SpaceFerretComponent, HungerModifiedEvent>(OnHungerModified);
+    }
+
+    private void OnInit(EntityUid uid, SpaceFerretComponent component, GenericAntagCreatedEvent args)
+    {
+        var mind = args.Mind;
+
+        if (mind.Session == null)
+            return;
+
+        var session = mind.Session;
+        _role.MindAddRole(args.MindId, new RoleBriefingComponent
+        {
+            Briefing = Loc.GetString(component.RoleBriefing)
+        }, mind);
+        _role.MindAddRole(args.MindId, new SpaceFerretRoleComponent()
+        {
+            PrototypeId = component.AntagProtoId
+        }, mind);
+        _role.MindPlaySound(args.MindId, component.RoleIntroSfx, mind);
+        _chatMan.DispatchServerMessage(session, Loc.GetString(component.RoleGreeting));
+    }
+
+    public void OnInteractFailed(EntityUid uid, SpaceFerretComponent _, InteractionAttemptFailed args)
+    {
+        RaiseLocalEvent(uid, new BackflipActionEvent());
+    }
+
+    private void OnHungerModified(EntityUid uid, SpaceFerretComponent comp, HungerModifiedEvent args)
+    {
+        if (_mind.TryGetObjectiveComp<ConsumeNutrientsConditionComponent>(uid, out var nutrientsCondition) && args.Amount > 0)
+        {
+            nutrientsCondition.NutrientsConsumed += args.Amount;
+        }
+    }
+}

Content.Server/Interaction/InteractionPopupSystem.cs

@@ -1,8 +1,10 @@
 using Content.Server.Interaction.Components;
 using Content.Server.Popups;
 using Content.Shared.Bed.Sleep;
+using Content.Shared.DeltaV.Interaction.Events;
 using Content.Shared.IdentityManagement;
 using Content.Shared.Interaction;
+using Content.Shared.Interaction.Events;
 using Content.Shared.Mobs.Components;
 using Content.Shared.Mobs.Systems;
 using Robust.Shared.Audio;
@@ -96,6 +98,8 @@ private void SharedInteract(
 
             if (component.InteractFailureSpawn != null)
                 Spawn(component.InteractFailureSpawn, _transform.GetMapCoordinates(uid));
+
+            RaiseLocalEvent(target, new InteractionAttemptFailed(target)); // DeltaV - Allow systems to be aware of failed interactions. Probably should also be one for successful interactions, but I didn't need it
         }
 
         if (component.MessagePerceivedByOthers != null)

Content.Shared/DeltaV/Interaction/Events/InteractionAttemptFailedEvent.cs

@@ -0,0 +1,6 @@
+namespace Content.Shared.DeltaV.Interaction.Events;
+
+public sealed class InteractionAttemptFailed(EntityUid target)
+{
+    public EntityUid Target = target;
+}

Content.Shared/DeltaV/Nutrition/Events.cs

@@ -0,0 +1,6 @@
+namespace Content.Shared.DeltaV.Nutrition;
+
+public sealed class HungerModifiedEvent(float amount) : EntityEventArgs
+{
+    public float Amount = amount;
+}

Content.Shared/DeltaV/SpaceFerret/Components/CanBackflipComponent.cs

@@ -0,0 +1,17 @@
+using Robust.Shared.Audio;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.DeltaV.SpaceFerret;
+
+[RegisterComponent]
+public sealed partial class CanBackflipComponent : Component
+{
+    [DataField]
+    public EntProtoId BackflipAction = "ActionBackflip";
+
+    [DataField]
+    public EntityUid? BackflipActionEntity;
+
+    [DataField]
+    public SoundSpecifier ClappaSfx = new SoundPathSpecifier("/Audio/DeltaV/Animals/slugclappa.ogg");
+}

Content.Shared/DeltaV/SpaceFerret/Components/CanHibernateComponent.cs

@@ -0,0 +1,24 @@
+using Content.Shared.Actions;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.DeltaV.SpaceFerret;
+
+[RegisterComponent]
+public sealed partial class CanHibernateComponent : Component
+{
+    [DataField(required: true)]
+    public EntProtoId EepyAction = "ActionEepy";
+
+    [DataField]
+    public EntityUid? EepyActionEntity;
+
+    [DataField(required: true)]
+    public LocId NotEnoughNutrientsMessage = "spaceferret-not-enough-nutrients";
+
+    [DataField(required: true)]
+    public LocId TooFarFromHibernationSpot = "spaceferret-out-of-range";
+
+    [DataField(required: true)]
+    public string SpriteStateId = "";
+}