Barber scissors fix (#22895)

* barber!

* 5% change to maintenance

* some fixes

* refactor some

* ElectroJR fix merge

* aoa

* remvoe humanoid

* Magic mirror cleanup

* Cleanup

* Bunch more fixes

* Fix nohair + range bugs

* Fixes

---------

Co-authored-by: metalgearsloth <comedian_vs_clown@hotmail.com>

diff --git a/Content.Client/MagicMirror/MagicMirrorBoundUserInterface.cs b/Content.Client/MagicMirror/MagicMirrorBoundUserInterface.cs
index ebb6780853ef83d466c576bd781a8f22c3ee9c9e..bfbf2efe4f96f0084754c94ed36f9d04e14c734e 100644 (file)
--- a/Content.Client/MagicMirror/MagicMirrorBoundUserInterface.cs
+++ b/Content.Client/MagicMirror/MagicMirrorBoundUserInterface.cs
@@ -30,6 +30,7 @@ public sealed class MagicMirrorBoundUserInterface : BoundUserInterface
         _window.OnFacialHairSlotAdded += delegate () { AddSlot(MagicMirrorCategory.FacialHair); };
         _window.OnFacialHairSlotRemoved += args => RemoveSlot(MagicMirrorCategory.FacialHair, args);
 
+        _window.OnClose += Close;
         _window.OpenCentered();
     }
 
@@ -53,17 +54,18 @@ public sealed class MagicMirrorBoundUserInterface : BoundUserInterface
         SendMessage(new MagicMirrorAddSlotMessage(category));
     }
 
-    protected override void ReceiveMessage(BoundUserInterfaceMessage message)
+    protected override void UpdateState(BoundUserInterfaceState state)
     {
-        base.ReceiveMessage(message);
+        base.UpdateState(state);
 
-        if (message is not MagicMirrorUiData data || _window == null)
+        if (state is not MagicMirrorUiState data || _window == null)
         {
             return;
         }
 
         _window.UpdateState(data);
     }
+
     protected override void Dispose(bool disposing)
     {
         base.Dispose(disposing);

diff --git a/Content.Client/MagicMirror/MagicMirrorWindow.xaml.cs b/Content.Client/MagicMirror/MagicMirrorWindow.xaml.cs
index 802f766341e0a936a0e8cf7b8a694581bb331328..e7f5ec343fd02f54c85f131eb303d890fc51a385 100644 (file)
--- a/Content.Client/MagicMirror/MagicMirrorWindow.xaml.cs
+++ b/Content.Client/MagicMirror/MagicMirrorWindow.xaml.cs
@@ -21,8 +21,6 @@ public sealed partial class MagicMirrorWindow : DefaultWindow
     public Action<int>? OnFacialHairSlotRemoved;
     public Action? OnFacialHairSlotAdded;
 
-    private bool _noHair;
-
     public MagicMirrorWindow()
     {
         RobustXamlLoader.Load(this);
@@ -38,15 +36,14 @@ public sealed partial class MagicMirrorWindow : DefaultWindow
         FacialHairPicker.OnSlotAdd += delegate { OnFacialHairSlotAdded!(); };
     }
 
-    public void UpdateState(MagicMirrorUiData state)
+    public void UpdateState(MagicMirrorUiState state)
     {
         HairPicker.UpdateData(state.Hair, state.Species, state.HairSlotTotal);
         FacialHairPicker.UpdateData(state.FacialHair, state.Species, state.FacialHairSlotTotal);
 
-        if (!HairPicker.Visible && !FacialHairPicker.Visible && !_noHair)
+        if (!HairPicker.Visible && !FacialHairPicker.Visible)
         {
             AddChild(new Label { Text = Loc.GetString("magic-mirror-component-activate-user-has-no-hair") });
-            _noHair = true;
         }
     }
 }

