уэээ

Content.Benchmarks/MapLoadBenchmark.cs

@@ -46,7 +46,7 @@ public async Task Cleanup()
         PoolManager.Shutdown();
     }
 
-    public static readonly string[] MapsSource = { "Empty", "Box", "Bagel", "Dev", "CentComm", "Atlas", "Core", "TestTeg", "Saltern", "Packed", "Omega", "Cluster", "Reach", "Origin", "Meta", "Marathon", "Europa", "MeteorArena", "Fland", "Barratry", "Oasis" };
+    public static readonly string[] MapsSource = { "Empty", "Box", "Bagel", "Dev", "CentComm", "Atlas", "Core", "TestTeg", "Saltern", "Packed", "Omega", "Cluster", "Reach", "Origin", "Meta", "Marathon", "Europa", "MeteorArena", "Fland", "Barratry", "Oasis", "Skibidi"};
 
     [ParamsSource(nameof(MapsSource))]
     public string Map;

Content.Client/Rotation/RotationVisualizerSystem.cs

@@ -23,8 +23,8 @@ private void OnAppearanceChange(EntityUid uid, RotationVisualsComponent componen
         if (args.Sprite == null)
             return;
 
-        // If not defined, defaults to standing.
-        _appearance.TryGetData<RotationState>(uid, RotationVisuals.RotationState, out var state, args.Component);
+        if (!_appearance.TryGetData<RotationState>(uid, RotationVisuals.RotationState, out var state, args.Component))
+            return;
 
         switch (state)
         {

Content.IntegrationTests/Tests/PostMapInitTest.cs

@@ -80,7 +80,10 @@ public sealed class PostMapInitTest
             "Atlas",
             "Reach",
             "Train",
-            "Oasis"
+            "Oasis",
+            // Skibidi-Start
+            "Skibidi"
+            // Skibidi-End
         };
 
         /// <summary>

Content.Server/Medical/Components/ActiveSurgeryComponent.cs

@@ -0,0 +1,9 @@
+namespace Content.Server.Medical.Components
+{
+    [RegisterComponent]
+    public sealed partial class ActiveSurgeryComponent : Component
+    {
+        [DataField]
+        public bool? IsActive = false;
+    }
+}

Content.Server/Medical/Components/MedicalDrapesComponent.cs

@@ -0,0 +1,13 @@
+namespace Content.Server.Medical.Components;
+[RegisterComponent, AutoGenerateComponentPause]
+[Access(typeof(MedicalDrapesSystem), typeof(CryoPodSystem))]
+public sealed partial class MedicalDrapesComponent : Component
+{
+    [DataField]
+    public TimeSpan UseDelay = TimeSpan.FromSeconds(0.8);
+    [DataField]
+    public EntityUid? UsedOnEntity;
+    [DataField]
+    public float MaxUseRange = 2.5f;
+
+}

Content.Server/Medical/Components/SurgeryToolComponent.cs

@@ -0,0 +1,31 @@
+using Content.Shared.Damage;
+using Content.Shared.Damage.Prototypes;
+using Robust.Shared.Audio;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.List;
+namespace Content.Server.Medical.Components
+{
+    [RegisterComponent]
+    public sealed partial class SurgeryToolComponent : Component
+    {
+        [DataField("damage", required: true)]
+        [ViewVariables(VVAccess.ReadWrite)]
+        public DamageSpecifier Damage = default!;
+        [DataField("damageContainers", customTypeSerializer: typeof(PrototypeIdListSerializer<DamageContainerPrototype>))]
+        public List<string>? DamageContainers;
+        [ViewVariables(VVAccess.ReadWrite)]
+        [DataField("delay")]
+        public float Delay = 1f;
+        [DataField("InProgressSound")]
+        public SoundSpecifier? InProgressSound = null;
+        [DataField("CauterySound")]
+        public SoundSpecifier? CauterySound = null;
+        [DataField("ScalpelSound")]
+        public SoundSpecifier? ScalpelSound = null;
+        [DataField("IsCautery")]
+        public bool? IsCautery = null;
+        [DataField("IsScalpel")]
+        public bool? IsScalpel = null;
+        [DataField("IsHemostat")]
+        public bool? IsHemostat = null;
+    }
+}

Content.Server/Medical/HealingSystem.cs

@@ -152,7 +152,7 @@ private void OnHealingAfterInteract(Entity<HealingComponent> entity, ref AfterIn
             args.Handled = true;
     }
 
-    private bool TryHeal(EntityUid uid, EntityUid user, EntityUid target, HealingComponent component)
+    public bool TryHeal(EntityUid uid, EntityUid user, EntityUid target, HealingComponent component)
     {
         if (!TryComp<DamageableComponent>(target, out var targetDamage))
             return false;

Content.Server/Medical/MedicalDrapesSystem.cs

@@ -0,0 +1,71 @@
+using Content.Server.Medical.Components;
+using Content.Server.Popups;
+using Content.Shared.Buckle.Components;
+using Content.Shared.DoAfter;
+using Content.Shared.IdentityManagement;
+using Content.Shared.Interaction;
+using Content.Shared.Mobs.Components;
+using Robust.Server.GameObjects;
+using Robust.Shared.Timing;
+using Content.Shared.Medical;
+using YamlDotNet.Core.Tokens;
+
+namespace Content.Server.Medical
+{
+    public sealed class MedicalDrapesSystem : EntitySystem
+    {
+        [Dependency] private readonly IGameTiming _timing = default!;
+        [Dependency] private readonly SharedDoAfterSystem _doAfterSystem = default!;
+        [Dependency] private readonly UserInterfaceSystem _uiSystem = default!;
+        [Dependency] private readonly TransformSystem _transformSystem = default!;
+        [Dependency] private readonly PopupSystem _popupSystem = default!;
+        public override void Initialize()
+        {
+            SubscribeLocalEvent<MedicalDrapesComponent, AfterInteractEvent>(OnAfterInteract);
+            SubscribeLocalEvent<MedicalDrapesComponent, MedicalDrapesDoAfterEvent>(OnDoAfter);
+        }
+
+        private void OnAfterInteract(Entity<MedicalDrapesComponent> uid, ref AfterInteractEvent args)
+        {
+            if (args.Target == null || !args.CanReach || !HasComp<MobStateComponent>(args.Target))
+                return;
+
+            _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, args.User, uid.Comp.UseDelay, new MedicalDrapesDoAfterEvent(), uid, target: args.Target, used: uid)
+            {
+                NeedHand = true,
+                BreakOnMove = true
+            });
+        }
+
+        private void OnDoAfter(Entity<MedicalDrapesComponent> uid, ref MedicalDrapesDoAfterEvent args)
+        {
+            if (args.Handled || args.Cancelled || args.Target == null)
+                return;
+            args.Handled = true;
+            EntityUid target = (EntityUid)args.Target;
+            TryComp<BuckleComponent>(args.Target, out var buckle);
+            var ent = buckle!.BuckledTo;
+            TryComp<ActiveSurgeryComponent>(args.Target, out var surgery);
+            if (!HasComp<ActiveSurgeryComponent>(target))
+            {
+                if (target == args.User)
+                    return;
+                if(!buckle.Buckled)
+                {
+                    _popupSystem.PopupEntity(Loc.GetString("medical-surgery-cantoperate"), uid, args.User);
+                    return;
+                }
+                AddComp<ActiveSurgeryComponent>(target);
+                _popupSystem.PopupEntity(Loc.GetString("medical-surgery-activate"), uid, args.User);
+            }
+            if (HasComp<ActiveSurgeryComponent>(target) && surgery!.IsActive != true)
+            {
+                if (target == args.User)
+                    return;
+                RemComp<ActiveSurgeryComponent>(target);
+                _popupSystem.PopupEntity(Loc.GetString("medical-surgery-stop"), uid, args.User);
+            }
+
+        }
+    }
+}

