Go back to constant electrocution damage based on voltage (#26455)

Makes electrocution damage based on the voltage of the wire and bring down the damage to a sane level. It's no longer primarily based on the power being received.

LV Cable -> 10 damage
MV Cable -> 20 damage
HV Cable -> 30 damage

Having a primarily power-based damage system causes there to be massive fluctuations in damage based on things outside of a regular player's control, like the station power output. This removes a lot of player agency and turns grilles into a risky gamble where they can either do no damage or instantly fry the player due to simply being hooked up to the engine.

While this may be a more accurate simulation in some regards, the reality of the gameplay is that it's often just frustrating, resulting in constant death traps as players brushing against electrified grilles and punching wires take absurd amounts of damage. By making them flat rates, it's possible to actually balance the damage output.

diff --git a/Content.Server/Electrocution/Components/ElectrifiedComponent.cs b/Content.Server/Electrocution/Components/ElectrifiedComponent.cs
index 2f3def6e061faae3df223b450853edd34e241e5e..65a539eb08ea99f122caddfc05df4e32052f063d 100644 (file)
--- a/Content.Server/Electrocution/Components/ElectrifiedComponent.cs
+++ b/Content.Server/Electrocution/Components/ElectrifiedComponent.cs
@@ -41,8 +41,32 @@ public sealed partial class ElectrifiedComponent : Component
     [DataField("lowVoltageNode")]
     public string? LowVoltageNode;
 
+    /// <summary>
+    /// Damage multiplier for HV electrocution
+    /// </summary>
+    [DataField]
+    public float HighVoltageDamageMultiplier = 3f;
+
+    /// <summary>
+    /// Shock time multiplier for HV electrocution
+    /// </summary>
+    [DataField]
+    public float HighVoltageTimeMultiplier = 1.5f;
+
+    /// <summary>
+    /// Damage multiplier for MV electrocution
+    /// </summary>
+    [DataField]
+    public float MediumVoltageDamageMultiplier = 2f;
+
+    /// <summary>
+    /// Shock time multiplier for MV electrocution
+    /// </summary>
+    [DataField]
+    public float MediumVoltageTimeMultiplier = 1.25f;
+
     [DataField("shockDamage")]
-    public int ShockDamage = 20;
+    public float ShockDamage = 7.5f;
 
     /// <summary>
     ///     Shock time, in seconds.

diff --git a/Content.Server/Electrocution/Components/ElectrocutionComponent.cs b/Content.Server/Electrocution/Components/ElectrocutionComponent.cs
index 9da78c9134f6ef3ec39200405c533b36219ff388..7badc852579ec0ef763abc79313e5701bb7ead32 100644 (file)
--- a/Content.Server/Electrocution/Components/ElectrocutionComponent.cs
+++ b/Content.Server/Electrocution/Components/ElectrocutionComponent.cs
@@ -15,10 +15,4 @@ public sealed partial class ElectrocutionComponent : Component
 
     [DataField("timeLeft")]
     public float TimeLeft;
-
-    [DataField("accumDamage")]
-    public float AccumulatedDamage;
-
-    [DataField("baseDamage")]
-    public float BaseDamage = 20f;
 }

diff --git a/Content.Server/Electrocution/ElectrocutionSystem.cs b/Content.Server/Electrocution/ElectrocutionSystem.cs
index d967013f6525a859c45cff16c44a8f89fa0ea5f5..116330628299f448f3babc2ef6dd3b58fc74e909 100644 (file)
--- a/Content.Server/Electrocution/ElectrocutionSystem.cs
+++ b/Content.Server/Electrocution/ElectrocutionSystem.cs
@@ -17,7 +17,6 @@ using Content.Shared.Interaction;
 using Content.Shared.Inventory;
 using Content.Shared.Jittering;
 using Content.Shared.Maps;
-using Content.Shared.Mobs;
 using Content.Shared.Popups;
 using Content.Shared.Speech.EntitySystems;
 using Content.Shared.StatusEffect;