diff --git a/Content.Server/Interaction/InteractionSystem.cs b/Content.Server/Interaction/InteractionSystem.cs
index 8d4e8eb818a967c409c6b1527929e82ff9c8a072..6692886daeeccd4dc0889af6ca7ab39a88f8fc1b 100644 (file)
--- a/Content.Server/Interaction/InteractionSystem.cs
+++ b/Content.Server/Interaction/InteractionSystem.cs
@@ -48,7 +48,7 @@ namespace Content.Server.Interaction
 
         private void HandleUserInterfaceRangeCheck(ref BoundUserInterfaceCheckRangeEvent ev)
         {
-            if (ev.Player.AttachedEntity is not { } user)
+            if (ev.Player.AttachedEntity is not { } user || ev.Result == BoundUserInterfaceRangeResult.Fail)
                 return;
 
             if (InRangeUnobstructed(user, ev.Target, ev.UserInterface.InteractionRange))

diff --git a/Content.Server/MagicMirror/MagicMirrorComponent.cs b/Content.Server/MagicMirror/MagicMirrorComponent.cs
index b974b513cd9b74f45cffd6117e705a2b222282af..a9e72f577aa6a36411232fca86ea1ecb4c2b2cde 100644 (file)
--- a/Content.Server/MagicMirror/MagicMirrorComponent.cs
+++ b/Content.Server/MagicMirror/MagicMirrorComponent.cs
@@ -3,23 +3,45 @@ using Robust.Shared.Audio;
 
 namespace Content.Server.MagicMirror;
 
+/// <summary>
+/// Allows humanoids to change their appearance mid-round.
+/// </summary>
 [RegisterComponent]
 public sealed partial class MagicMirrorComponent : Component
 {
-    public Entity<HumanoidAppearanceComponent>? Target;
+    /// <summary>
+    /// Magic mirror target, used for validating UI messages.
+    /// </summary>
+    [DataField]
+    public EntityUid? Target;
 
+    /// <summary>
+    /// doafter time required to add a new slot
+    /// </summary>
     [DataField, ViewVariables(VVAccess.ReadWrite)]
-    public float AddSlotTime = 5f;
+    public TimeSpan AddSlotTime = TimeSpan.FromSeconds(5);
 
+    /// <summary>
+    /// doafter time required to remove a existing slot
+    /// </summary>
     [DataField, ViewVariables(VVAccess.ReadWrite)]
-    public float RemoveSlotTime = 2f;
+    public TimeSpan RemoveSlotTime = TimeSpan.FromSeconds(2);
 
+    /// <summary>
+    /// doafter time required to change slot
+    /// </summary>
     [DataField, ViewVariables(VVAccess.ReadWrite)]
-    public float SelectSlotTime = 3f;
+    public TimeSpan SelectSlotTime = TimeSpan.FromSeconds(3);
 
+    /// <summary>
+    /// doafter time required to recolor slot
+    /// </summary>
     [DataField, ViewVariables(VVAccess.ReadWrite)]
-    public float ChangeSlotTime = 1f;
+    public TimeSpan ChangeSlotTime = TimeSpan.FromSeconds(1);
 
+    /// <summary>
+    /// Sound emitted when slots are changed
+    /// </summary>
     [DataField, ViewVariables(VVAccess.ReadWrite)]
     public SoundSpecifier ChangeHairSound = new SoundPathSpecifier("/Audio/Items/scissors.ogg");
 }

diff --git a/Content.Server/MagicMirror/MagicMirrorSystem.cs b/Content.Server/MagicMirror/MagicMirrorSystem.cs
index eb989eafd61842fa5b82cdc7473ba603b9f74d1c..6b3fe98d7884b30999f4b59078fa5b9847af816a 100644 (file)
--- a/Content.Server/MagicMirror/MagicMirrorSystem.cs
+++ b/Content.Server/MagicMirror/MagicMirrorSystem.cs
@@ -13,20 +13,23 @@ using Robust.Shared.Player;
 
 namespace Content.Server.MagicMirror;
 
+/// <summary>
+/// Allows humanoids to change their appearance mid-round.
+/// </summary>
 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 SharedInteractionSystem _interaction = default!;
     [Dependency] private readonly UserInterfaceSystem _uiSystem = default!;
 
-
     public override void Initialize()
     {
         base.Initialize();
         SubscribeLocalEvent<MagicMirrorComponent, ActivatableUIOpenAttemptEvent>(OnOpenUIAttempt);
-        SubscribeLocalEvent<MagicMirrorComponent, AfterActivatableUIOpenEvent>(AfterUIOpen);
+        SubscribeLocalEvent<MagicMirrorComponent, BoundUIClosedEvent>(OnUIClosed);
         SubscribeLocalEvent<MagicMirrorComponent, MagicMirrorSelectMessage>(OnMagicMirrorSelect);
         SubscribeLocalEvent<MagicMirrorComponent, MagicMirrorChangeColorMessage>(OnTryMagicMirrorChangeColor);
         SubscribeLocalEvent<MagicMirrorComponent, MagicMirrorAddSlotMessage>(OnTryMagicMirrorAddSlot);
@@ -34,21 +37,34 @@ public sealed class MagicMirrorSystem : EntitySystem
 
         SubscribeLocalEvent<MagicMirrorComponent, AfterInteractEvent>(OnMagicMirrorInteract);
 
-        SubscribeLocalEvent<MagicMirrorComponent, SelectDoAfterEvent>(OnSelectSlotDoAfter);
-        SubscribeLocalEvent<MagicMirrorComponent, ChangeColorDoAfterEvent>(OnChangeColorDoAfter);
-        SubscribeLocalEvent<MagicMirrorComponent, RemoveSlotDoAfterEvent>(OnRemoveSlotDoAfter);
-        SubscribeLocalEvent<MagicMirrorComponent, AddSlotDoAfterEvent>(OnAddSlotDoAfter);
+        SubscribeLocalEvent<MagicMirrorComponent, MagicMirrorSelectDoAfterEvent>(OnSelectSlotDoAfter);
+        SubscribeLocalEvent<MagicMirrorComponent, MagicMirrorChangeColorDoAfterEvent>(OnChangeColorDoAfter);
+        SubscribeLocalEvent<MagicMirrorComponent, MagicMirrorRemoveSlotDoAfterEvent>(OnRemoveSlotDoAfter);
+        SubscribeLocalEvent<MagicMirrorComponent, MagicMirrorAddSlotDoAfterEvent>(OnAddSlotDoAfter);
+
+        SubscribeLocalEvent<MagicMirrorComponent, BoundUserInterfaceCheckRangeEvent>(OnMirrorRangeCheck);
     }
 
-    private void OnMagicMirrorInteract(Entity<MagicMirrorComponent> mirror, ref AfterInteractEvent args)
+    private void OnMirrorRangeCheck(EntityUid uid, MagicMirrorComponent component, ref BoundUserInterfaceCheckRangeEvent args)
     {
-        if (!TryComp<ActorComponent>(args.User, out var actor)) return;
-        if (TryComp<HumanoidAppearanceComponent>(args.Target, out var humanoid))
+        if (!Exists(component.Target) || !_interaction.InRangeUnobstructed(uid, component.Target.Value))
         {
-            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}!");
-        };
+            args.Result = BoundUserInterfaceRangeResult.Fail;
+        }
+    }
+
+    private void OnMagicMirrorInteract(Entity<MagicMirrorComponent> mirror, ref AfterInteractEvent args)
+    {
+        if (!args.CanReach || args.Target == null)
+            return;
+
+        if (!TryComp<ActorComponent>(args.User, out var actor))
+            return;
+
+        if (!_uiSystem.TryOpen(mirror.Owner, MagicMirrorUiKey.Key, actor.PlayerSession))
+            return;
+
+        UpdateInterface(mirror.Owner, args.Target.Value, mirror.Comp);
     }
 
     private void OnOpenUIAttempt(EntityUid uid, MagicMirrorComponent mirror, ActivatableUIOpenAttemptEvent args)
