Load o' Fixes for IPCs and Mechs (DeltaV-Station#1235)

Content.Server/Cloning/CloningSystem.cs

@@ -9,6 +9,7 @@
 using Content.Server.Materials;
 using Content.Server.Popups;
 using Content.Server.Power.EntitySystems;
+using Content.Shared._EinsteinEngines.Silicon.Components; // Goobstation
 using Content.Shared.Atmos;
 using Content.Shared.CCVar;
 using Content.Shared.Chemistry.Components;
@@ -167,6 +168,9 @@ public bool TryCloning(EntityUid uid, EntityUid bodyToClone, Entity<MindComponen
             if (!TryComp<HumanoidAppearanceComponent>(bodyToClone, out var humanoid))
                 return false; // whatever body was to be cloned, was not a humanoid
 
+            if (HasComp<SiliconComponent>(bodyToClone))
+                return false; // Goobstation: Don't clone IPCs.
+
             if (!_prototype.TryIndex(humanoid.Species, out var speciesPrototype))
                 return false;
 

Content.Server/Mech/Systems/MechSystem.cs

@@ -240,7 +240,6 @@ private void OnMechEntry(EntityUid uid, MechComponent component, MechEntryEvent
 
         TryInsert(uid, args.Args.User, component);
         _actionBlocker.UpdateCanMove(uid);
-
         args.Handled = true;
     }
 
@@ -250,7 +249,6 @@ private void OnMechExit(EntityUid uid, MechComponent component, MechExitEvent ar
             return;
 
         TryEject(uid, component);
-
         args.Handled = true;
     }
     //goobstation

Content.Server/Objectives/Components/PickRandomPersonComponent.cs

@@ -8,4 +8,6 @@ namespace Content.Server.Objectives.Components;
 [RegisterComponent, Access(typeof(KillPersonConditionSystem))]
 public sealed partial class PickRandomPersonComponent : Component
 {
+    [DataField]
+    public bool NeedsOrganic; // Goobstation: Only pick non-silicon players.
 }

Content.Server/Objectives/Systems/KillPersonConditionSystem.cs

@@ -60,7 +60,7 @@ private void OnPersonAssigned(EntityUid uid, PickRandomPersonComponent comp, ref
             return;
 
         // no other humans to kill
-        var allHumans = _mind.GetAliveHumans(args.MindId);
+        var allHumans = _mind.GetAliveHumans(args.MindId, comp.NeedsOrganic);
         if (allHumans.Count == 0)
         {
             args.Cancelled = true;

Content.Server/PowerCell/PowerCellSystem.cs

@@ -228,8 +228,8 @@ private void OnCellEmpAttempt(EntityUid uid, PowerCellComponent component, EmpAt
 
     private void OnCellSlotExamined(EntityUid uid, PowerCellSlotComponent component, ExaminedEvent args)
     {
-        TryGetBatteryFromSlot(uid, out var battery);
-        OnBatteryExamined(uid, battery, args);
+        TryGetBatteryFromSlot(uid, out var batteryEnt, out var battery); // Goobstation
+        OnBatteryExamined(batteryEnt.GetValueOrDefault(uid), battery, args); // Goobstation
     }
 
     public void OnBatteryExamined(EntityUid uid, BatteryComponent? component, ExaminedEvent args) // WD EDIT

Content.Server/_EinsteinEngines/Silicon/Charge/Systems/SiliconChargeSystem.cs

@@ -187,8 +187,9 @@ private float SiliconHeatEffects(EntityUid silicon, SiliconComponent siliconComp
             if (!_random.Prob(Math.Clamp(temperComp.CurrentTemperature / (upperThresh * 5), 0.001f, 0.9f)))
                 return hotTempMulti;
 
-            _flammable.AdjustFireStacks(silicon, Math.Clamp(siliconComp.FireStackMultiplier, -10, 10), flamComp);
-            _flammable.Ignite(silicon, silicon, flamComp);
+            // Goobstation: Replaced by KillOnOverheatSystem
+            //_flammable.AdjustFireStacks(silicon, Math.Clamp(siliconComp.FireStackMultiplier, -10, 10), flamComp);
+            //_flammable.Ignite(silicon, silicon, flamComp);
             return hotTempMulti;
         }
 

Content.Server/_EinsteinEngines/Silicon/WeldingHealable/WeldingHealableSystem.cs

@@ -7,6 +7,8 @@
 using Content.Shared.Interaction;
 using Content.Shared.Popups;
 using Content.Shared.Tools;
+using Content.Shared._Shitmed.Targeting;
+using Content.Shared.Body.Systems;
 using SharedToolSystem = Content.Shared.Tools.Systems.SharedToolSystem;
 
 namespace Content.Server._EinsteinEngines.Silicon.WeldingHealable;
@@ -17,7 +19,7 @@ public sealed class WeldingHealableSystem : SharedWeldingHealableSystem
     [Dependency] private readonly DamageableSystem _damageableSystem = default!;
     [Dependency] private readonly SharedPopupSystem _popup = default!;
     [Dependency] private readonly SharedSolutionContainerSystem _solutionContainer = default!;
-
+    [Dependency] private readonly SharedBodySystem _bodySystem = default!;
     public override void Initialize()
     {
         SubscribeLocalEvent<WeldingHealableComponent, InteractUsingEvent>(Repair);
@@ -31,7 +33,7 @@ private void OnRepairFinished(EntityUid uid, WeldingHealableComponent healableCo
             || !TryComp<WeldingHealingComponent>(args.Used, out var component)
             || damageable.DamageContainerID is null
             || !component.DamageContainers.Contains(damageable.DamageContainerID)
-            || !HasDamage(damageable, component)
+            || !HasDamage((args.Target.Value, damageable), component, args.User)
             || !TryComp<WelderComponent>(args.Used, out var welder)
             || !TryComp<SolutionContainerManagerComponent>(args.Used, out var solutionContainer)
             || !_solutionContainer.TryGetSolution(((EntityUid) args.Used, solutionContainer), welder.FuelSolutionName, out var solution))
@@ -67,7 +69,7 @@ private async void Repair(EntityUid uid, WeldingHealableComponent healableCompon
             || !EntityManager.TryGetComponent(args.Target, out DamageableComponent? damageable)
             || damageable.DamageContainerID is null
             || !component.DamageContainers.Contains(damageable.DamageContainerID)
-            || !HasDamage(damageable, component)
+            || !HasDamage((args.Target, damageable), component, args.User)
             || !_toolSystem.HasQuality(args.Used, component.QualityNeeded)
             || args.User == args.Target && !component.AllowSelfHeal)
             return;
@@ -88,16 +90,26 @@ private async void Repair(EntityUid uid, WeldingHealableComponent healableCompon
             });
     }
 
- private bool HasDamage(DamageableComponent component, WeldingHealingComponent healable)
+    private bool HasDamage(Entity<DamageableComponent> damageable, WeldingHealingComponent healable, EntityUid user)
     {
         if (healable.Damage.DamageDict is null)
             return false;
 
         foreach (var type in healable.Damage.DamageDict)
-            if (component.Damage.DamageDict[type.Key].Value > 0)
+            if (damageable.Comp.Damage.DamageDict[type.Key].Value > 0)
                 return true;
 
+        // In case the healer is a humanoid entity with targeting, we run the check on the targeted parts.
+        if (!TryComp(user, out TargetingComponent? targeting))
+            return false;
+
+        var (targetType, targetSymmetry) = _bodySystem.ConvertTargetBodyPart(targeting.Target);
+        foreach (var part in _bodySystem.GetBodyChildrenOfType(damageable, targetType, symmetry: targetSymmetry))
+            if (TryComp<DamageableComponent>(part.Id, out var damageablePart))
+                foreach (var type in healable.Damage.DamageDict)
+                    if (damageablePart.Damage.DamageDict[type.Key].Value > 0)
+                        return true;
+
         return false;
     }
 }
-

Content.Server/_Goobstation/Mech/Equipment/EntitySystems/MechGunSystem.cs

@@ -2,26 +2,27 @@
 using Content.Server.Power.Components;
 using Content.Server.Power.EntitySystems;
 using Content.Shared.Mech.Components;
+using Content.Shared.Mech.EntitySystems;
 using Content.Shared.Mech.Equipment.Components;
 using Content.Shared.Throwing;
-using Content.Shared.Weapons.Ranged.Systems;
+using Content.Shared.Weapons.Ranged.Components;
 using Robust.Shared.Random;
 
 namespace Content.Server.Mech.Equipment.EntitySystems;
 public sealed class MechGunSystem : EntitySystem
 {
-    [Dependency] private readonly IRobustRandom _random = default!;
-    [Dependency] private readonly ThrowingSystem _throwing = default!;
     [Dependency] private readonly MechSystem _mech = default!;
     [Dependency] private readonly BatterySystem _battery = default!;
 
     public override void Initialize()
     {
         base.Initialize();
-        SubscribeLocalEvent<MechEquipmentComponent, GunShotEvent>(MechGunShot);
+        SubscribeLocalEvent<MechEquipmentComponent, HandleMechEquipmentBatteryEvent>(OnHandleMechEquipmentBattery);
+        SubscribeLocalEvent<HitscanBatteryAmmoProviderComponent, CheckMechWeaponBatteryEvent>(OnCheckBattery);
+        SubscribeLocalEvent<ProjectileBatteryAmmoProviderComponent, CheckMechWeaponBatteryEvent>(OnCheckBattery);
     }
 
-    private void MechGunShot(EntityUid uid, MechEquipmentComponent component, ref GunShotEvent args)
+    private void OnHandleMechEquipmentBattery(EntityUid uid, MechEquipmentComponent component, HandleMechEquipmentBatteryEvent args)
     {
         if (!component.EquipmentOwner.HasValue)
             return;
@@ -31,11 +32,22 @@ private void MechGunShot(EntityUid uid, MechEquipmentComponent component, ref Gu
 
         if (TryComp<BatteryComponent>(uid, out var battery))
         {
+            var ev = new CheckMechWeaponBatteryEvent(battery);
+            RaiseLocalEvent(uid, ref ev);
+
+            if (ev.Cancelled)
+                return;
+
             ChargeGunBattery(uid, battery);
-            return;
         }
     }
 
+    private void OnCheckBattery(EntityUid uid, BatteryAmmoProviderComponent component, CheckMechWeaponBatteryEvent args)
+    {
+        if (args.Battery.CurrentCharge > component.FireCost)
+            args.Cancelled = true;
+    }
+
     private void ChargeGunBattery(EntityUid uid, BatteryComponent component)
     {
         if (!TryComp<MechEquipmentComponent>(uid, out var mechEquipment) || !mechEquipment.EquipmentOwner.HasValue)
@@ -59,3 +71,6 @@ private void ChargeGunBattery(EntityUid uid, BatteryComponent component)
         _battery.SetCharge(uid, component.MaxCharge, component);
     }
 }
+
+[ByRefEvent]
+public record struct CheckMechWeaponBatteryEvent(BatteryComponent Battery, bool Cancelled = false);

Content.Server/_Goobstation/Temperature/KillOnOverheatComponent.cs

@@ -0,0 +1,16 @@
+using Content.Shared.Atmos;
+
+namespace Content.Server._Goobstation.Temperature;
+
+/// <summary>
+/// Kills an entity when its temperature goes over a threshold.
+/// </summary>
+[RegisterComponent, Access(typeof(KillOnOverheatSystem))]
+public sealed partial class KillOnOverheatComponent : Component
+{
+    [DataField]
+    public float OverheatThreshold = Atmospherics.T0C + 110f;
+
+    [DataField]
+    public LocId OverheatPopup = "ipc-overheat-popup";
+}

Content.Server/_Goobstation/Temperature/KillOnOverheatSystem.cs

@@ -0,0 +1,33 @@
+using Content.Server.Temperature.Components;
+using Content.Shared.IdentityManagement;
+using Content.Shared.Mobs;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Mobs.Systems;
+using Content.Shared.Popups;
+using Content.Shared.Damage.Components;
+
+namespace Content.Server._Goobstation.Temperature;
+
+public sealed class KillOnOverheatSystem : EntitySystem
+{
+    [Dependency] private readonly MobStateSystem _mob = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        var query = EntityQueryEnumerator<KillOnOverheatComponent, TemperatureComponent, MobStateComponent>();
+        while (query.MoveNext(out var uid, out var comp, out var temp, out var mob))
+        {
+            if (mob.CurrentState == MobState.Dead
+                || temp.CurrentTemperature < comp.OverheatThreshold
+                || HasComp<GodmodeComponent>(uid))
+                continue;
+
+            var msg = Loc.GetString(comp.OverheatPopup, ("name", Identity.Name(uid, EntityManager)));
+            _popup.PopupEntity(msg, uid, PopupType.LargeCaution);
+            _mob.ChangeMobState(uid, MobState.Dead, mob);
+        }
+    }
+}