The Rat King [Antag]

Content.Server/Disease/Components/DiseaseCarrierComponent.cs

@@ -1,5 +1,6 @@
 using System.Linq;
 using Content.Shared.Disease;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.List;
 
 namespace Content.Server.Disease.Components
 {
@@ -32,5 +33,12 @@ public sealed class DiseaseCarrierComponent : Component
         /// <summary>
         [ViewVariables(VVAccess.ReadWrite)]
         public List<DiseasePrototype> AllDiseases => PastDiseases.Concat(Diseases).ToList();
+        /// <summary>
+        /// A list of diseases which the entity does not
+        /// exhibit direct symptoms from. They still transmit
+        /// these diseases, just without symptoms.
+        /// </summary>
+        [DataField("silentDiseases", customTypeSerializer: typeof(PrototypeIdListSerializer<DiseasePrototype>))]
+        public List<string>? SilentDiseases;
     }
 }

Content.Server/Disease/DiseaseSystem.cs

@@ -97,6 +97,13 @@ public override void Update(float frameTime)
                 {
                     var disease = carrierComp.Diseases[i];
 
+                    //if the disease is on the silent disease list, don't do effects
+                    var doEffects = true;
+                    if (carrierComp.SilentDiseases != null)
+                        foreach (var id in carrierComp.SilentDiseases)
+                            if (id == disease.ID)
+                                doEffects = false;
+
                     var args = new DiseaseEffectArgs(carrierComp.Owner, disease, EntityManager);
                     disease.Accumulator += frameTime;
                     if (disease.Accumulator >= disease.TickTime)
@@ -107,10 +114,13 @@ public override void Update(float frameTime)
                             if (cure.Cure(args))
                                 CureDisease(carrierComp, disease);
                         }
-                        foreach (var effect in disease.Effects)
+                        if (doEffects)
                         {
-                            if (_random.Prob(effect.Probability))
-                                effect.Effect(args);
+                            foreach (var effect in disease.Effects)
+                            {
+                                if (_random.Prob(effect.Probability))
+                                    effect.Effect(args);
+                            }
                         }
                     }
                 }
@@ -383,6 +393,14 @@ public void TryInfect(DiseaseCarrierComponent carrier, DiseasePrototype? disease
                 TryAddDisease(carrier.Owner, disease, carrier);
         }
 
+        public void TryInfect(DiseaseCarrierComponent carrier, string? disease, float chance = 0.7f, bool forced = false)
+        {
+            if (disease == null || !_prototypeManager.TryIndex<DiseasePrototype>(disease, out var d))
+                return;
+
+            TryInfect(carrier, d, chance, forced);
+        }
+
         /// <summary>
         /// Plays a sneeze/cough popup if applicable
         /// and then tries to infect anyone in range

Content.Server/RatKing/RatKingComponent.cs

@@ -0,0 +1,27 @@
+using Content.Shared.Actions.ActionTypes;
+
+namespace Content.Server.RatKing
+{
+    [RegisterComponent]
+    public sealed class RatKingComponent: Component
+    {
+        [DataField("actionRaiseArmy", required: true)]
+        public InstantAction ActionRaiseArmy = new();
+
+        [DataField("hungerPerArmyUse", required: true)]
+        public float HungerPerArmyUse = 25f;
+
+        public string ArmyMobSpawnId = "MobRatServant";
+
+        [DataField("actionDomain", required: true)]
+        public InstantAction ActionDomain = new();
+
+        [DataField("hungerPerDomainUse", required: true)]
+        public float HungerPerDomainUse = 50f;
+
+        public string DomainDiseaseId = "Plague";
+
+        public float DomainRange = 3f;
+
+    }
+};

Content.Server/RatKing/RatKingSystem.cs