@@ -59,12 +75,19 @@ public sealed class MagicMirrorSystem : EntitySystem
 
     private void OnMagicMirrorSelect(EntityUid uid, MagicMirrorComponent component, MagicMirrorSelectMessage message)
     {
-        if (component.Target == null) return;
-        if (message.Session.AttachedEntity == null) return;
+        if (component.Target is not { } target || message.Session.AttachedEntity is not { } user)
+            return;
+
+        var doAfter = new MagicMirrorSelectDoAfterEvent()
+        {
+            Category = message.Category,
+            Slot = message.Slot,
+            Marking = message.Marking,
+        };
 
-        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)
+        _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, user, component.SelectSlotTime, doAfter, uid, target: target, used: uid)
         {
+            DistanceThreshold = SharedInteractionSystem.InteractionRange,
             BreakOnTargetMove = true,
             BreakOnDamage = true,
             BreakOnHandChange = false,
@@ -75,14 +98,18 @@ public sealed class MagicMirrorSystem : EntitySystem
 
         _audio.PlayPvs(component.ChangeHairSound, uid);
     }
-    private void OnSelectSlotDoAfter(EntityUid uid, MagicMirrorComponent component, SelectDoAfterEvent args)
+
+    private void OnSelectSlotDoAfter(EntityUid uid, MagicMirrorComponent component, MagicMirrorSelectDoAfterEvent args)
     {
-        if (args.Handled || args.Args.Target == null || args.Cancelled)
+        if (args.Handled || args.Target == null || args.Cancelled)
+            return;
+
+        if (component.Target != args.Target)
             return;
-        if (component.Target == null) return;
 
-        var category = MarkingCategories.Hair;
-        switch (args.Message.Category)
+        MarkingCategories category;
+
+        switch (args.Category)
         {
             case MagicMirrorCategory.Hair:
                 category = MarkingCategories.Hair;
@@ -94,18 +121,24 @@ public sealed class MagicMirrorSystem : EntitySystem
                 return;
         }
 
-        _humanoid.SetMarkingId(component.Target.Value.Owner, category, args.Message.Slot, args.Message.Marking);
+        _humanoid.SetMarkingId(component.Target.Value, category, args.Slot, args.Marking);
 
-        UpdateInterface(uid, component.Target.Value.Owner, args.Message.Session);
+        UpdateInterface(uid, component.Target.Value, component);
     }
 
     private void OnTryMagicMirrorChangeColor(EntityUid uid, MagicMirrorComponent component, MagicMirrorChangeColorMessage message)
     {
-        if (component.Target == null) return;
-        if (message.Session.AttachedEntity == null) return;
+        if (component.Target is not { } target || message.Session.AttachedEntity is not { } user)
+            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)
+        var doAfter = new MagicMirrorChangeColorDoAfterEvent()
+        {
+            Category = message.Category,
+            Slot = message.Slot,
+            Colors = message.Colors,
+        };
+
+        _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, user, component.ChangeSlotTime, doAfter, uid, target: target, used: uid)
         {
             BreakOnTargetMove = true,
             BreakOnDamage = true,
@@ -115,14 +148,16 @@ public sealed class MagicMirrorSystem : EntitySystem
             NeedHand = true
         });
     }
