It's time to build a barbershop! (#22565)

* barber! * 5% change to maintenance
2023-12-22 12:54:00 +03:00
parent 5d185483b4
commit 5a1e317e0f
12 changed files with 253 additions and 42 deletions
--- a/Content.Server/MagicMirror/MagicMirrorSystem.cs
+++ b/Content.Server/MagicMirror/MagicMirrorSystem.cs
@@ -1,16 +1,22 @@
 using System.Linq;
+using Content.Server.DoAfter;
 using Content.Server.Humanoid;
 using Content.Server.UserInterface;
+using Content.Shared.DoAfter;
 using Content.Shared.Humanoid;
 using Content.Shared.Humanoid.Markings;
+using Content.Shared.Interaction;
 using Content.Shared.MagicMirror;
 using Robust.Server.GameObjects;
+using Robust.Shared.Audio.Systems;
 using Robust.Shared.Player;

 namespace Content.Server.MagicMirror;

 public sealed class MagicMirrorSystem : EntitySystem
 {
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly DoAfterSystem _doAfterSystem = default!;
    [Dependency] private readonly MarkingManager _markings = default!;
    [Dependency] private readonly HumanoidAppearanceSystem _humanoid = default!;
    [Dependency] private readonly UserInterfaceSystem _uiSystem = default!;
@@ -22,9 +28,27 @@ public sealed class MagicMirrorSystem : EntitySystem
        SubscribeLocalEvent<MagicMirrorComponent, ActivatableUIOpenAttemptEvent>(OnOpenUIAttempt);
        SubscribeLocalEvent<MagicMirrorComponent, AfterActivatableUIOpenEvent>(AfterUIOpen);
        SubscribeLocalEvent<MagicMirrorComponent, MagicMirrorSelectMessage>(OnMagicMirrorSelect);
-        SubscribeLocalEvent<MagicMirrorComponent, MagicMirrorChangeColorMessage>(OnMagicMirrorChangeColor);
-        SubscribeLocalEvent<MagicMirrorComponent, MagicMirrorAddSlotMessage>(OnMagicMirrorAddSlot);
-        SubscribeLocalEvent<MagicMirrorComponent, MagicMirrorRemoveSlotMessage>(OnMagicMirrorRemoveSlot);
+        SubscribeLocalEvent<MagicMirrorComponent, MagicMirrorChangeColorMessage>(OnTryMagicMirrorChangeColor);
+        SubscribeLocalEvent<MagicMirrorComponent, MagicMirrorAddSlotMessage>(OnTryMagicMirrorAddSlot);
+        SubscribeLocalEvent<MagicMirrorComponent, MagicMirrorRemoveSlotMessage>(OnTryMagicMirrorRemoveSlot);
+
+        SubscribeLocalEvent<MagicMirrorComponent, AfterInteractEvent>(OnMagicMirrorInteract);
+
+        SubscribeLocalEvent<MagicMirrorComponent, SelectDoAfterEvent>(OnSelectSlotDoAfter);
+        SubscribeLocalEvent<MagicMirrorComponent, ChangeColorDoAfterEvent>(OnChangeColorDoAfter);
+        SubscribeLocalEvent<MagicMirrorComponent, RemoveSlotDoAfterEvent>(OnRemoveSlotDoAfter);
+        SubscribeLocalEvent<MagicMirrorComponent, AddSlotDoAfterEvent>(OnAddSlotDoAfter);
+    }
+
+    private void OnMagicMirrorInteract(Entity<MagicMirrorComponent> mirror, ref AfterInteractEvent args)
+    {
+        if (!TryComp<ActorComponent>(args.User, out var actor)) return;
+        if (TryComp<HumanoidAppearanceComponent>(args.Target, out var humanoid))
+        {
+            mirror.Comp.Target = new Entity<HumanoidAppearanceComponent>(args.Target.Value, humanoid);
+            UpdateInterface(mirror.Owner, mirror.Comp.Target.Value.Owner, actor.PlayerSession);
+            Log.Debug($"Target {mirror.Comp.Target}!");
+        };
    }

    private void OnOpenUIAttempt(EntityUid uid, MagicMirrorComponent mirror, ActivatableUIOpenAttemptEvent args)
@@ -33,16 +57,32 @@ public sealed class MagicMirrorSystem : EntitySystem
            args.Cancel();
    }

