Fix humanoid appearances for placement manager (#18291)

Content.Shared/Humanoid/SharedHumanoidAppearanceSystem.cs

@@ -4,6 +4,9 @@ using Robust.Shared.GameStates;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Utility;
 using System.Linq;
+using Content.Shared.Preferences;
+using Robust.Shared.GameObjects.Components.Localization;
+using Robust.Shared.Network;
 
 namespace Content.Shared.Humanoid;
 
@@ -18,6 +21,7 @@ namespace Content.Shared.Humanoid;
 /// </summary>
 public abstract class SharedHumanoidAppearanceSystem : EntitySystem
 {
+    [Dependency] private readonly INetManager _netManager = default!;
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
     [Dependency] private readonly MarkingManager _markingManager = default!;
 
@@ -26,9 +30,33 @@ public abstract class SharedHumanoidAppearanceSystem : EntitySystem
     public override void Initialize()
     {
         base.Initialize();
+        SubscribeLocalEvent<HumanoidAppearanceComponent, ComponentInit>(OnInit);
         SubscribeLocalEvent<HumanoidAppearanceComponent, ComponentGetState>(OnGetState);
     }
 
+    private void OnInit(EntityUid uid, HumanoidAppearanceComponent humanoid, ComponentInit args)
+    {
+        if (string.IsNullOrEmpty(humanoid.Species) || _netManager.IsClient && !uid.IsClientSide())
+        {
+            return;
+        }
+
+        if (string.IsNullOrEmpty(humanoid.Initial)
+            || !_prototypeManager.TryIndex(humanoid.Initial, out HumanoidProfilePrototype? startingSet))
+        {
+            LoadProfile(uid, HumanoidCharacterProfile.DefaultWithSpecies(humanoid.Species), humanoid);
+            return;
+        }
+
+        // Do this first, because profiles currently do not support custom base layers
+        foreach (var (layer, info) in startingSet.CustomBaseLayers)
+        {
+            humanoid.CustomBaseLayers.Add(layer, info);
+        }
+
+        LoadProfile(uid, startingSet.Profile, humanoid);
+    }
+
     private void OnGetState(EntityUid uid, HumanoidAppearanceComponent component, ref ComponentGetState args)
     {
         args.State = new HumanoidAppearanceState(component.MarkingSet,
@@ -233,4 +261,155 @@ public abstract class SharedHumanoidAppearanceSystem : EntitySystem
             Dirty(humanoid);
         }
     }
+
+    /// <summary>
+    ///     Loads a humanoid character profile directly onto this humanoid mob.
+    /// </summary>
+    /// <param name="uid">The mob's entity UID.</param>
+    /// <param name="profile">The character profile to load.</param>
+    /// <param name="humanoid">Humanoid component of the entity</param>
+    public virtual void LoadProfile(EntityUid uid, HumanoidCharacterProfile profile, HumanoidAppearanceComponent? humanoid = null)
+    {
+        if (!Resolve(uid, ref humanoid))
+        {
+            return;
+        }
+
+        SetSpecies(uid, profile.Species, false, humanoid);
+        SetSex(uid, profile.Sex, false, humanoid);
+        humanoid.EyeColor = profile.Appearance.EyeColor;
+
+        SetSkinColor(uid, profile.Appearance.SkinColor, false);
+
+        humanoid.MarkingSet.Clear();
+
+        // Add markings that doesn't need coloring. We store them until we add all other markings that doesn't need it.
+        var markingFColored = new Dictionary<Marking, MarkingPrototype>();
+        foreach (var marking in profile.Appearance.Markings)
+        {
+            if (_markingManager.TryGetMarking(marking, out var prototype))
+            {
+                if (!prototype.ForcedColoring)
+                {
+                    AddMarking(uid, marking.MarkingId, marking.MarkingColors, false);
+                }
+                else
+                {
+                    markingFColored.Add(marking, prototype);
+                }
+            }
+        }
+
+        // Hair/facial hair - this may eventually be deprecated.
+        // We need to ensure hair before applying it or coloring can try depend on markings that can be invalid
+        var hairColor = _markingManager.MustMatchSkin(profile.Species, HumanoidVisualLayers.Hair, out var hairAlpha, _prototypeManager)
+            ? profile.Appearance.SkinColor.WithAlpha(hairAlpha) : profile.Appearance.HairColor;
+        var facialHairColor = _markingManager.MustMatchSkin(profile.Species, HumanoidVisualLayers.FacialHair, out var facialHairAlpha, _prototypeManager)
+            ? profile.Appearance.SkinColor.WithAlpha(facialHairAlpha) : profile.Appearance.FacialHairColor;
+
+        if (_markingManager.Markings.TryGetValue(profile.Appearance.HairStyleId, out var hairPrototype) &&
+            _markingManager.CanBeApplied(profile.Species, hairPrototype, _prototypeManager))
+        {
+            AddMarking(uid, profile.Appearance.HairStyleId, hairColor, false);
+        }
+
+        if (_markingManager.Markings.TryGetValue(profile.Appearance.FacialHairStyleId, out var facialHairPrototype) &&
+            _markingManager.CanBeApplied(profile.Species, facialHairPrototype, _prototypeManager))
+        {
+            AddMarking(uid, profile.Appearance.FacialHairStyleId, facialHairColor, false);
+        }
+
+        humanoid.MarkingSet.EnsureSpecies(profile.Species, profile.Appearance.SkinColor, _markingManager, _prototypeManager);
+
+        // Finally adding marking with forced colors
+        foreach (var (marking, prototype) in markingFColored)
+        {
+            var markingColors = MarkingColoring.GetMarkingLayerColors(
+                prototype,
+                profile.Appearance.SkinColor,
+                profile.Appearance.EyeColor,
+                humanoid.MarkingSet
+            );
+            AddMarking(uid, marking.MarkingId, markingColors, false);
+        }
+
+        EnsureDefaultMarkings(uid, humanoid);
+
+        humanoid.Gender = profile.Gender;
+        if (TryComp<GrammarComponent>(uid, out var grammar))
+        {
+            grammar.Gender = profile.Gender;
+        }
+
+        humanoid.Age = profile.Age;
+
+        Dirty(humanoid);
+    }
+
+    /// <summary>
+    ///     Adds a marking to this humanoid.
+    /// </summary>
+    /// <param name="uid">Humanoid mob's UID</param>
+    /// <param name="marking">Marking ID to use</param>
+    /// <param name="color">Color to apply to all marking layers of this marking</param>
+    /// <param name="sync">Whether to immediately sync this marking or not</param>
+    /// <param name="forced">If this marking was forced (ignores marking points)</param>
+    /// <param name="humanoid">Humanoid component of the entity</param>
+    public void AddMarking(EntityUid uid, string marking, Color? color = null, bool sync = true, bool forced = false, HumanoidAppearanceComponent? humanoid = null)
+    {
+        if (!Resolve(uid, ref humanoid)
+            || !_markingManager.Markings.TryGetValue(marking, out var prototype))
+        {
+            return;
+        }
+
+        var markingObject = prototype.AsMarking();
+        markingObject.Forced = forced;
+        if (color != null)
+        {
+            for (var i = 0; i < prototype.Sprites.Count; i++)
+            {
+                markingObject.SetColor(i, color.Value);
+            }
+        }
+
+        humanoid.MarkingSet.AddBack(prototype.MarkingCategory, markingObject);
+
+        if (sync)
+            Dirty(humanoid);
+    }
+
+    private void EnsureDefaultMarkings(EntityUid uid, HumanoidAppearanceComponent? humanoid)
+    {
+        if (!Resolve(uid, ref humanoid))
+        {
+            return;
+        }
+        humanoid.MarkingSet.EnsureDefault(humanoid.SkinColor, humanoid.EyeColor, _markingManager);
+    }
+
+    /// <summary>
+    ///
+    /// </summary>
+    /// <param name="uid">Humanoid mob's UID</param>
+    /// <param name="marking">Marking ID to use</param>
+    /// <param name="colors">Colors to apply against this marking's set of sprites.</param>
+    /// <param name="sync">Whether to immediately sync this marking or not</param>
+    /// <param name="forced">If this marking was forced (ignores marking points)</param>
+    /// <param name="humanoid">Humanoid component of the entity</param>
+    public void AddMarking(EntityUid uid, string marking, IReadOnlyList<Color> colors, bool sync = true, bool forced = false, HumanoidAppearanceComponent? humanoid = null)
+    {
+        if (!Resolve(uid, ref humanoid)
+            || !_markingManager.Markings.TryGetValue(marking, out var prototype))
+        {
+            return;
+        }
+
+        var markingObject = new Marking(marking, colors);
+        markingObject.Forced = forced;
+        humanoid.MarkingSet.AddBack(prototype.MarkingCategory, markingObject);
+
+        if (sync)
+            Dirty(humanoid);
+    }
 }