Fishy swarmers: Carp content and Space Dragon!

Content.Client/MobState/DamageStateVisualizerSystem.cs

@@ -0,0 +1,57 @@
+using Content.Shared.MobState;
+using Robust.Client.GameObjects;
+using DrawDepth = Content.Shared.DrawDepth.DrawDepth;
+
+namespace Content.Client.MobState;
+
+public sealed class DamageStateVisualizerSystem : VisualizerSystem<DamageStateVisualsComponent>
+{
+    protected override void OnAppearanceChange(EntityUid uid, DamageStateVisualsComponent component, ref AppearanceChangeEvent args)
+    {
+        var sprite = args.Sprite;
+
+        if (sprite == null || !args.Component.TryGetData(DamageStateVisuals.State, out DamageState data))
+        {
+            return;
+        }
+
+        if (!component.States.TryGetValue(data, out var layers))
+        {
+            return;
+        }
+
+        if (component.Rotate)
+        {
+            sprite.NoRotation = data switch
+            {
+                DamageState.Critical => false,
+                DamageState.Dead => false,
+                _ => true
+            };
+        }
+
+        // Brain no worky rn so this was just easier.
+        foreach (var layer in sprite.AllLayers)
+        {
+            layer.Visible = false;
+        }
+
+        foreach (var (key, state) in layers)
+        {
+            sprite.LayerSetVisible(key, true);
+            sprite.LayerSetState(key, state);
+        }
+
+        // So they don't draw over mobs anymore
+        if (data == DamageState.Dead && sprite.DrawDepth > (int) DrawDepth.Items)
+        {
+            component.OriginalDrawDepth = sprite.DrawDepth;
+            sprite.DrawDepth = (int) DrawDepth.Items;
+        }
+        else if (component.OriginalDrawDepth != null)
+        {
+            sprite.DrawDepth = component.OriginalDrawDepth.Value;
+            component. OriginalDrawDepth = null;
+        }
+    }
+}

Content.Client/MobState/DamageStateVisualsComponent.cs

@@ -0,0 +1,22 @@
+using Content.Shared.MobState;
+
+namespace Content.Client.MobState;
+
+[RegisterComponent]
+public sealed class DamageStateVisualsComponent : Component
+{
+    public int? OriginalDrawDepth;
+
+    [DataField("states")] public Dictionary<DamageState, Dictionary<string, string>> States = new();
+
+    /// <summary>
+    /// Should noRot be turned off when crit / dead.
+    /// </summary>
+    [DataField("rotate")] public bool Rotate;
+}
+
+public enum DamageStateVisualLayers : byte
+{
+    Base,
+    BaseUnshaded,
+}

Content.Server/Dragon/DragonComponent.cs

@@ -0,0 +1,80 @@
+using Content.Shared.Actions.ActionTypes;
+using Robust.Shared.Containers;
+using System.Threading;
+using Content.Shared.Actions;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.Sound;
+using Content.Shared.Storage;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
+
+namespace Content.Server.Dragon
+{
+    [RegisterComponent]
+    public sealed class DragonComponent : Component
+    {
+        /// <summary>
+        /// The chemical ID injected upon devouring
+        /// </summary>
+        [DataField("devourChemical", customTypeSerializer: typeof(PrototypeIdSerializer<ReagentPrototype>))]
+        public string DevourChem = "Ichor";
+
+        /// <summary>
+        /// The amount of ichor injected per devour
+        /// </summary>
+        [DataField("devourHealRate")]
+        public float DevourHealRate = 15f;
+
+        [DataField("devourActionId", customTypeSerializer: typeof(PrototypeIdSerializer<EntityTargetActionPrototype>))]
+        public string DevourActionId = "DragonDevour";
+
+        [DataField("devourAction")]
+        public EntityTargetAction? DevourAction;
+
+        [DataField("spawnActionId", customTypeSerializer: typeof(PrototypeIdSerializer<InstantActionPrototype>))]
+        public string SpawnActionId = "DragonSpawn";
+
+        [DataField("spawnAction")]
+        public InstantAction? SpawnAction;
+
+        /// <summary>
+        /// The amount of time it takes to devour something
+        /// <remarks>
+        /// NOTE: original intended design was to increase this proportionally with damage thresholds, but those proved quite difficult to get consistently. right now it devours the structure at a fixed timer.
+        /// </remarks>
+        /// </summary>
+        [DataField("devourTime")]
+        public float DevourTime = 15f;
+
+        [DataField("spawnCount")] public int SpawnsLeft = 2;
+
+        [DataField("maxSpawnCount")] public int MaxSpawns = 2;
+
+        [DataField("spawnProto", customTypeSerializer: typeof(PrototypeIdSerializer<EntityPrototype>))]
+        public string? SpawnPrototype = "MobCarpDragon";
+
+        [ViewVariables(VVAccess.ReadWrite), DataField("soundDeath")]
+        public SoundSpecifier? SoundDeath = new SoundPathSpecifier("/Audio/Animals/space_dragon_roar.ogg");
+
+        [ViewVariables(VVAccess.ReadWrite), DataField("soundDevour")]
+        public SoundSpecifier? SoundDevour = new SoundPathSpecifier("/Audio/Effects/demon_consume.ogg");
+
+        [ViewVariables(VVAccess.ReadWrite), DataField("soundStructureDevour")]
+        public SoundSpecifier? SoundStructureDevour = new SoundPathSpecifier("/Audio/Machines/airlock_creaking.ogg");
+
+        [ViewVariables(VVAccess.ReadWrite), DataField("soundRoar")]
+        public SoundSpecifier? SoundRoar =
+            new SoundPathSpecifier("/Audio/Animals/space_dragon_roar.ogg");
+
+        public CancellationTokenSource? CancelToken;
+
+        /// <summary>
+        /// Where the entities go when dragon devours them, empties when the dragon is butchered.
+        /// </summary>
+        public Container DragonStomach = default!;
+    }
+
+    public sealed class DragonDevourActionEvent : EntityTargetActionEvent {}
+
+    public sealed class DragonSpawnActionEvent : InstantActionEvent {}
+}