tommy/tbd-station-14
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Barber scissors fix (#22895)

Browse Source 
* 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>
This commit is contained in:
Ed
2024-01-06 12:19:45 +03:00
committed by GitHub
parent 52aac0ea3b
commit f0097d4963
6 changed files with 190 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

192
Content.Server/MagicMirror/MagicMirrorSystem.cs
View File

@@ -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 OnMirrorRangeCheck(EntityUid uid, MagicMirrorComponent component, ref BoundUserInterfaceCheckRangeEvent args)
{
if (!Exists(component.Target) || !_interaction.InRangeUnobstructed(uid, component.Target.Value))
{
args.Result = BoundUserInterfaceRangeResult.Fail;
}
}
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}!");
};
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 SelectDoAfterEvent(message);
_doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, message.Session.AttachedEntity.Value, component.SelectSlotTime, doAfter, uid, target: component.Target.Value.Owner, used: uid)
var doAfter = new MagicMirrorSelectDoAfterEvent()
{
Category = message.Category,
Slot = message.Slot,
Marking = message.Marking,
};
_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)
{
if (args.Handled || args.Args.Target == null || args.Cancelled)
return;
if (component.Target == null) return;
var category = MarkingCategories.Hair;
switch (args.Message.Category)
private void OnSelectSlotDoAfter(EntityUid uid, MagicMirrorComponent component, MagicMirrorSelectDoAfterEvent args)
{
if (args.Handled || args.Target == null || args.Cancelled)
return;
if (component.Target != args.Target)
return;
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 == null) return;
var category = MarkingCategories.Hair;
switch (args.Message.Category)
if (component.Target != args.Target)
return;
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 RemoveSlotDoAfterEvent(message);
_doAfterSystem.TryStartDoAfter(new DoAfterArgs(EntityManager, message.Session.AttachedEntity.Value, component.RemoveSlotTime, doAfter, uid, target: component.Target.Value.Owner, used: uid)
var doAfter = new MagicMirrorRemoveSlotDoAfterEvent()
{
Category = message.Category,
Slot = message.Slot,
};
_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;
var category = MarkingCategories.Hair;
switch (args.Message.Category)
MarkingCategories 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;
}
}