Content.Server/Medical/SurgerySystem.cs

@@ -0,0 +1,158 @@
+using Content.Server.Administration.Logs;
+using Content.Server.Body.Components;
+using Content.Server.Body.Systems;
+using Content.Server.Chemistry.Containers.EntitySystems;
+using Content.Server.Medical.Components;
+using Content.Server.Popups;
+using Content.Server.Stack;
+using Content.Shared.Audio;
+using Content.Shared.Buckle.Components;
+using Content.Shared.Damage;
+using Content.Shared.Database;
+using Content.Shared.DoAfter;
+using Content.Shared.FixedPoint;
+using Content.Shared.Interaction;
+using Content.Shared.Interaction.Events;
+using Content.Shared.Item;
+using Content.Shared.Medical;
+using Content.Shared.Mobs;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Mobs.Systems;
+using Content.Shared.Stacks;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Random;
+
+namespace Content.Server.Medical;
+
+public sealed class SurgerySystem : EntitySystem
+{
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly IAdminLogManager _adminLogger = default!;
+    [Dependency] private readonly DamageableSystem _damageable = default!;
+    [Dependency] private readonly BloodstreamSystem _bloodstreamSystem = default!;
+    [Dependency] private readonly SharedDoAfterSystem _doAfter = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly StackSystem _stacks = default!;
+    [Dependency] private readonly SharedInteractionSystem _interactionSystem = default!;
+    [Dependency] private readonly MobThresholdSystem _mobThresholdSystem = default!;
+    [Dependency] private readonly PopupSystem _popupSystem = default!;
+    [Dependency] private readonly SolutionContainerSystem _solutionContainerSystem = default!;
+
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<SurgeryToolComponent, AfterInteractEvent>(OnSurgeryAfterInteract);
+        SubscribeLocalEvent<DamageableComponent, SurgeryDoAfterEvent>(OnDoAfter);
+    }
+
+    private void OnDoAfter(Entity<DamageableComponent> entity, ref SurgeryDoAfterEvent args)
+    {
+        TryComp<SurgeryToolComponent>(entity, out var comp);
+        var dontRepeat = false;
+        if (!TryComp(args.Used, out SurgeryToolComponent? healing))
+            return;
+        if (args.Handled || args.Cancelled)
+            return;
+        if (healing.DamageContainers is not null &&
+            entity.Comp.DamageContainerID is not null &&
+            !healing.DamageContainers.Contains(entity.Comp.DamageContainerID))
+        {
+            return;
+        }
+        var healed = _damageable.TryChangeDamage(entity.Owner, healing.Damage, true, origin: args.Args.User);
+        if (healed == null)
+            return;
+        var total = healed?.GetTotal() ?? FixedPoint2.Zero;
+        if (entity.Owner != args.User)
+        {
+            _adminLogger.Add(LogType.Healed,
+                $"{EntityManager.ToPrettyString(args.User):user} healed {EntityManager.ToPrettyString(entity.Owner):target} for {total:damage} damage");
+        }
+        _audio.PlayPvs(comp!.InProgressSound, args.User, AudioHelpers.WithVariation(0.125f, _random).WithVolume(1f));
+
+        args.Repeat = (HasDamage(entity.Comp, healing) && !dontRepeat);
+        if (!args.Repeat && !dontRepeat)
+            args.Handled = true;
+    }
+
+    private bool HasDamage(DamageableComponent component, SurgeryToolComponent healing)
+    {
+        var damageableDict = component.Damage.DamageDict;
+        var healingDict = healing.Damage.DamageDict;
+        foreach (var type in healingDict)
+        {
+            if (damageableDict[type.Key].Value > 0)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+    private void OnSurgeryAfterInteract(Entity<SurgeryToolComponent> entity, ref AfterInteractEvent args)
+    {
+        TryComp<SurgeryToolComponent>(entity, out var comp);
+        var target = (EntityUid)args.Target!;
+        TryComp<ActiveSurgeryComponent>(args.Target, out var surgery);
+        if (args.Handled || !args.CanReach || args.Target == null && !HasComp<ActiveSurgeryComponent>(args.Target) && surgery!.IsActive != true)
+            return;
+
+        if (entity.Comp.IsScalpel == true && surgery!.IsActive != true)
+        {
+            surgery!.IsActive = true;
+            _audio.PlayPvs(comp!.ScalpelSound, entity.Owner);
+            args.Handled = true;
+        }
+
+        if (surgery!.IsActive == true)
+        {
+            if (entity.Comp.IsCautery == true)
+            {
+            _audio.PlayPvs(comp!.CauterySound, entity.Owner);
+            RemComp<ActiveSurgeryComponent>(target);
+            args.Handled = true;
+            }
+
+            if (entity.Comp.IsHemostat == true)
+            {
+            if (TryHeal(entity, args.User, args.Target!.Value, entity.Comp))
+                args.Handled = true;
+            }
+        }
+
+    }
+
+    public bool TryHeal(EntityUid uid, EntityUid user, EntityUid target, SurgeryToolComponent component)
+    {
+        if (!TryComp<DamageableComponent>(target, out var targetDamage))
+            return false;
+        TryComp<BuckleComponent>(target, out var buckle);
+        if (!buckle!.Buckled)
+            return false;
+        if (component.DamageContainers is not null &&
+            targetDamage.DamageContainerID is not null &&
+            !component.DamageContainers.Contains(targetDamage.DamageContainerID))
+        {
+            return false;
+        }
+        if (user != target && !_interactionSystem.InRangeUnobstructed(user, target, popup: true))
+            return false;
+        var anythingToDo = HasDamage(targetDamage, component);
+        if (!anythingToDo)
+        {
+            return false;
+        }
+        _audio.PlayPvs(component!.InProgressSound, user, AudioHelpers.WithVariation(0.125f, _random).WithVolume(1f));
+        var delay = component.Delay;
+        var doAfterEventArgs =
+            new DoAfterArgs(EntityManager, user, delay, new SurgeryDoAfterEvent(), target, target: target, used: uid)
+            {
+                // Didn't break on damage as they may be trying to prevent it and
+                // not being able to heal your own ticking damage would be frustrating.
+                NeedHand = true,
+                BreakOnMove = true,
+                BreakOnWeightlessMove = false,
+            };
+        _doAfter.TryStartDoAfter(doAfterEventArgs);
+        return true;
+    }
+}

Content.Shared/Buckle/SharedBuckleSystem.Buckle.cs

@@ -21,6 +21,7 @@
 using Robust.Shared.Physics.Events;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Utility;
+using Content.Shared.Rotation;
 
 namespace Content.Shared.Buckle;
 
@@ -195,6 +196,7 @@ protected void SetBuckledTo(Entity<BuckleComponent> buckle, Entity<StrapComponen
         buckle.Comp.BuckleTime = _gameTiming.CurTime;
         ActionBlocker.UpdateCanMove(buckle);
         Appearance.SetData(buckle, StrapVisuals.State, buckle.Comp.Buckled);
+        Appearance.SetData(buckle, RotationVisuals.RotationState, RotationState.Horizontal);
         Dirty(buckle);
     }
 
@@ -348,6 +350,7 @@ private void Buckle(Entity<BuckleComponent> buckle, Entity<StrapComponent> strap
         SetBuckledTo(buckle, strap!);
         Appearance.SetData(strap, StrapVisuals.State, true);
         Appearance.SetData(buckle, BuckleVisuals.Buckled, true);
+        Appearance.SetData(buckle, RotationVisuals.RotationState, RotationState.Horizontal);
 
         _rotationVisuals.SetHorizontalAngle(buckle.Owner, strap.Comp.Rotation);
 
@@ -455,6 +458,7 @@ private void Unbuckle(Entity<BuckleComponent> buckle, Entity<StrapComponent> str
         _rotationVisuals.ResetHorizontalAngle(buckle.Owner);
         Appearance.SetData(strap, StrapVisuals.State, strap.Comp.BuckledEntities.Count != 0);
         Appearance.SetData(buckle, BuckleVisuals.Buckled, false);
+        Appearance.SetData(buckle, RotationVisuals.RotationState, RotationState.Vertical);
 
         if (HasComp<KnockedDownComponent>(buckle) || _mobState.IsIncapacitated(buckle))
             _standing.Down(buckle);

Content.Shared/Medical/MedicalDrapesDoAfterEvent.cs

@@ -0,0 +1,9 @@
+using Content.Shared.DoAfter;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Medical;
+
+[Serializable, NetSerializable]
+public sealed partial class MedicalDrapesDoAfterEvent : SimpleDoAfterEvent
+{
+}

Content.Shared/Medical/SurgeryDoAfterEvent.cs

@@ -0,0 +1,9 @@
+using Content.Shared.DoAfter;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Medical;
+
+[Serializable, NetSerializable]
+public sealed partial class SurgeryDoAfterEvent : SimpleDoAfterEvent
+{
+}