Add invulnerable damage flag, godmode and damage flag commands (#1949)

* Add invulnerable damage flag and commands

* Add serialization for damage flags

* Add godmode command

Content.Shared/GameObjects/Components/Damage/DamageFlag.cs

@@ -0,0 +1,13 @@
+using System;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.GameObjects.Components.Damage
+{
+    [Flags]
+    [Serializable, NetSerializable]
+    public enum DamageFlag
+    {
+        None = 0,
+        Invulnerable = 1 << 0
+    }
+}

Content.Shared/GameObjects/Components/Damage/DamageableComponent.cs

@@ -27,6 +27,8 @@ namespace Content.Shared.GameObjects.Components.Damage
 
         private DamageState _currentDamageState;
 
+        private DamageFlag _flags;
+
         public event Action<HealthChangedEventArgs>? HealthChangedEvent;
 
         /// <summary>
@@ -79,6 +81,8 @@ namespace Content.Shared.GameObjects.Components.Damage
                 {
                     EnterState(value);
                 }
+
+                Dirty();
             }
         }
 
@@ -88,6 +92,36 @@ namespace Content.Shared.GameObjects.Components.Damage
 
         public IReadOnlyDictionary<DamageType, int> DamageTypes => Damage.DamageTypes;
 
+        public DamageFlag Flags
+        {
+            get => _flags;
+            private set
+            {
+                if (_flags == value)
+                {
+                    return;
+                }
+
+                _flags = value;
+                Dirty();
+            }
+        }
+
+        public void AddFlag(DamageFlag flag)
+        {
+            Flags |= flag;
+        }
+
+        public bool HasFlag(DamageFlag flag)
+        {
+            return Flags.HasFlag(flag);
+        }
+
+        public void RemoveFlag(DamageFlag flag)
+        {
+            Flags &= ~flag;
+        }
+
         public override void ExposeData(ObjectSerializer serializer)
         {
             base.ExposeData(serializer);
@@ -104,6 +138,35 @@ namespace Content.Shared.GameObjects.Components.Damage
                 t => DeadThreshold = t == -1 ? (int?) null : t,
                 () => DeadThreshold ?? -1);
 
+            serializer.DataReadWriteFunction(
+                "flags",
+                new List<DamageFlag>(),
+                flags =>
+                {
+                    var result = DamageFlag.None;
+
+                    foreach (var flag in flags)
+                    {
+                        result |= flag;
+                    }
+
+                    Flags = result;
+                },
+                () =>
+                {
+                    var writeFlags = new List<DamageFlag>();
+
+                    foreach (var flag in (DamageFlag[]) Enum.GetValues(typeof(DamageFlag)))
+                    {
+                        if ((Flags & flag) == flag)
+                        {
+                            writeFlags.Add(flag);
+                        }
+                    }
+
+                    return writeFlags;
+                });
+
             if (serializer.Reading)
             {
                 // Doesn't write to file, TODO?
@@ -151,6 +214,11 @@ namespace Content.Shared.GameObjects.Components.Damage
             IEntity? source = null,
             HealthChangeParams? extraParams = null)
         {
+            if (amount > 0 && HasFlag(DamageFlag.Invulnerable))
+            {
+                return false;
+            }
+
             if (Damage.SupportsDamageType(type))
             {
                 var finalDamage = amount;
@@ -171,6 +239,11 @@ namespace Content.Shared.GameObjects.Components.Damage
             IEntity? source = null,
             HealthChangeParams? extraParams = null)
         {
+            if (amount > 0 && HasFlag(DamageFlag.Invulnerable))
+            {
+                return false;
+            }
+
             if (Damage.SupportsDamageClass(@class))
             {
                 var types = @class.ToTypes();
@@ -250,6 +323,11 @@ namespace Content.Shared.GameObjects.Components.Damage
         public bool SetDamage(DamageType type, int newValue, IEntity? source = null,
             HealthChangeParams? extraParams = null)
         {
+            if (newValue >= TotalDamage && HasFlag(DamageFlag.Invulnerable))
+            {
+                return false;
+            }
+
             if (Damage.SupportsDamageType(type))
             {
                 Damage.SetDamageValue(type, newValue);

Content.Shared/GameObjects/Components/Damage/IDamageableComponent.cs

@@ -45,6 +45,30 @@ namespace Content.Shared.GameObjects.Components.Damage
         /// </summary>
         IReadOnlyDictionary<DamageType, int> DamageTypes { get; }
 
+        /// <summary>
+        ///     The damage flags on this component.
+        /// </summary>
+        DamageFlag Flags { get; }
+
+        /// <summary>
+        ///     Adds a flag to this component.
+        /// </summary>
+        /// <param name="flag">The flag to add.</param>
+        void AddFlag(DamageFlag flag);
+
+        /// <summary>
+        ///     Checks whether or not this component has a specific flag.
+        /// </summary>
+        /// <param name="flag">The flag to check for.</param>
+        /// <returns>True if it has the flag, false otherwise.</returns>
+        bool HasFlag(DamageFlag flag);
+
+        /// <summary>
+        ///     Removes a flag from this component.
+        /// </summary>
+        /// <param name="flag">The flag to remove.</param>
+        void RemoveFlag(DamageFlag flag);
+
         /// <summary>
         ///     Gets the amount of damage of a type.
         /// </summary>