@@ -0,0 +1,87 @@
+using Content.Server.Actions;
+using Content.Server.Disease;
+using Content.Server.Disease.Components;
+using Content.Server.Nutrition.Components;
+using Content.Server.Popups;
+using Content.Shared.Actions;
+using Robust.Shared.Player;
+
+namespace Content.Server.RatKing
+{
+    public sealed class RatKingSystem : EntitySystem
+    {
+        [Dependency] private readonly PopupSystem _popup = default!;
+        [Dependency] private readonly ActionsSystem _action = default!;
+        [Dependency] private readonly DiseaseSystem _disease = default!;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            SubscribeLocalEvent<RatKingComponent, ComponentStartup>(OnStartup);
+
+            SubscribeLocalEvent<RatKingComponent, RatKingRaiseArmyActionEvent>(OnRaiseArmy);
+            SubscribeLocalEvent<RatKingComponent, RatKingDomainActionEvent>(OnDomain);
+        }
+
+        private void OnStartup(EntityUid uid, RatKingComponent component, ComponentStartup args)
+        {
+            _action.AddAction(uid, component.ActionRaiseArmy, null);
+            _action.AddAction(uid, component.ActionDomain, null);
+        }
+
+        /// <summary>
+        /// Summons an allied rat servant at the King, costing a small amount of hunger
+        /// </summary>
+        private void OnRaiseArmy(EntityUid uid, RatKingComponent component, RatKingRaiseArmyActionEvent args)
+        {
+			if (args.Handled)
+				return;
+
+            if (!TryComp<HungerComponent>(uid, out var hunger))
+                return;
+
+            //make sure the hunger doesn't go into the negatives
+            if (hunger.CurrentHunger < component.HungerPerArmyUse)
+            {
+                _popup.PopupEntity(Loc.GetString("rat-king-too-hungry"), uid, Filter.Entities(uid));
+                return;
+            }
+            args.Handled = true;
+            hunger.CurrentHunger -= component.HungerPerArmyUse;
+            Spawn(component.ArmyMobSpawnId, Transform(uid).Coordinates); //spawn the little mouse boi
+        }
+
+        /// <summary>
+        /// Gets all of the nearby disease-carrying entities in a radius
+        /// and gives them the specified disease. It has a hunger cost as well
+        /// </summary>
+        private void OnDomain(EntityUid uid, RatKingComponent component, RatKingDomainActionEvent args)
+        {
+			if (args.Handled)
+				return;
+
+            if (!TryComp<HungerComponent>(uid, out var hunger))
+                return;
+
+            //make sure the hunger doesn't go into the negatives
+            if (hunger.CurrentHunger < component.HungerPerDomainUse)
+            {
+                _popup.PopupEntity(Loc.GetString("rat-king-too-hungry"), uid, Filter.Entities(uid));
+                return;
+            }
+            args.Handled = true;
+            hunger.CurrentHunger -= component.HungerPerDomainUse;
+
+            var xformQuery = EntityQuery<TransformComponent, DiseaseCarrierComponent>(false); //get every disease-carrying mob
+            var bodyXform = Transform(uid);
+            _popup.PopupEntity(Loc.GetString("rat-king-domain-popup"), uid, Filter.Pvs(uid));
+
+            foreach (var query in xformQuery) //go through all of them, filtering only those in range that are not the king itself
+                if (bodyXform.Coordinates.InRange(EntityManager, query.Item1.Coordinates, component.DomainRange) && query.Item1.Owner != uid)
+                    _disease.TryInfect(query.Item2, component.DomainDiseaseId); //infect them with w/e disease
+        }
+    }
+
+    public sealed class RatKingRaiseArmyActionEvent : InstantActionEvent { };
+    public sealed class RatKingDomainActionEvent : InstantActionEvent { };
+};

Content.Server/StationEvents/Events/MouseMigration.cs

