using Content.Server.Fluids.EntitySystems;
using Content.Server.Ghost;
using Content.Server.Popups;
-using Content.Server.Repairable;
using Content.Server.Stack;
using Content.Server.Wires;
using Content.Shared.Body.Systems;
using Content.Shared.Mind;
using Content.Shared.Nutrition.EntitySystems;
using Content.Shared.Power;
+using Content.Shared.Repairable;
using Content.Shared.Stacks;
using Robust.Server.GameObjects;
using Robust.Shared.Player;
+++ /dev/null
-using Content.Shared.Damage;
-using Content.Shared.Tools;
-using Robust.Shared.Prototypes;
-using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
-
-namespace Content.Server.Repairable
-{
- [RegisterComponent]
- public sealed partial class RepairableComponent : Component
- {
- /// <summary>
- /// All the damage to change information is stored in this <see cref="DamageSpecifier"/>.
- /// </summary>
- /// <remarks>
- /// If this data-field is specified, it will change damage by this amount instead of setting all damage to 0.
- /// in order to heal/repair the damage values have to be negative.
- /// </remarks>
- [DataField]
- public DamageSpecifier? Damage;
-
- [DataField]
- public int FuelCost = 5;
-
- [DataField]
- public ProtoId<ToolQualityPrototype> QualityNeeded = "Welding";
-
- [DataField]
- public int DoAfterDelay = 1;
-
- /// <summary>
- /// A multiplier that will be applied to the above if an entity is repairing themselves.
- /// </summary>
- [DataField]
- public float SelfRepairPenalty = 3f;
-
- /// <summary>
- /// Whether or not an entity is allowed to repair itself.
- /// </summary>
- [DataField]
- public bool AllowSelfRepair = true;
- }
-}
+++ /dev/null
-using Content.Server.Administration.Logs;
-using Content.Shared.Damage;
-using Content.Shared.Database;
-using Content.Shared.Interaction;
-using Content.Shared.Popups;
-using Content.Shared.Repairable;
-using SharedToolSystem = Content.Shared.Tools.Systems.SharedToolSystem;
-
-namespace Content.Server.Repairable
-{
- public sealed class RepairableSystem : SharedRepairableSystem
- {
- [Dependency] private readonly SharedToolSystem _toolSystem = default!;
- [Dependency] private readonly DamageableSystem _damageableSystem = default!;
- [Dependency] private readonly SharedPopupSystem _popup = default!;
- [Dependency] private readonly IAdminLogManager _adminLogger= default!;
-
- public override void Initialize()
- {
- SubscribeLocalEvent<RepairableComponent, InteractUsingEvent>(Repair);
- SubscribeLocalEvent<RepairableComponent, RepairFinishedEvent>(OnRepairFinished);
- }
-
- private void OnRepairFinished(EntityUid uid, RepairableComponent component, RepairFinishedEvent args)
- {
- if (args.Cancelled)
- return;
-
- if (!TryComp(uid, out DamageableComponent? damageable) || damageable.TotalDamage == 0)
- return;
-
- if (component.Damage != null)
- {
- var damageChanged = _damageableSystem.TryChangeDamage(uid, component.Damage, true, false, origin: args.User);
- _adminLogger.Add(LogType.Healed, $"{ToPrettyString(args.User):user} repaired {ToPrettyString(uid):target} by {damageChanged?.GetTotal()}");
- }
-
- else
- {
- // Repair all damage
- _damageableSystem.SetAllDamage(uid, damageable, 0);
- _adminLogger.Add(LogType.Healed, $"{ToPrettyString(args.User):user} repaired {ToPrettyString(uid):target} back to full health");
- }
-
- var str = Loc.GetString("comp-repairable-repair",
- ("target", uid),
- ("tool", args.Used!));
- _popup.PopupEntity(str, uid, args.User);
-
- var ev = new RepairedEvent((uid, component), args.User);
- RaiseLocalEvent(uid, ref ev);
- }
-
- public async void Repair(EntityUid uid, RepairableComponent component, InteractUsingEvent args)
- {
- if (args.Handled)
- return;
-
- // Only try repair the target if it is damaged
- if (!TryComp<DamageableComponent>(uid, out var damageable) || damageable.TotalDamage == 0)
- return;
-
- float delay = component.DoAfterDelay;
-
- // Add a penalty to how long it takes if the user is repairing itself
- if (args.User == args.Target)
- {
- if (!component.AllowSelfRepair)
- return;
-
- delay *= component.SelfRepairPenalty;
- }
-
- // Run the repairing doafter
- args.Handled = _toolSystem.UseTool(args.Used, args.User, uid, delay, component.QualityNeeded, new RepairFinishedEvent(), component.FuelCost);
- }
- }
-
- /// <summary>
- /// Event raised on an entity when its successfully repaired.
- /// </summary>
- /// <param name="Ent"></param>
- /// <param name="User"></param>
- [ByRefEvent]
- public readonly record struct RepairedEvent(Entity<RepairableComponent> Ent, EntityUid User);
-
-}
using Content.Server.NPC.HTN;
using Content.Server.NPC.HTN.PrimitiveTasks.Operators.Combat.Ranged;
using Content.Server.Power.Components;
-using Content.Server.Repairable;
using Content.Server.TurretController;
using Content.Shared.Access;
using Content.Shared.Destructible;
using Content.Shared.DeviceNetwork.Components;
using Content.Shared.DeviceNetwork.Events;
using Content.Shared.Power;
+using Content.Shared.Repairable;
using Content.Shared.Turrets;
using Content.Shared.Weapons.Ranged.Components;
using Content.Shared.Weapons.Ranged.Events;
--- /dev/null
+using Content.Shared.Damage;
+using Content.Shared.Tools;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.Repairable;
+
+/// <summary>
+/// Use this component to mark a device as repairable.
+/// </summary>
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+public sealed partial class RepairableComponent : Component
+{
+ /// <summary>
+ /// All the damage to change information is stored in this <see cref="DamageSpecifier"/>.
+ /// </summary>
+ /// <remarks>
+ /// If this data-field is specified, it will change damage by this amount instead of setting all damage to 0.
+ /// in order to heal/repair the damage values have to be negative.
+ /// </remarks>
+ [DataField, AutoNetworkedField]
+ public DamageSpecifier? Damage;
+
+ /// <summary>
+ /// Cost of fuel used to repair this device.
+ /// </summary>
+ [DataField, AutoNetworkedField]
+ public int FuelCost = 5;
+
+ /// <summary>
+ /// Tool quality necessary to repair this device.
+ /// </summary>
+ [DataField, AutoNetworkedField]
+ public ProtoId<ToolQualityPrototype> QualityNeeded = "Welding";
+
+ /// <summary>
+ /// The base tool use delay (seconds). This will be modified by the tool's quality
+ /// </summary>
+ [DataField, AutoNetworkedField]
+ public int DoAfterDelay = 1;
+
+ /// <summary>
+ /// A multiplier that will be applied to the above if an entity is repairing themselves.
+ /// </summary>
+ [DataField, AutoNetworkedField]
+ public float SelfRepairPenalty = 3f;
+
+ /// <summary>
+ /// Whether an entity is allowed to repair itself.
+ /// </summary>
+ [DataField, AutoNetworkedField]
+ public bool AllowSelfRepair = true;
+}
--- /dev/null
+using Content.Shared.Administration.Logs;
+using Content.Shared.Damage;
+using Content.Shared.Database;
+using Content.Shared.DoAfter;
+using Content.Shared.Interaction;
+using Content.Shared.Popups;
+using Content.Shared.Tools.Systems;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Repairable;
+
+public sealed partial class RepairableSystem : EntitySystem
+{
+ [Dependency] private readonly SharedToolSystem _toolSystem = default!;
+ [Dependency] private readonly DamageableSystem _damageableSystem = default!;
+ [Dependency] private readonly SharedPopupSystem _popup = default!;
+ [Dependency] private readonly ISharedAdminLogManager _adminLogger = default!;
+
+ public override void Initialize()
+ {
+ SubscribeLocalEvent<RepairableComponent, InteractUsingEvent>(Repair);
+ SubscribeLocalEvent<RepairableComponent, RepairFinishedEvent>(OnRepairFinished);
+ }
+
+ private void OnRepairFinished(Entity<RepairableComponent> ent, ref RepairFinishedEvent args)
+ {
+ if (args.Cancelled)
+ return;
+
+ if (!TryComp(ent.Owner, out DamageableComponent? damageable) || damageable.TotalDamage == 0)
+ return;
+
+ if (ent.Comp.Damage != null)
+ {
+ var damageChanged = _damageableSystem.TryChangeDamage(ent.Owner, ent.Comp.Damage, true, false, origin: args.User);
+ _adminLogger.Add(LogType.Healed, $"{ToPrettyString(args.User):user} repaired {ToPrettyString(ent.Owner):target} by {damageChanged?.GetTotal()}");
+ }
+
+ else
+ {
+ // Repair all damage
+ _damageableSystem.SetAllDamage(ent.Owner, damageable, 0);
+ _adminLogger.Add(LogType.Healed, $"{ToPrettyString(args.User):user} repaired {ToPrettyString(ent.Owner):target} back to full health");
+ }
+
+ var str = Loc.GetString("comp-repairable-repair", ("target", ent.Owner), ("tool", args.Used!));
+ _popup.PopupClient(str, ent.Owner, args.User);
+
+ var ev = new RepairedEvent(ent, args.User);
+ RaiseLocalEvent(ent.Owner, ref ev);
+ }
+
+ private void Repair(Entity<RepairableComponent> ent, ref InteractUsingEvent args)
+ {
+ if (args.Handled)
+ return;
+
+ // Only try repair the target if it is damaged
+ if (!TryComp<DamageableComponent>(ent.Owner, out var damageable) || damageable.TotalDamage == 0)
+ return;
+
+ float delay = ent.Comp.DoAfterDelay;
+
+ // Add a penalty to how long it takes if the user is repairing itself
+ if (args.User == args.Target)
+ {
+ if (!ent.Comp.AllowSelfRepair)
+ return;
+
+ delay *= ent.Comp.SelfRepairPenalty;
+ }
+
+ // Run the repairing doafter
+ args.Handled = _toolSystem.UseTool(args.Used, args.User, ent.Owner, delay, ent.Comp.QualityNeeded, new RepairFinishedEvent(), ent.Comp.FuelCost);
+ }
+}
+
+/// <summary>
+/// Event raised on an entity when its successfully repaired.
+/// </summary>
+/// <param name="Ent"></param>
+/// <param name="User"></param>
+[ByRefEvent]
+public readonly record struct RepairedEvent(Entity<RepairableComponent> Ent, EntityUid User);
+
+[Serializable, NetSerializable]
+public sealed partial class RepairFinishedEvent : SimpleDoAfterEvent;
+++ /dev/null
-using Content.Shared.DoAfter;
-using Robust.Shared.Serialization;
-
-namespace Content.Shared.Repairable;
-
-public abstract partial class SharedRepairableSystem : EntitySystem
-{
- [Serializable, NetSerializable]
- protected sealed partial class RepairFinishedEvent : SimpleDoAfterEvent
- {
- }
-}
-
projects / space-station-14.git / commitdiff