-    private void OnChangeColorDoAfter(EntityUid uid, MagicMirrorComponent component, ChangeColorDoAfterEvent args)
+    private void OnChangeColorDoAfter(EntityUid uid, MagicMirrorComponent component, MagicMirrorChangeColorDoAfterEvent args)
     {
-        if (args.Handled || args.Args.Target == null || args.Cancelled)
+        if (args.Handled || args.Target == null || args.Cancelled)
+            return;
+
+        if (component.Target != args.Target)
             return;
-        if (component.Target == null) return;
 
-        var category = MarkingCategories.Hair;
-        switch (args.Message.Category)
+        MarkingCategories category;
+        switch (args.Category)
         {
             case MagicMirrorCategory.Hair:
                 category = MarkingCategories.Hair;
@@ -134,20 +169,27 @@ public sealed class MagicMirrorSystem : EntitySystem
                 return;
         }
 
-        _humanoid.SetMarkingColor(component.Target.Value.Owner, category, args.Message.Slot, args.Message.Colors);
+        _humanoid.SetMarkingColor(component.Target.Value, category, args.Slot, args.Colors);
 
         // using this makes the UI feel like total ass
+        // que
         // UpdateInterface(uid, component.Target, message.Session);
     }
 
     private void OnTryMagicMirrorRemoveSlot(EntityUid uid, MagicMirrorComponent component, MagicMirrorRemoveSlotMessage message)
     {
-        if (component.Target == null) return;
-        if (message.Session.AttachedEntity == null) return;
+        if (component.Target is not { } target || message.Session.AttachedEntity is not { } user)
+            return;
+
+        var doAfter = new MagicMirrorRemoveSlotDoAfterEvent()
+        {
+            Category = message.Category,
+            Slot = message.Slot,
+        };
 
-        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)
+        _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, user, component.RemoveSlotTime, doAfter, uid, target: target, used: uid)
         {
+            DistanceThreshold = SharedInteractionSystem.InteractionRange,
             BreakOnTargetMove = true,
             BreakOnDamage = true,
             BreakOnHandChange = false,
@@ -158,15 +200,18 @@ public sealed class MagicMirrorSystem : EntitySystem
 
         _audio.PlayPvs(component.ChangeHairSound, uid);
     }
