Diseases (#7057)

* Disease system first pass

* Renamed HealthChange

* First working version of diseases (wtf???)

* Fix the cursed yaml initialization

* Pop-Up effect

* Generic status effect

* Create copy of prototype

* CureDiseaseEffect

* Disease resistance

* Spaceacillin

* Nerf spaceacillin now that we know it works

* Sneezing, Coughing, Snoughing

* Fix queuing, prevent future issues

* Disease protection

* Disease outbreak event

* Disease Reagent Cure

* Chem cause disease effect

* Disease artifacts

* Try infect when interacting with diseased

* Diseases don't have to be infectious

* Talking without a mask does a snough

* Temperature cure

* Bedrest

* DiseaseAdjustReagent

* Tweak how disease statuses work to be a bit less shit

* A few more diseases

* Natural immunity (can't get the same disease twice)

* Polished up some diseases, touched up spaceacillin production

* Rebalanced transmission

* Edit a few diseases, make disease cures support a minimum value

* Nitrile gloves, more disease protection sources

* Health scanner shows diseased status

* Clean up disease system

* Traitor item

* Mouth swabs

* Disease diagnoser machine

* Support for clean samples

* Vaccines + fixes

* Pass on disease resistant clothes

* More work on non-infectious diseases & vaccines

* Handle dead bodies

* Added the relatively CBT visualizer

* Pass over diseases and their populators

* Comment stuff

* Readability cleanup

* Add printing sound to diagnoser, fix printing bug

* vaccinator sound, seal up some classes

* Make disease protection equip detection not shit (thanks whoever wrote addaccentcomponent)

* Mirror review

* More review stuff

* More mirror review stuff

* Refactor snoughing

* Redid report creator

* Fix snough messages, new vaccinator sound

* Mirror review naming

* Woops, forgot the artifact

* Add recipes and fills

* Rebalance space cold and robovirus

* Give lizarb disease interaction stuff

* Tweak some stuff and move things around

* Add diseases to mice (since animal vectors are interesting and can be used to make vaccines)

* Remove unused reagent

Content.Shared/Chemistry/Reagent/ReagentEffectCondition.cs

@@ -1,7 +1,5 @@
 using System.Text.Json.Serialization;
 using JetBrains.Annotations;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Serialization.Manager.Attributes;
 
 namespace Content.Shared.Chemistry.Reagent
 {

Content.Shared/Disease/DiseaseCure.cs

@@ -0,0 +1,24 @@
+using JetBrains.Annotations;
+
+namespace Content.Shared.Disease
+{
+    [ImplicitDataDefinitionForInheritors]
+    [MeansImplicitUse]
+    public abstract class DiseaseCure
+    {
+        /// <summary>
+        /// This returns true if the disease should be cured
+        /// and false otherwise
+        /// </summary>
+        public abstract bool Cure(DiseaseEffectArgs args);
+
+        /// <summary>
+        /// This is used by the disease diangoser machine
+        /// to generate reports to tell people all of a disease's
+        /// special cures using in-game methods.
+        /// So it should return a localization string describing
+        /// the cure
+        /// </summary>
+        public abstract string CureText();
+    }
+}

Content.Shared/Disease/DiseaseEffect.cs

@@ -0,0 +1,29 @@
+using JetBrains.Annotations;
+
+namespace Content.Shared.Disease
+{
+    [ImplicitDataDefinitionForInheritors]
+    [MeansImplicitUse]
+    public abstract class DiseaseEffect
+    {
+        /// <summary>
+        ///     What's the chance, from 0 to 1, that this effect will occur?
+        /// </summary>
+        [DataField("probability")]
+        public float Probability = 1.0f;
+        /// <summary>
+        /// What effect the disease will have.
+        /// </summary>
+        public abstract void Effect(DiseaseEffectArgs args);
+    }
+    /// <summary>
+    /// What you have to work with in any disease effect/cure.
+    /// Includes an entity manager because it is out of scope
+    /// otherwise.
+    /// </summary>
+    public readonly record struct DiseaseEffectArgs(
+        EntityUid DiseasedEntity,
+        DiseasePrototype Disease,
+        IEntityManager EntityManager
+    );
+}

Content.Shared/Disease/DiseaseMachineVisuals.cs

@@ -0,0 +1,16 @@
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Disease
+{
+    [Serializable, NetSerializable]
+    /// <summary>
+    /// Stores bools for if the machine is on
+    /// and if it's currently running.
+    /// Used for the visualizer
+    /// </summary>
+    public enum DiseaseMachineVisuals : byte
+    {
+        IsOn,
+        IsRunning
+    }
+}

Content.Shared/Disease/DiseasePrototype.cs

@@ -0,0 +1,68 @@
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
+/// <summary>
+/// Diseases encompass everything from viruses to cancers to heart disease.
+/// It's not just a virology thing.
+/// </summary>
+namespace Content.Shared.Disease
+{
+    [Prototype("disease")]
+    [DataDefinition]
+    public sealed class DiseasePrototype : IPrototype, IInheritingPrototype
+    {
+        [ViewVariables]
+        [DataField("id", required: true)]
+        public string ID { get; } = default!;
+
+        [DataField("name")]
+        public string Name { get; } = string.Empty;
+
+        [DataField("parent", customTypeSerializer: typeof(PrototypeIdSerializer<DiseasePrototype>))]
+        public string? Parent { get; private set; }
+
+        [NeverPushInheritance]
+        [DataField("abstract")]
+        public bool Abstract { get; private set; }
+
+        /// <summary>
+        /// Controls how often a disease ticks.
+        /// </summary>
+        public float TickTime = 1f;
+
+        /// <summary>
+        /// Since disease isn't mapped to metabolism or anything,
+        /// it needs something to control its tickrate
+        /// </summary>
+        public float Accumulator = 0f;
+        /// <summary>
+        /// List of effects the disease has that will
+        /// run every second (by default anyway)
+        /// </summary>
+        [DataField("effects", serverOnly: true)]
+        public readonly List<DiseaseEffect> Effects = new(0);
+        /// <summary>
+        /// List of SPECIFIC CURES the disease has that will
+        /// be checked every second.
+        /// Stuff like spaceacillin operates outside this.
+        /// </summary>
+        [DataField("cures", serverOnly: true)]
+        public readonly List<DiseaseCure> Cures = new(0);
+        /// <summary>
+        /// This flatly reduces the probabilty disease medicine
+        /// has to cure it every tick. Although, since spaceacillin is
+        /// used as a reference and it has 0.15 chance, this is
+        /// a base 33% reduction in cure chance
+        /// </summary>
+        [DataField("cureResist", serverOnly: true)]
+        public float CureResist = 0.05f;
+        /// <summary>
+        /// Whether the disease can infect other people.
+        /// Since this isn't just a virology thing, this
+        /// primary determines what sort of disease it is.
+        /// This also affects things like the vaccine machine.
+        /// You can't print a cancer vaccine
+        /// </summary>
+        [DataField("infectious", serverOnly: true)]
+        public bool Infectious = true;
+    }
+}

Content.Shared/Disease/DiseasedComponent.cs

@@ -0,0 +1,12 @@
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Disease.Components
+{
+    [NetworkedComponent]
+    [RegisterComponent]
+    /// This is added to anyone with at least 1 disease
+    /// and helps cull event subscriptions and entity queries
+    /// when they are not relevant.
+    public sealed class DiseasedComponent : Component
+    {}
+}