@@ -0,0 +1,50 @@
+using System.Linq;
+using Content.Server.StationEvents.Components;
+using Robust.Shared.Random;
+
+namespace Content.Server.StationEvents.Events;
+
+public sealed class MouseMigration : StationEvent
+{
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly IEntityManager _entityManager = default!;
+
+    public static List<string> SpawnedPrototypeChoices = new List<string>() //we double up for that ez fake probability
+        {"MobMouse", "MobMouse1", "MobMouse2", "MobRatServant"};
+
+    public override string Name => "MouseMigration";
+
+    public override string? StartAnnouncement =>
+        Loc.GetString("station-event-mouse-migration-announcement");
+
+    public override int EarliestStart => 30;
+
+    public override int MinimumPlayers => 35; //this just ensures that it doesn't spawn on lowpop maps. 
+
+    public override float Weight => WeightVeryLow;
+
+    public override int? MaxOccurrences => 1;
+
+    protected override float StartAfter => 30f;
+
+    protected override float EndAfter => 60;
+
+    public override void Startup()
+    {
+        base.Startup();
+
+        var spawnLocations = _entityManager.EntityQuery<VentCritterSpawnLocationComponent, TransformComponent>().ToList();
+        _random.Shuffle(spawnLocations);
+
+        var spawnAmount = _random.Next(7, 15); // A small colony of critters.
+
+        for (int i = 0; i < spawnAmount && i < spawnLocations.Count - 1; i++)
+        {
+            var spawnChoice = _random.Pick(SpawnedPrototypeChoices);
+            if (_random.Prob(0.01f) || i == 0) //small chance for multiple, but always at least 1
+                spawnChoice = "MobRatKing";
+
+            _entityManager.SpawnEntity(spawnChoice, spawnLocations[i].Item2.Coordinates);
+        }
+    }
+}

Resources/Locale/en-US/animals/rat-king/rat-king.ftl

@@ -0,0 +1,8 @@
+rat-king-raise-army-name = Raise Army
+rat-king-raise-army-description = Spend some hunger to summon an allied rat to help defend you.
+
+rat-king-domain-name = Rat King's Domain
+rat-king-domain-description = Spend some hunger to infect those around you with the plague.
+rat-king-domain-popup = A cloud of plague is released into the air!
+
+rat-king-too-hungry = You are too hungry to use this ability!

Resources/Locale/en-US/station-events/events/mouse-migration.ftl

@@ -0,0 +1 @@
+station-event-mouse-migration-announcement = We have detected an oncoming migration of rodents to the station. Please stay out of maintenance tunnels and try and avoid excessive contact.

Resources/Prototypes/Diseases/infectious.yml

@@ -168,6 +168,31 @@
     - !type:DiseaseReagentCure
       reagent: DemonsBlood
 
+- type: disease
+  id: Plague
+  name: plague
+  cureResist: 0.1
+  effects:
+    - !type:DiseaseVomit
+      probability: 0.005
+    - !type:DiseasePopUp
+      probability: 0.025
+    - !type:DiseaseSnough
+      probability: 0.025
+      snoughMessage: disease-cough
+      snoughSound:
+        collection: Coughs
+    - !type:DiseaseHealthChange
+      probability: 0.05
+      damage:
+        types:
+          Poison: 2
+  cures:
+    - !type:DiseaseBedrestCure
+      maxLength: 120
+    - !type:DiseaseJustWaitCure
+      maxLength: 240
+
 - type: disease
   id: OwOnavirus
   name: OwOnavirus

Resources/Prototypes/Entities/Clothing/Head/misc.yml

@@ -112,6 +112,19 @@
   - type: Clothing
     sprite: Clothing/Head/Misc/cone.rsi
 
+- type: entity
+  parent: ClothingHeadBase
+  id: ClothingHeadHatFancyCrown
+  name: fancy crown
+  description: It smells like dead rat.
+  components:
+  - type: Sprite
+    sprite: Clothing/Head/Misc/fancycrown.rsi
+  - type: Clothing
+    sprite: Clothing/Head/Misc/fancycrown.rsi
+  - type: MobPrice
+    price: 3000
+
 - type: entity
   parent: ClothingHeadBase
   id: ClothingHeadHatCatEars