-    private void OnRemoveSlotDoAfter(EntityUid uid, MagicMirrorComponent component, RemoveSlotDoAfterEvent args)
+
+    private void OnRemoveSlotDoAfter(EntityUid uid, MagicMirrorComponent component, MagicMirrorRemoveSlotDoAfterEvent args)
     {
-        if (args.Handled || args.Args.Target == null || args.Cancelled)
+        if (args.Handled || args.Target == null || args.Cancelled)
             return;
 
-        if (component.Target == null) return;
+        if (component.Target != args.Target)
+            return;
+
+        MarkingCategories category;
 
-        var category = MarkingCategories.Hair;
-        switch (args.Message.Category)
+        switch (args.Category)
         {
             case MagicMirrorCategory.Hair:
                 category = MarkingCategories.Hair;
@@ -178,18 +223,25 @@ public sealed class MagicMirrorSystem : EntitySystem
                 return;
         }
 
-        _humanoid.RemoveMarking(component.Target.Value.Owner, category, args.Message.Slot);
+        _humanoid.RemoveMarking(component.Target.Value, category, args.Slot);
 
-        UpdateInterface(uid, component.Target.Value.Owner, args.Message.Session);
+        UpdateInterface(uid, component.Target.Value, component);
     }
 
     private void OnTryMagicMirrorAddSlot(EntityUid uid, MagicMirrorComponent component, MagicMirrorAddSlotMessage message)
     {
-        if (component.Target == null) return;
-        if (message.Session.AttachedEntity == null) return;
+        if (component.Target == 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)
+        if (message.Session.AttachedEntity == null)
+            return;
+
+        var doAfter = new MagicMirrorAddSlotDoAfterEvent()
+        {
+            Category = message.Category,
+        };
+
+        _doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, message.Session.AttachedEntity.Value, component.AddSlotTime, doAfter, uid, target: component.Target.Value, used: uid)
         {
             BreakOnTargetMove = true,
             BreakOnDamage = true,
@@ -198,17 +250,17 @@ public sealed class MagicMirrorSystem : EntitySystem
             BreakOnWeightlessMove = false,
             NeedHand = true
         });
+
         _audio.PlayPvs(component.ChangeHairSound, uid);
     }