-    private void OnMagicMirrorSelect(EntityUid uid, MagicMirrorComponent component,
-        MagicMirrorSelectMessage message)
+    private void OnMagicMirrorSelect(EntityUid uid, MagicMirrorComponent component, MagicMirrorSelectMessage message)
    {
-        if (message.Session.AttachedEntity == null || !TryComp<HumanoidAppearanceComponent>(message.Session.AttachedEntity.Value, out var humanoid))
+        if (component.Target == null) return;
+        if (message.Session.AttachedEntity == null) return;
+
+        var doAfter = new SelectDoAfterEvent(message);
+        _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, message.Session.AttachedEntity.Value, component.SelectSlotTime, doAfter, uid, target: component.Target.Value.Owner, used: uid)
        {
+            BreakOnTargetMove = true,
+            BreakOnDamage = true,
+            BreakOnHandChange = false,
+            BreakOnUserMove = true,
+            BreakOnWeightlessMove = false,
+            NeedHand = true
+        });
+
+        _audio.PlayPvs(component.ChangeHairSound, uid);
+    }
+    private void OnSelectSlotDoAfter(EntityUid uid, MagicMirrorComponent component, SelectDoAfterEvent args)
+    {
+        if (args.Handled || args.Args.Target == null || args.Cancelled)
            return;
-        }
+        if (component.Target == null) return;

        var category = MarkingCategories.Hair;
-        switch (message.Category)
+        switch (args.Message.Category)
        {
            case MagicMirrorCategory.Hair:
                category = MarkingCategories.Hair;
@@ -54,21 +94,35 @@ public sealed class MagicMirrorSystem : EntitySystem
                return;
        }

-        _humanoid.SetMarkingId(message.Session.AttachedEntity.Value, category, message.Slot, message.Marking);
+        _humanoid.SetMarkingId(component.Target.Value.Owner, category, args.Message.Slot, args.Message.Marking);

-        UpdateInterface(uid, message.Session.AttachedEntity.Value, message.Session);
+        UpdateInterface(uid, component.Target.Value.Owner, args.Message.Session);
    }

-    private void OnMagicMirrorChangeColor(EntityUid uid, MagicMirrorComponent component,
-        MagicMirrorChangeColorMessage message)
+    private void OnTryMagicMirrorChangeColor(EntityUid uid, MagicMirrorComponent component, MagicMirrorChangeColorMessage message)
    {
-        if (message.Session.AttachedEntity == null || !TryComp<HumanoidAppearanceComponent>(message.Session.AttachedEntity.Value, out var humanoid))
+        if (component.Target == null) return;
+        if (message.Session.AttachedEntity == null) return;
+
+        var doAfter = new ChangeColorDoAfterEvent(message);
+        _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, message.Session.AttachedEntity.Value, component.ChangeSlotTime, doAfter, uid, target: component.Target.Value.Owner, used: uid)
        {
+            BreakOnTargetMove = true,
+            BreakOnDamage = true,
+            BreakOnHandChange = false,
+            BreakOnUserMove = true,
+            BreakOnWeightlessMove = false,
+            NeedHand = true
+        });
+    }
+    private void OnChangeColorDoAfter(EntityUid uid, MagicMirrorComponent component, ChangeColorDoAfterEvent args)
+    {
+        if (args.Handled || args.Args.Target == null || args.Cancelled)
            return;
-        }
+        if (component.Target == null) return;

        var category = MarkingCategories.Hair;
-        switch (message.Category)
+        switch (args.Message.Category)
        {
            case MagicMirrorCategory.Hair:
                category = MarkingCategories.Hair;
@@ -80,22 +134,39 @@ public sealed class MagicMirrorSystem : EntitySystem
                return;
        }

-        _humanoid.SetMarkingColor(message.Session.AttachedEntity.Value, category, message.Slot, message.Colors);
+        _humanoid.SetMarkingColor(component.Target.Value.Owner, category, args.Message.Slot, args.Message.Colors);

        // using this makes the UI feel like total ass
-        // UpdateInterface(uid, message.Session.AttachedEntity.Value, message.Session);
+        // UpdateInterface(uid, component.Target, message.Session);
    }

-    private void OnMagicMirrorRemoveSlot(EntityUid uid, MagicMirrorComponent component,
-        MagicMirrorRemoveSlotMessage message)
+    private void OnTryMagicMirrorRemoveSlot(EntityUid uid, MagicMirrorComponent component, MagicMirrorRemoveSlotMessage message)
    {
-        if (message.Session.AttachedEntity == null || !TryComp<HumanoidAppearanceComponent>(message.Session.AttachedEntity.Value, out var humanoid))
+        if (component.Target == null) return;
+        if (message.Session.AttachedEntity == null) return;
+
+        var doAfter = new RemoveSlotDoAfterEvent(message);
+        _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, message.Session.AttachedEntity.Value, component.RemoveSlotTime, doAfter, uid, target: component.Target.Value.Owner, used: uid)
        {
+            BreakOnTargetMove = true,
+            BreakOnDamage = true,
+            BreakOnHandChange = false,
+            BreakOnUserMove = true,
+            BreakOnWeightlessMove = false,
+            NeedHand = true
+        });
+
+        _audio.PlayPvs(component.ChangeHairSound, uid);
+    }
+    private void OnRemoveSlotDoAfter(EntityUid uid, MagicMirrorComponent component, RemoveSlotDoAfterEvent args)
+    {
+        if (args.Handled || args.Args.Target == null || args.Cancelled)
            return;
-        }
+
+        if (component.Target == null) return;

        var category = MarkingCategories.Hair;