@@ -98,29 +97,18 @@ public sealed class ElectrocutionSystem : SharedElectrocutionSystem
     private void UpdateElectrocutions(float frameTime)
     {
         var query = EntityQueryEnumerator<ElectrocutionComponent, PowerConsumerComponent>();
-        while (query.MoveNext(out var uid, out var electrocution, out var consumer))
+        while (query.MoveNext(out var uid, out var electrocution, out _))
         {
             var timePassed = Math.Min(frameTime, electrocution.TimeLeft);
 
             electrocution.TimeLeft -= timePassed;
-            electrocution.AccumulatedDamage += electrocution.BaseDamage * (consumer.ReceivedPower / consumer.DrawRate) * timePassed;
 
             if (!MathHelper.CloseTo(electrocution.TimeLeft, 0))
                 continue;
 
-            if (EntityManager.EntityExists(electrocution.Electrocuting))
-            {
-                // TODO: damage should be scaled by shock damage multiplier
-                // TODO: better paralyze/jitter timing
-                var damage = new DamageSpecifier(_prototypeManager.Index<DamageTypePrototype>(DamageType), (int) electrocution.AccumulatedDamage);
+            // We tried damage scaling based on power in the past and it really wasn't good.
+            // Various scaling types didn't fix tiders and HV grilles instantly critting players.
 
-                var actual = _damageable.TryChangeDamage(electrocution.Electrocuting, damage, origin: electrocution.Source);
-                if (actual != null)
-                {
-                    _adminLogger.Add(LogType.Electrocution,
-                        $"{ToPrettyString(electrocution.Electrocuting):entity} received {actual.GetTotal():damage} powered electrocution damage from {ToPrettyString(electrocution.Source):source}");
-                }
-            }
             QueueDel(uid);
         }
     }
@@ -198,7 +186,7 @@ public sealed class ElectrocutionSystem : SharedElectrocutionSystem
         if (!_meleeWeapon.GetDamage(args.Used, args.User).Any())
             return;
 
-        DoCommonElectrocution(args.User, uid, component.UnarmedHitShock, component.UnarmedHitStun, false, 1);
+        DoCommonElectrocution(args.User, uid, component.UnarmedHitShock, component.UnarmedHitStun, false);
     }
 
     private void OnElectrifiedInteractUsing(EntityUid uid, ElectrifiedComponent electrified, InteractUsingEvent args)
@@ -213,16 +201,6 @@ public sealed class ElectrocutionSystem : SharedElectrocutionSystem
         TryDoElectrifiedAct(uid, args.User, siemens, electrified);
     }
 
-    private float CalculateElectrifiedDamageScale(float power)
-    {
-        // A logarithm allows a curve of damage that grows quickly, but slows down dramatically past a value. This keeps the damage to a reasonable range.
-        const float DamageShift = 1.67f; // Shifts the curve for an overall higher or lower damage baseline
-        const float CeilingCoefficent = 1.35f; // Adjusts the approach to maximum damage, higher = Higher top damage
-        const float LogGrowth = 0.00001f; // Adjusts the growth speed of the curve
-
-        return DamageShift + MathF.Log(power * LogGrowth) * CeilingCoefficent;
-    }
-
     public bool TryDoElectrifiedAct(EntityUid uid, EntityUid targetUid,
         float siemens = 1,
         ElectrifiedComponent? electrified = null,
@@ -263,19 +241,15 @@ public sealed class ElectrocutionSystem : SharedElectrocutionSystem
         }
 
         var node = PoweredNode(uid, electrified, nodeContainer);
-        if (node?.NodeGroup is not IBasePowerNet powerNet)
-            return false;
-
-        var net = powerNet.NetworkNode;
-        var supp = net.LastCombinedMaxSupply;
-
-        if (supp <= 0f)
+        if (node?.NodeGroup is not IBasePowerNet)
             return false;
 
-        // Initial damage scales off of the available supply on the principle that the victim has shorted the entire powernet through their body.
-        var damageScale = CalculateElectrifiedDamageScale(supp);
-        if (damageScale <= 0f)
-            return false;
+        var (damageScalar, timeScalar) = node.NodeGroupID switch
+        {
+            NodeGroupID.HVPower => (electrified.HighVoltageDamageMultiplier, electrified.HighVoltageTimeMultiplier),
+            NodeGroupID.MVPower => (electrified.MediumVoltageDamageMultiplier, electrified.MediumVoltageTimeMultiplier),
+            _ => (1f, 1f)
+        };
 
         {
             var lastRet = true;
@@ -286,8 +260,8 @@ public sealed class ElectrocutionSystem : SharedElectrocutionSystem
                     entity,
                     uid,
                     node,
-                    (int) MathF.Ceiling(electrified.ShockDamage * damageScale * MathF.Pow(RecursiveDamageMultiplier, depth)),
-                    TimeSpan.FromSeconds(electrified.ShockTime * MathF.Min(1f + MathF.Log2(1f + damageScale), 3f) * MathF.Pow(RecursiveTimeMultiplier, depth)),
+                    (int) (electrified.ShockDamage * MathF.Pow(RecursiveDamageMultiplier, depth) * damageScalar),
+                    TimeSpan.FromSeconds(electrified.ShockTime * MathF.Pow(RecursiveTimeMultiplier, depth) * timeScalar),
                     true,
                     electrified.SiemensCoefficient);
             }