-    private void OnAddSlotDoAfter(EntityUid uid, MagicMirrorComponent component, AddSlotDoAfterEvent args)
+    private void OnAddSlotDoAfter(EntityUid uid, MagicMirrorComponent component, MagicMirrorAddSlotDoAfterEvent args)
     {
-        if (args.Handled || args.Args.Target == null || args.Cancelled)
+        if (args.Handled || args.Target == null || args.Cancelled || !TryComp(component.Target, out HumanoidAppearanceComponent? humanoid))
             return;
 
-        if (component.Target == null) return;
+        MarkingCategories category;
 
-        var category = MarkingCategories.Hair;
-        switch (args.Message.Category)
+        switch (args.Category)
         {
             case MagicMirrorCategory.Hair:
                 category = MarkingCategories.Hair;
@@ -220,21 +272,21 @@ public sealed class MagicMirrorSystem : EntitySystem
                 return;
         }
 
-        var marking = _markings.MarkingsByCategoryAndSpecies(category, component.Target.Value.Comp.Species).Keys.FirstOrDefault();
+        var marking = _markings.MarkingsByCategoryAndSpecies(category, humanoid.Species).Keys.FirstOrDefault();
+
         if (string.IsNullOrEmpty(marking))
-        {
             return;
-        }
 
-        _humanoid.AddMarking(component.Target.Value.Owner, marking, Color.Black);
+        _humanoid.AddMarking(component.Target.Value, marking, Color.Black);
+
+        UpdateInterface(uid, component.Target.Value, component);
 
-        UpdateInterface(uid, component.Target.Value.Owner, args.Message.Session);
     }
 
-    private void UpdateInterface(EntityUid uid, EntityUid playerUid, ICommonSession session)
+    private void UpdateInterface(EntityUid mirrorUid, EntityUid targetUid, MagicMirrorComponent component)
     {
-        if (!TryComp<HumanoidAppearanceComponent>(playerUid, out var humanoid)) return;
-        if (session is not { } player) return;
+        if (!TryComp<HumanoidAppearanceComponent>(targetUid, out var humanoid))
+            return;
 
         var hair = humanoid.MarkingSet.TryGetCategory(MarkingCategories.Hair, out var hairMarkings)
             ? new List<Marking>(hairMarkings)
@@ -244,21 +296,19 @@ public sealed class MagicMirrorSystem : EntitySystem
             ? new List<Marking>(facialHairMarkings)
             : new();
 
-        var msg = new MagicMirrorUiData(
+        var state = new MagicMirrorUiState(
             humanoid.Species,
             hair,
             humanoid.MarkingSet.PointsLeft(MarkingCategories.Hair) + hair.Count,
             facialHair,
             humanoid.MarkingSet.PointsLeft(MarkingCategories.FacialHair) + facialHair.Count);
 
-        _uiSystem.TrySendUiMessage(uid, MagicMirrorUiKey.Key, msg, player);
+        component.Target = targetUid;
+        _uiSystem.TrySetUiState(mirrorUid, MagicMirrorUiKey.Key, state);
     }
 
-    private void AfterUIOpen(EntityUid uid, MagicMirrorComponent component, AfterActivatableUIOpenEvent args)
+    private void OnUIClosed(Entity<MagicMirrorComponent> ent, ref BoundUIClosedEvent args)
     {
-        if (!TryComp<HumanoidAppearanceComponent>(args.User, out var humanoid)) return;
-        component.Target = new Entity<HumanoidAppearanceComponent>(args.User, humanoid);
-
-        UpdateInterface(uid, args.User, args.Session);
+        ent.Comp.Target = null;
     }
 }

diff --git a/Content.Shared/MagicMirror/SharedMagicMirrorSystem.cs b/Content.Shared/MagicMirror/SharedMagicMirrorSystem.cs
index 7d389c90e02a96623e7b813314063840525436e5..0b22e024982e4b534a5a08a8360b4392503c78be 100644 (file)
--- a/Content.Shared/MagicMirror/SharedMagicMirrorSystem.cs
+++ b/Content.Shared/MagicMirror/SharedMagicMirrorSystem.cs
@@ -1,17 +1,18 @@
 using Content.Shared.DoAfter;
 using Content.Shared.Humanoid.Markings;