-        switch (message.Category)
+        switch (args.Message.Category)
        {
            case MagicMirrorCategory.Hair:
                category = MarkingCategories.Hair;
@@ -107,21 +178,37 @@ public sealed class MagicMirrorSystem : EntitySystem
                return;
        }

-        _humanoid.RemoveMarking(message.Session.AttachedEntity.Value, category, message.Slot);
+        _humanoid.RemoveMarking(component.Target.Value.Owner, category, args.Message.Slot);

-        UpdateInterface(uid, message.Session.AttachedEntity.Value, message.Session);
+        UpdateInterface(uid, component.Target.Value.Owner, args.Message.Session);
    }

-    private void OnMagicMirrorAddSlot(EntityUid uid, MagicMirrorComponent component,
-        MagicMirrorAddSlotMessage message)
+    private void OnTryMagicMirrorAddSlot(EntityUid uid, MagicMirrorComponent component, MagicMirrorAddSlotMessage message)
    {
-        if (message.Session.AttachedEntity == null || !TryComp<HumanoidAppearanceComponent>(message.Session.AttachedEntity.Value, out var humanoid))
+        if (component.Target == null) return;
+        if (message.Session.AttachedEntity == null) return;
+
+        var doAfter = new AddSlotDoAfterEvent(message);
+        _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, message.Session.AttachedEntity.Value, component.AddSlotTime, doAfter, uid, target: component.Target.Value.Owner, used: uid)
        {
+            BreakOnTargetMove = true,
+            BreakOnDamage = true,
+            BreakOnHandChange = false,
+            BreakOnUserMove = true,
+            BreakOnWeightlessMove = false,
+            NeedHand = true
+        });
+        _audio.PlayPvs(component.ChangeHairSound, uid);
+    }
+    private void OnAddSlotDoAfter(EntityUid uid, MagicMirrorComponent component, AddSlotDoAfterEvent args)
+    {
+        if (args.Handled || args.Args.Target == null || args.Cancelled)
            return;
-        }
+
+        if (component.Target == null) return;

        var category = MarkingCategories.Hair;
-        switch (message.Category)
+        switch (args.Message.Category)
        {
            case MagicMirrorCategory.Hair:
                category = MarkingCategories.Hair;
@@ -133,23 +220,21 @@ public sealed class MagicMirrorSystem : EntitySystem
                return;
        }

-        var marking = _markings.MarkingsByCategoryAndSpecies(category, humanoid.Species).Keys.FirstOrDefault();
+        var marking = _markings.MarkingsByCategoryAndSpecies(category, component.Target.Value.Comp.Species).Keys.FirstOrDefault();
        if (string.IsNullOrEmpty(marking))
        {
            return;
        }

-        _humanoid.AddMarking(message.Session.AttachedEntity.Value, marking, Color.Black);
+        _humanoid.AddMarking(component.Target.Value.Owner, marking, Color.Black);

-        UpdateInterface(uid, message.Session.AttachedEntity.Value, message.Session);
+        UpdateInterface(uid, component.Target.Value.Owner, args.Message.Session);
    }

-    private void UpdateInterface(EntityUid uid, EntityUid playerUid, ICommonSession session, HumanoidAppearanceComponent? humanoid = null)
+    private void UpdateInterface(EntityUid uid, EntityUid playerUid, ICommonSession session)
    {
-        if (!Resolve(playerUid, ref humanoid) || session is not { } player)
-        {
-            return;
-        }
+        if (!TryComp<HumanoidAppearanceComponent>(playerUid, out var humanoid)) return;
+        if (session is not { } player) return;

        var hair = humanoid.MarkingSet.TryGetCategory(MarkingCategories.Hair, out var hairMarkings)
            ? new List<Marking>(hairMarkings)
@@ -171,9 +256,9 @@ public sealed class MagicMirrorSystem : EntitySystem

    private void AfterUIOpen(EntityUid uid, MagicMirrorComponent component, AfterActivatableUIOpenEvent args)
    {
-        var looks = Comp<HumanoidAppearanceComponent>(args.User);
-        var actor = Comp<ActorComponent>(args.User);
+        if (!TryComp<HumanoidAppearanceComponent>(args.User, out var humanoid)) return;
+        component.Target = new Entity<HumanoidAppearanceComponent>(args.User, humanoid);

        UpdateInterface(uid, args.User, args.Session);
    }
-}
+}