+using Robust.Shared.Player;
 using Robust.Shared.Serialization;
 
 namespace Content.Shared.MagicMirror;
 
 [Serializable, NetSerializable]
-public enum MagicMirrorUiKey
+public enum MagicMirrorUiKey : byte
 {
     Key
 }
 
 [Serializable, NetSerializable]
-public enum MagicMirrorCategory
+public enum MagicMirrorCategory : byte
 {
     Hair,
     FacialHair
@@ -85,9 +86,9 @@ public sealed class MagicMirrorAddSlotMessage : BoundUserInterfaceMessage
 }
 
 [Serializable, NetSerializable]
-public sealed class MagicMirrorUiData : BoundUserInterfaceMessage
+public sealed class MagicMirrorUiState : BoundUserInterfaceState
 {
-    public MagicMirrorUiData(string species, List<Marking> hair, int hairSlotTotal, List<Marking> facialHair, int facialHairSlotTotal)
+    public MagicMirrorUiState(string species, List<Marking> hair, int hairSlotTotal, List<Marking> facialHair, int facialHairSlotTotal)
     {
         Species = species;
         Hair = hair;
@@ -96,60 +97,47 @@ public sealed class MagicMirrorUiData : BoundUserInterfaceMessage
         FacialHairSlotTotal = facialHairSlotTotal;
     }
 
-    public string Species { get; }
+    public NetEntity Target;
 
-    public List<Marking> Hair { get; }
-    public int HairSlotTotal { get; }
+    public string Species;
 
-    public List<Marking> FacialHair { get; }
-    public int FacialHairSlotTotal { get; }
+    public List<Marking> Hair;
+    public int HairSlotTotal;
 
+    public List<Marking> FacialHair;
+    public int FacialHairSlotTotal;
 }
 
 [Serializable, NetSerializable]
-public sealed partial class RemoveSlotDoAfterEvent : DoAfterEvent
+public sealed partial class MagicMirrorRemoveSlotDoAfterEvent : DoAfterEvent
 {
-    public MagicMirrorRemoveSlotMessage Message;
-
-    public RemoveSlotDoAfterEvent(MagicMirrorRemoveSlotMessage message)
-    {
-        Message = message;
-    }
     public override DoAfterEvent Clone() => this;
+    public MagicMirrorCategory Category;
+    public int Slot;
 }
 
 [Serializable, NetSerializable]
-public sealed partial class AddSlotDoAfterEvent : DoAfterEvent
+public sealed partial class MagicMirrorAddSlotDoAfterEvent : DoAfterEvent
 {
-    public MagicMirrorAddSlotMessage Message;
-
-    public AddSlotDoAfterEvent(MagicMirrorAddSlotMessage message)
-    {
-        Message = message;
-    }
     public override DoAfterEvent Clone() => this;
+    public MagicMirrorCategory Category;
 }
 
 [Serializable, NetSerializable]
-public sealed partial class SelectDoAfterEvent : DoAfterEvent
+public sealed partial class MagicMirrorSelectDoAfterEvent : DoAfterEvent
 {
-    public MagicMirrorSelectMessage Message;
+    public MagicMirrorCategory Category;
+    public int Slot;
+    public string Marking = string.Empty;
 
-    public SelectDoAfterEvent(MagicMirrorSelectMessage message)
-    {
-        Message = message;
-    }
     public override DoAfterEvent Clone() => this;
 }
 
 [Serializable, NetSerializable]
-public sealed partial class ChangeColorDoAfterEvent : DoAfterEvent
+public sealed partial class MagicMirrorChangeColorDoAfterEvent : DoAfterEvent
 {
-    public MagicMirrorChangeColorMessage Message;
-
-    public ChangeColorDoAfterEvent(MagicMirrorChangeColorMessage message)
-    {
-        Message = message;
-    }
     public override DoAfterEvent Clone() => this;
+    public MagicMirrorCategory Category;
+    public int Slot;
+    public List<Color> Colors = new List<Color>();
 }