Humanoid appearance refactor (#10882)

* initial commit
- species prototype modifications
- markings points as its own file
- shared humanoid component

* adds a tool to convert sprite accessories to markings (in go)

* removes a fmt call

* converts sprite accessory to markings

* adds hair and facial hair to marking categories

* multiple changes
- humanoid visualizer system
- markings modifications for visualizer
- modifications to shared humanoid component
- lays out a base for humanoid system

* hidden layers, ports some properties from appearance component, shrinks DefaultMarkings a little

* squishes the initialize event calls into one function

adds stuff to set species/skin color externally from a server message - currently laid out as if it a dirty call to a networked component, may be subject to change (server-side has not been implemented yet)

* makes the sprite pipeline more obvious

* apply all markings, hidden layer set replacement

* ensures that markings are cleared when the new set is applied

* starts refactoring markingsset (unfinished)

* more additions to the markingset api

* adds constructor logic to markingset

* adds a method to filter out markings in a set based on a given species

* fixes enumerators in markingset

* adds validator into MarkingSet, fixes ForwardMarkingEnumerator

* modifications to the humanoid visual system

* ensuredefault in markingset

* oop

* fixes up data keys, populates OnAppearanceChange in visualizer

* changes to humanoid component, markings

marking equality is now more strict, humanoidcomponent is now implemented for client as a child of sharedhumanoidcomponent

* markings are now applied the visualizer by diffing them

* base sprites are now applied to humanoids from humanoidvisualizer

* passes along base sprite settings to the marking application so that markings know to follow skin color/alpha or not (see: slimes)

* custom base layers on humanoids

* merges all data keys into one data class for humanoid visualizers

* setappearance in sharedhumanoidsystem, removes custombaselayercolors

* humanoidcomponent, system (empty) in server

* adds some basic public API functions to HumanoidSystem

* add marking, remove marking

* changes appearance MarkingsSet to a List<Marking>, adds listener for PlayerSpawnCompleteEvent in HumanoidSystem

* ensuredefaultmarkings, oninit for humanoids

* markingmanager API changes

* removes MarkingsSet

* LoadProfile, adjusts randomization in humanoid appearance to account for species

* base layer settings in humanoidsystem, eye color from profile

* rearranges files to centralize under Humanoid namespace

* more reorganization, deletes some stuff

gotta break stuff to make other things work, right?

goodbye SpriteAccessory...

* fixes a good chunk of server-side issues

still does not compile, yet

* singlemarkingpicker xaml layout

* singlemarkingpicker logic

* magic mirror window (varying pieces of it, mostly client-oriented)

* removes some imports, gives MagicMirror a BUI class (not filled in yet)

* populates magic mirror BUI functionality / window callbacks

* fixes up some errors in humanoidprofileeditor

* changes to SingleMarkingPicker

SingleMarkingPicker now accepts a List<Marking>, species, and total possible markings available in that marking category

* fixes up hair pickers on humanoid profile editor

* fixes the errors in markingpicker

* markingsystem is now gone

* fixes a bunch of build errors

* so that's why i did it like that

* namespace issues, adds robustxamlloader to singlemarkingpicker

* another robustxamlloader

* human, lizard sprites/points

* prototype fixes, deletion of old spriteaccessory

* component registration, fixes dwarf skin toning

no, 'ReptilianToned' does not exist

* removes component registration from abstract humanoid component

* visualizer data now cloneable

* serialize for visualizer key

* zero-count edge case

* missing semi-colon moment

* setspecies in humanoidsystem

* ensures that default markings, if empty, will cause ensuredefault to skip over that given category

* tryadd instead of add

* whoops

* diff and apply should properly apply markings now

* always ensure default, fixes double load for player spawning

* apply skin color now sets the skin color property in humanoidcomponent

* removes sprite from a few species prototypes

* sprite changes for specific base layers based on humanoid sex

* layer ordering fix, and a missing base layer should now disallow markings on that layer

* anymarking base layer, adds the right leg/foot for humans

* loading a profile will now clear all markings on that humanoid

* adds missing layers for humans

* separates species.yml into respective species prototype files

* ensures that if layer visibility was changed, all markings have to be reapplied

* server-side enforcement of hiding hair (and other head-related markings) when equipping things that hide hair

* slime fix, clothingsystem now dictates layer visibility server side

* sussy

* layer settings should now ensure a marking should match the skin tone

* whoops

* skincolor static class and functions in UI

* skin color validation in humanoidcharacterappearance

* markingpicker now shows only the markings for the selected category in used

* getter for slot in singlemarkingpicker now ensures slot is 0 if markings exists

* FilterSpecies no longer attempts to do removal while iterating

* expands for SingleMarkingPicker

* humanoid base dummy has blank layers now (and snout/tail/headside/headtop)

* fixes an issue with visualizer system if the marking count was different but the markings themselves were (somewhat) the same

* whoops

* adds edge case handlers for count differences in humanoid markings

* preview now loads profile instead of directly setting appearance

* moves marking set loading to update controls

* clones a marking set in markingpicker by using the deep clone constructor

* whoops (deep cloning a marking now copies the marking id)

* adds replace function for markingset

* points should now update after the markings are remove/added

* merging base layer sprites into a humanoid should now clear them before merging

* sets dirty range start to count only if the dirty range start was never set above 0

* fixes up some issues with singlemarkingpicker

* color selector sliders in single marking picker should now expand

* hair from hair pickers should now apply in profile loading (client-side)

* category in singlemarkingpicker now sets the private category variable

* slot selector should now populate

* single marking picker buttons now have text, also shows the category name over all user-clickable elements

* removes a comment

* removing hair slots now sets it to bald, defaults to zero used slots if current hair is bald on hair/facial hair

* random skin color, eye color

* populate colors now checks if the marking count is greater than zero in singlemarkingpicker

* hair/facial hair pickers now just get the first possible hair from the respective species list

* different approach to random skin color

* oh, that's why it wasn't working

* randomize everything now just updates every single control

* selecting a new marking in SingleMarkingPicker should attempt to copy over old colors, populate list now uses cache,

* markingmanager now uses OnlyWhitelisted to populate by category and species

* filterspecies now uses onlyWhitelist to filter markings based on whitelist or not

* oops

* ui fix for singlemarkingpicker, ensures that cache is not null if it is null when populatelist is called

* order of operations for the horizontal expand for add/remove

* hair pickers should now update when you add/remove the hair slot

* fixes variable naming error in character appearance

* loc string fix in singlemarkingpicker

* lizards, vox now have onlyWhitelist, vox restriction for hair/facialhairs

* having zero possible hairs should no longer cause an exception in randomization

* setting species should now update hair pickers

* ignore categories for marking picker

* and a clear as well for the category button

* places that functionality in its own function instead

* adds eye base sprite, vox now also have their own custom eye sprites

* loading a profile client-side should do FilterSpecies for markings now

* client-side load profile does filter species after adding in the hairs now

* magic mirror

* callbacks now call the callback instead of adding it on construct

* whoops

* in removemarking too

* adds missing synchronize calls

* comments out an updateinterface call in magic mirror

* magic mirror window title, minimum sizing

* fixes minsize, adds warning for players who try to set their hair for species that have no hair

* removes spaces in xaml

* namespace changes/organization

* whoopsie (merge conflicts)

* re-enables identity from humanoid component

* damagevisuals now uses the enum given to it instead of the layerstate given on that layer tied to the enum

* removes commas from json

* changes to visuals system so the change is consistent

* chest

* reptilian

* visualizer system now handles body sprite setting/coloration, similar to how characterappearance did it

not a big fan of this

* adds a check in applybasesprites

* adding/removing parts should now make them invisible on a humanoid

* body part removal/adding now enumerates over sublayers instead

* synchro now runs in bodycomponent startup

* parts instead of slots

* humanoidcompnent check

* switches from rsi to actualrsi

* removes all the body stuff (too slow)

* cleans up resolves from humanoid visualizer system

* merging sprites now checks if the base sprites have been modified or not (through things like species changes, or custom base sprite changes)

* not forgetting that one again

* merging now returns an actual dirty value

* replaces the sequenceequal with a more accurate solution

* permanent layers, layer visibility on add/remove part in body

* should send all hidden layers over now

* isdirty in visualizer system for base layers

* isdirty checks count as well

* ok, IsDirty should now set the base layers if the merged sprites are different

* equals override in HumanoidSpritePrototypes.cs

temporary until record prototypes :heck:

* makes fields readonly, equates IDs instead

* adds forced markings through marking picker

* forced in humanoidsystem api, ignorespecies in markingpicker

* marking bui

* makes that serializable as well

* ignore species/forced toggles now work

* adds icon to modifier verb, interface and keys to humanoid bases

* needs the actual enum value to open, no?

* makes the key the actual key

* actions now propagate upwards

* ignore species when set now repopulates markingpicker

* modifiable base layers in the markings window

* oops!

* layout changes

* info box should now appear

* adds ignorespecies for marking picker, collapsible for base layer section of appearance modification window

* collapsible layout moment

* if base layers have changed, all markings are now dirty (and if a base layer is missing, the marking is still 'applied' but it's now just invisible

* small change to marking visibility

* small changes to modifier UI

* markings now match skin on zombification

* zombie stuff

* makes the line edit in marking modifier window more obvious

* disables vox on round start

* horizontal expand on the single label in base layer modifiers

* humanoid profiles in prototypes

* randomhumanoidappearance won't work if the humanoid has a profile already stored

* removes unused code

* documentation in humanoidsystem server-side

* documentation in shared/client

* whoops

* converts accessory into marking in locale files (also adds marking loc string into single marking picker)

* be gone, shared humanoid appearance system from the last upstream merge

* species ignore on randomization (defaults to no ignored species)

* more upstream merge parts that bypassed any errors before merge

* addresses review (also just adds typeserializers in some places)

* submodule moment

* upstream merge issues

Content.Shared/Humanoid/HairStyles.cs

@@ -0,0 +1,18 @@
+namespace Content.Shared.Humanoid
+{
+    public static class HairStyles
+    {
+        public const string DefaultHairStyle = "HairBald";
+        public const string DefaultFacialHairStyle = "FacialHairShaved";
+
+        public static readonly IReadOnlyList<Color> RealisticHairColors = new List<Color>
+        {
+            Color.Yellow,
+            Color.Black,
+            Color.SandyBrown,
+            Color.Brown,
+            Color.Wheat,
+            Color.Gray
+        };
+    }
+}

Content.Shared/Humanoid/HumanoidCharacterAppearance.cs

@@ -0,0 +1,242 @@
+using System.Linq;
+using Content.Shared.Humanoid.Markings;
+using Content.Shared.Humanoid.Prototypes;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Humanoid
+{
+    [DataDefinition]
+    [Serializable, NetSerializable]
+    public sealed class HumanoidCharacterAppearance : ICharacterAppearance
+    {
+        public HumanoidCharacterAppearance(string hairStyleId,
+            Color hairColor,
+            string facialHairStyleId,
+            Color facialHairColor,
+            Color eyeColor,
+            Color skinColor,
+            List<Marking> markings)
+        {
+            HairStyleId = hairStyleId;
+            HairColor = ClampColor(hairColor);
+            FacialHairStyleId = facialHairStyleId;
+            FacialHairColor = ClampColor(facialHairColor);
+            EyeColor = ClampColor(eyeColor);
+            SkinColor = ClampColor(skinColor);
+            Markings = markings;
+        }
+
+        [DataField("hair")]
+        public string HairStyleId { get; }
+
+        [DataField("hairColor")]
+        public Color HairColor { get; }
+
+        [DataField("facialHair")]
+        public string FacialHairStyleId { get; }
+
+        [DataField("facialHairColor")]
+        public Color FacialHairColor { get; }
+
+        [DataField("eyeColor")]
+        public Color EyeColor { get; }
+
+        [DataField("skinColor")]
+        public Color SkinColor { get; }
+
+        [DataField("markings")]
+        public List<Marking> Markings { get; }
+
+        public HumanoidCharacterAppearance WithHairStyleName(string newName)
+        {
+            return new(newName, HairColor, FacialHairStyleId, FacialHairColor, EyeColor, SkinColor, Markings);
+        }
+
+        public HumanoidCharacterAppearance WithHairColor(Color newColor)
+        {
+            return new(HairStyleId, newColor, FacialHairStyleId, FacialHairColor, EyeColor, SkinColor, Markings);
+        }
+
+        public HumanoidCharacterAppearance WithFacialHairStyleName(string newName)
+        {
+            return new(HairStyleId, HairColor, newName, FacialHairColor, EyeColor, SkinColor, Markings);
+        }
+
+        public HumanoidCharacterAppearance WithFacialHairColor(Color newColor)
+        {
+            return new(HairStyleId, HairColor, FacialHairStyleId, newColor, EyeColor, SkinColor, Markings);
+        }
+
+        public HumanoidCharacterAppearance WithEyeColor(Color newColor)
+        {
+            return new(HairStyleId, HairColor, FacialHairStyleId, FacialHairColor, newColor, SkinColor, Markings);
+        }
+
+        public HumanoidCharacterAppearance WithSkinColor(Color newColor)
+        {
+            return new(HairStyleId, HairColor, FacialHairStyleId, FacialHairColor, EyeColor, newColor, Markings);
+        }
+
+        public HumanoidCharacterAppearance WithMarkings(List<Marking> newMarkings)
+        {
+            return new(HairStyleId, HairColor, FacialHairStyleId, FacialHairColor, EyeColor, SkinColor, newMarkings);
+        }
+
+        public static HumanoidCharacterAppearance Default()
+        {
+            return new(
+                HairStyles.DefaultHairStyle,
+                Color.Black,
+                HairStyles.DefaultFacialHairStyle,
+                Color.Black,
+                Color.Black,
+                Humanoid.SkinColor.ValidHumanSkinTone,
+                new ()
+            );
+        }
+
+        private static IReadOnlyList<Color> RealisticEyeColors = new List<Color>
+        {
+            Color.Brown,
+            Color.Gray,
+            Color.Azure,
+            Color.SteelBlue,
+            Color.Black
+        };
+
+        public static HumanoidCharacterAppearance Random(string species, Sex sex)
+        {
+            var random = IoCManager.Resolve<IRobustRandom>();
+            var markingManager = IoCManager.Resolve<MarkingManager>();
+            var hairStyles = markingManager.MarkingsByCategoryAndSpecies(MarkingCategories.Hair, species).Keys.ToList();
+            var facialHairStyles = markingManager.MarkingsByCategoryAndSpecies(MarkingCategories.FacialHair, species).Keys.ToList();
+
+            var newHairStyle = hairStyles.Count > 0
+                ? random.Pick(hairStyles)
+                : HairStyles.DefaultHairStyle;
+
+            var newFacialHairStyle = facialHairStyles.Count == 0 || sex == Sex.Female
+                ? HairStyles.DefaultFacialHairStyle
+                : random.Pick(facialHairStyles);
+
+            var newHairColor = random.Pick(HairStyles.RealisticHairColors);
+            newHairColor = newHairColor
+                .WithRed(RandomizeColor(newHairColor.R))
+                .WithGreen(RandomizeColor(newHairColor.G))
+                .WithBlue(RandomizeColor(newHairColor.B));
+
+            // TODO: Add random markings
+
+            var newEyeColor = random.Pick(RealisticEyeColors);
+
+            var skinType = IoCManager.Resolve<IPrototypeManager>().Index<SpeciesPrototype>(species).SkinColoration;
+
+            var newSkinColor = Humanoid.SkinColor.ValidHumanSkinTone;
+            switch (skinType)
+            {
+                case HumanoidSkinColor.HumanToned:
+                    var tone = random.Next(0, 100);
+                    newSkinColor = Humanoid.SkinColor.HumanSkinTone(tone);
+                    break;
+                case HumanoidSkinColor.Hues:
+                case HumanoidSkinColor.TintedHues:
+                    var rbyte = random.Next(0, 255);
+                    var gbyte = random.Next(0, 255);
+                    var bbyte = random.Next(0, 255);
+                    newSkinColor = new Color(rbyte, gbyte, bbyte);
+                    break;
+            }
+
+            if (skinType == HumanoidSkinColor.TintedHues)
+            {
+                newSkinColor = Humanoid.SkinColor.ValidTintedHuesSkinTone(newSkinColor);
+            }
+
+            return new HumanoidCharacterAppearance(newHairStyle, newHairColor, newFacialHairStyle, newHairColor, newEyeColor, newSkinColor, new ());
+
+            float RandomizeColor(float channel)
+            {
+                return MathHelper.Clamp01(channel + random.Next(-25, 25) / 100f);
+            }
+        }
+
+        public static Color ClampColor(Color color)
+        {
+            return new(color.RByte, color.GByte, color.BByte);
+        }
+
+        public static HumanoidCharacterAppearance EnsureValid(HumanoidCharacterAppearance appearance, string species)
+        {
+            var hairStyleId = appearance.HairStyleId;
+            var facialHairStyleId = appearance.FacialHairStyleId;
+
+            var hairColor = ClampColor(appearance.HairColor);
+            var facialHairColor = ClampColor(appearance.FacialHairColor);
+            var eyeColor = ClampColor(appearance.EyeColor);
+
+            var proto = IoCManager.Resolve<IPrototypeManager>();
+            var markingManager = IoCManager.Resolve<MarkingManager>();
+
+            if (!markingManager.MarkingsByCategory(MarkingCategories.Hair).ContainsKey(hairStyleId))
+            {
+                hairStyleId = HairStyles.DefaultHairStyle;
+            }
+
+            if (!markingManager.MarkingsByCategory(MarkingCategories.FacialHair).ContainsKey(facialHairStyleId))
+            {
+                facialHairStyleId = HairStyles.DefaultFacialHairStyle;
+            }
+
+            var markingSet = new MarkingSet();
+            var skinColor = appearance.SkinColor;
+            if (proto.TryIndex(species, out SpeciesPrototype? speciesProto))
+            {
+                markingSet = new MarkingSet(appearance.Markings, speciesProto.MarkingPoints, markingManager, proto);
+                markingSet.EnsureValid(markingManager);
+                markingSet.FilterSpecies(species, markingManager);
+
+                switch (speciesProto.SkinColoration)
+                {
+                    case HumanoidSkinColor.HumanToned:
+                        if (!Humanoid.SkinColor.VerifyHumanSkinTone(skinColor))
+                        {
+                            skinColor = Humanoid.SkinColor.ValidHumanSkinTone;
+                        }
+
+                        break;
+                    case HumanoidSkinColor.TintedHues:
+                        if (!Humanoid.SkinColor.VerifyTintedHues(skinColor))
+                        {
+                            skinColor = Humanoid.SkinColor.ValidTintedHuesSkinTone(skinColor);
+                        }
+
+                        break;
+                }
+            }
+
+            return new HumanoidCharacterAppearance(
+                hairStyleId,
+                hairColor,
+                facialHairStyleId,
+                facialHairColor,
+                eyeColor,
+                skinColor,
+                markingSet.GetForwardEnumerator().ToList());
+        }
+
+        public bool MemberwiseEquals(ICharacterAppearance maybeOther)
+        {
+            if (maybeOther is not HumanoidCharacterAppearance other) return false;
+            if (HairStyleId != other.HairStyleId) return false;
+            if (!HairColor.Equals(other.HairColor)) return false;
+            if (FacialHairStyleId != other.FacialHairStyleId) return false;
+            if (!FacialHairColor.Equals(other.FacialHairColor)) return false;
+            if (!EyeColor.Equals(other.EyeColor)) return false;
+            if (!SkinColor.Equals(other.SkinColor)) return false;
+            if (!Markings.SequenceEqual(other.Markings)) return false;
+            return true;
+        }
+    }
+}

Content.Shared/Humanoid/HumanoidVisualLayers.cs

@@ -0,0 +1,30 @@
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Humanoid
+{
+    [Serializable, NetSerializable]
+    public enum HumanoidVisualLayers : byte
+    {
+        Tail,
+        Hair,
+        FacialHair,
+        Chest,
+        Head,
+        Snout,
+        HeadSide, // side parts (i.e., frills)
+        HeadTop,  // top parts (i.e., ears)
+        Eyes,
+        RArm,
+        LArm,
+        RHand,
+        LHand,
+        RLeg,
+        LLeg,
+        RFoot,
+        LFoot,
+        Handcuffs,
+        StencilMask,
+        Ensnare,
+        Fire,
+    }
+}

Content.Shared/Humanoid/HumanoidVisualLayersExtension.cs

@@ -0,0 +1,127 @@
+using Content.Shared.Body.Components;
+using Content.Shared.Body.Part;
+
+namespace Content.Shared.Humanoid
+{
+    public static class HumanoidVisualLayersExtension
+    {
+        public static bool HasSexMorph(HumanoidVisualLayers layer)
+        {
+            return layer switch
+            {
+                HumanoidVisualLayers.Chest => true,
+                HumanoidVisualLayers.Head => true,
+                _ => false
+            };
+        }
+
+        /// <summary>
+        ///     Sublayers. Any other layers that may visually depend on this layer existing.
+        ///     For example, the head has layers such as eyes, hair, etc. depending on it.
+        /// </summary>
+        /// <param name="layer"></param>
+        /// <returns>Enumerable of layers that depend on that given layer. Empty, otherwise.</returns>
+        /// <remarks>This could eventually be replaced by a body system implementation.</remarks>
+        public static IEnumerable<HumanoidVisualLayers> Sublayers(HumanoidVisualLayers layer)
+        {
+            switch (layer)
+            {
+                case HumanoidVisualLayers.Head:
+                    yield return HumanoidVisualLayers.Head;
+                    yield return HumanoidVisualLayers.Eyes;
+                    yield return HumanoidVisualLayers.HeadSide;
+                    yield return HumanoidVisualLayers.HeadTop;
+                    yield return HumanoidVisualLayers.Hair;
+                    yield return HumanoidVisualLayers.FacialHair;
+                    yield return HumanoidVisualLayers.Snout;
+                    break;
+                case HumanoidVisualLayers.LArm:
+                    yield return HumanoidVisualLayers.LArm;
+                    yield return HumanoidVisualLayers.LHand;
+                    break;
+                case HumanoidVisualLayers.RArm:
+                    yield return HumanoidVisualLayers.RArm;
+                    yield return HumanoidVisualLayers.RHand;
+                    break;
+                case HumanoidVisualLayers.LLeg:
+                    yield return HumanoidVisualLayers.LLeg;
+                    yield return HumanoidVisualLayers.LFoot;
+                    break;
+                case HumanoidVisualLayers.RLeg:
+                    yield return HumanoidVisualLayers.RLeg;
+                    yield return HumanoidVisualLayers.RFoot;
+                    break;
+                case HumanoidVisualLayers.Chest:
+                    yield return HumanoidVisualLayers.Chest;
+                    yield return HumanoidVisualLayers.Tail;
+                    break;
+                default:
+                    yield break;
+            }
+        }
+
+        public static HumanoidVisualLayers? ToHumanoidLayers(this SharedBodyPartComponent part)
+        {
+            switch (part.PartType)
+            {
+                case BodyPartType.Other:
+                    break;
+                case BodyPartType.Torso:
+                    return HumanoidVisualLayers.Chest;
+                case BodyPartType.Tail:
+                    return HumanoidVisualLayers.Tail;
+                case BodyPartType.Head:
+                    // use the Sublayers method to hide the rest of the parts,
+                    // if that's what you're looking for
+                    return HumanoidVisualLayers.Head;
+                    break;
+                case BodyPartType.Arm:
+                    switch (part.Symmetry)
+                    {
+                        case BodyPartSymmetry.None:
+                            break;
+                        case BodyPartSymmetry.Left:
+                            return HumanoidVisualLayers.LArm;
+                        case BodyPartSymmetry.Right:
+                            return HumanoidVisualLayers.RArm;
+                    }
+                    break;
+                case BodyPartType.Hand:
+                    switch (part.Symmetry)
+                    {
+                        case BodyPartSymmetry.None:
+                            break;
+                        case BodyPartSymmetry.Left:
+                            return HumanoidVisualLayers.LHand;
+                        case BodyPartSymmetry.Right:
+                            return HumanoidVisualLayers.RHand;
+                    }
+                    break;
+                case BodyPartType.Leg:
+                    switch (part.Symmetry)
+                    {
+                        case BodyPartSymmetry.None:
+                            break;
+                        case BodyPartSymmetry.Left:
+                            return HumanoidVisualLayers.LLeg;
+                        case BodyPartSymmetry.Right:
+                            return HumanoidVisualLayers.RLeg;
+                    }
+                    break;
+                case BodyPartType.Foot:
+                    switch (part.Symmetry)
+                    {
+                        case BodyPartSymmetry.None:
+                            break;
+                        case BodyPartSymmetry.Left:
+                            return HumanoidVisualLayers.LFoot;
+                        case BodyPartSymmetry.Right:
+                            return HumanoidVisualLayers.RFoot;
+                    }
+                    break;
+            }
+
+            return null;
+        }
+    }
+}

Content.Shared/Humanoid/HumanoidVisualizerKeys.cs

@@ -0,0 +1,34 @@
+using Content.Shared.Humanoid.Markings;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Humanoid;
+
+[Serializable, NetSerializable]
+public enum HumanoidVisualizerKey
+{
+    Key
+}
+
+[Serializable, NetSerializable]
+public sealed class HumanoidVisualizerData : ICloneable
+{
+    public HumanoidVisualizerData(string species, Dictionary<HumanoidVisualLayers, CustomBaseLayerInfo> customBaseLayerInfo, Color skinColor, List<HumanoidVisualLayers> layerVisibility, List<Marking> markings)
+    {
+        Species = species;
+        CustomBaseLayerInfo = customBaseLayerInfo;
+        SkinColor = skinColor;
+        LayerVisibility = layerVisibility;
+        Markings = markings;
+    }
+
+    public string Species { get; }
+    public Dictionary<HumanoidVisualLayers, CustomBaseLayerInfo> CustomBaseLayerInfo { get; }
+    public Color SkinColor { get; }
+    public List<HumanoidVisualLayers> LayerVisibility { get; }
+    public List<Marking> Markings { get; }
+
+    public object Clone()
+    {
+        return new HumanoidVisualizerData(Species, new(CustomBaseLayerInfo), SkinColor, new(LayerVisibility), new(Markings));
+    }
+}

Content.Shared/Humanoid/ICharacterAppearance.cs

@@ -0,0 +1,8 @@
+
+namespace Content.Shared.Humanoid
+{
+    public interface ICharacterAppearance
+    {
+        bool MemberwiseEquals(ICharacterAppearance other);
+    }
+}

Content.Shared/Humanoid/Markings/Marking.cs

@@ -0,0 +1,136 @@
+using System.Linq;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Humanoid.Markings
+{
+    [Serializable, NetSerializable]
+    public sealed class Marking : IEquatable<Marking>, IComparable<Marking>, IComparable<string>
+    {
+        [DataField("markingColor")]
+        private List<Color> _markingColors = new();
+
+        private Marking(string markingId,
+            List<Color> markingColors)
+        {
+            MarkingId = markingId;
+            _markingColors = markingColors;
+        }
+
+        public Marking(string markingId,
+            IReadOnlyList<Color> markingColors)
+            : this(markingId, new List<Color>(markingColors))
+        {
+        }
+
+        public Marking(string markingId, int colorCount)
+        {
+            MarkingId = markingId;
+            List<Color> colors = new();
+            for (int i = 0; i < colorCount; i++)
+                colors.Add(Color.White);
+            _markingColors = colors;
+        }
+
+        public Marking(Marking other)
+        {
+            MarkingId = other.MarkingId;
+            _markingColors = new(other.MarkingColors);
+            Visible = other.Visible;
+            Forced = other.Forced;
+        }
+
+        /// <summary>
+        ///     ID of the marking prototype.
+        /// </summary>
+        [DataField("markingId")]
+        [ViewVariables]
+        public string MarkingId { get; } = default!;
+
+        /// <summary>
+        ///     All colors currently on this marking.
+        /// </summary>
+        [ViewVariables]
+        public IReadOnlyList<Color> MarkingColors => _markingColors;
+
+        /// <summary>
+        ///     If this marking is currently visible.
+        /// </summary>
+        [ViewVariables]
+        public bool Visible = true;
+
+        /// <summary>
+        ///     If this marking should be forcefully applied, regardless of points.
+        /// </summary>
+        [ViewVariables]
+        public bool Forced;
+
+        public void SetColor(int colorIndex, Color color) =>
+            _markingColors[colorIndex] = color;
+
+        public int CompareTo(Marking? marking)
+        {
+            if (marking == null)
+            {
+                return 1;
+            }
+
+            return MarkingId.CompareTo(marking.MarkingId);
+        }
+
+        public int CompareTo(string? markingId)
+        {
+            if (markingId == null)
+            {
+                return 1;
+            }
+
+            return MarkingId.CompareTo(markingId);
+        }
+
+        public bool Equals(Marking? other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+            return MarkingId.Equals(other.MarkingId)
+                && _markingColors.SequenceEqual(other._markingColors)
+                && Visible.Equals(other.Visible)
+                && Forced.Equals(other.Forced);
+        }
+
+        // VERY BIG TODO: TURN THIS INTO JSONSERIALIZER IMPLEMENTATION
+
+
+        // look this could be better but I don't think serializing
+        // colors is the correct thing to do
+        //
+        // this is still janky imo but serializing a color and feeding
+        // it into the default JSON serializer (which is just *fine*)
+        // doesn't seem to have compatible interfaces? this 'works'
+        // for now but should eventually be improved so that this can,
+        // in fact just be serialized through a convenient interface
+        new public string ToString()
+        {
+            // reserved character
+            string sanitizedName = this.MarkingId.Replace('@', '_');
+            List<string> colorStringList = new();
+            foreach (Color color in _markingColors)
+                colorStringList.Add(color.ToHex());
+
+            return $"{sanitizedName}@{String.Join(',', colorStringList)}";
+        }
+
+        public static Marking? ParseFromDbString(string input)
+        {
+            if (input.Length == 0) return null;
+            var split = input.Split('@');
+            if (split.Length != 2) return null;
+            List<Color> colorList = new();
+            foreach (string color in split[1].Split(','))
+                colorList.Add(Color.FromHex(color));
+
+            return new Marking(split[0], colorList);
+        }
+    }
+}

Content.Shared/Humanoid/Markings/MarkingCategories.cs

@@ -0,0 +1,47 @@
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Humanoid.Markings
+{
+    [Serializable, NetSerializable]
+    public enum MarkingCategories : byte
+    {
+        Hair,
+        FacialHair,
+        Head,
+        HeadTop,
+        HeadSide,
+        Snout,
+        Chest,
+        Arms,
+        Legs,
+        Tail,
+        Overlay
+    }
+
+    public static class MarkingCategoriesConversion
+    {
+        public static MarkingCategories FromHumanoidVisualLayers(HumanoidVisualLayers layer)
+        {
+            return layer switch
+            {
+                HumanoidVisualLayers.Hair => MarkingCategories.Hair,
+                HumanoidVisualLayers.FacialHair => MarkingCategories.FacialHair,
+                HumanoidVisualLayers.Head => MarkingCategories.Head,
+                HumanoidVisualLayers.HeadTop => MarkingCategories.HeadTop,
+                HumanoidVisualLayers.HeadSide => MarkingCategories.HeadSide,
+                HumanoidVisualLayers.Snout => MarkingCategories.Snout,
+                HumanoidVisualLayers.Chest => MarkingCategories.Chest,
+                HumanoidVisualLayers.RArm => MarkingCategories.Arms,
+                HumanoidVisualLayers.LArm => MarkingCategories.Arms,
+                HumanoidVisualLayers.RHand => MarkingCategories.Arms,
+                HumanoidVisualLayers.LHand => MarkingCategories.Arms,
+                HumanoidVisualLayers.LLeg => MarkingCategories.Legs,
+                HumanoidVisualLayers.RLeg => MarkingCategories.Legs,
+                HumanoidVisualLayers.LFoot => MarkingCategories.Legs,
+                HumanoidVisualLayers.RFoot => MarkingCategories.Legs,
+                HumanoidVisualLayers.Tail => MarkingCategories.Tail,
+                _ => MarkingCategories.Overlay
+            };
+        }
+    }
+}

Content.Shared/Humanoid/Markings/MarkingManager.cs

@@ -0,0 +1,124 @@
+using System.Diagnostics.CodeAnalysis;
+using Content.Shared.Humanoid.Prototypes;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.Humanoid.Markings
+{
+    public sealed class MarkingManager
+    {
+        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
+        private readonly List<MarkingPrototype> _index = new();
+        private readonly Dictionary<MarkingCategories, Dictionary<string, MarkingPrototype>> _markingDict = new();
+        private readonly Dictionary<string, MarkingPrototype> _markings = new();
+
+        public void Initialize()
+        {
+            _prototypeManager.PrototypesReloaded += OnPrototypeReload;
+
+            foreach (var category in Enum.GetValues<MarkingCategories>())
+            {
+                _markingDict.Add(category, new Dictionary<string, MarkingPrototype>());
+            }
+
+            foreach (var prototype in _prototypeManager.EnumeratePrototypes<MarkingPrototype>())
+            {
+                _index.Add(prototype);
+                _markingDict[prototype.MarkingCategory].Add(prototype.ID, prototype);
+                _markings.Add(prototype.ID, prototype);
+            }
+        }
+
+        public IReadOnlyDictionary<string, MarkingPrototype> Markings => _markings;
+        public IReadOnlyDictionary<MarkingCategories, Dictionary<string, MarkingPrototype>> CategorizedMarkings => _markingDict;
+
+        public IReadOnlyDictionary<string, MarkingPrototype> MarkingsByCategory(MarkingCategories category)
+        {
+            // all marking categories are guaranteed to have a dict entry
+            return _markingDict[category];
+        }
+
+        /// <summary>
+        ///     Markings by category and species.
+        /// </summary>
+        /// <param name="category"></param>
+        /// <param name="species"></param>
+        /// <remarks>
+        ///     This is done per category, as enumerating over every single marking by species isn't useful.
+        ///     Please make a pull request if you find a use case for that behavior.
+        /// </remarks>
+        /// <returns></returns>
+        public IReadOnlyDictionary<string, MarkingPrototype> MarkingsByCategoryAndSpecies(MarkingCategories category,
+            string species)
+        {
+            var speciesProto = _prototypeManager.Index<SpeciesPrototype>(species);
+            var onlyWhitelisted = _prototypeManager.Index<MarkingPointsPrototype>(speciesProto.MarkingPoints).OnlyWhitelisted;
+            var res = new Dictionary<string, MarkingPrototype>();
+
+            foreach (var (key, marking) in MarkingsByCategory(category))
+            {
+                if (onlyWhitelisted && marking.SpeciesRestrictions == null)
+                {
+                    continue;
+                }
+
+                if (marking.SpeciesRestrictions != null && !marking.SpeciesRestrictions.Contains(species))
+                {
+                    continue;
+                }
+
+                res.Add(key, marking);
+            }
+
+            return res;
+        }
+
+        public bool TryGetMarking(Marking marking, [NotNullWhen(true)] out MarkingPrototype? markingResult)
+        {
+            return _markings.TryGetValue(marking.MarkingId, out markingResult);
+        }
+
+        /// <summary>
+        ///     Check if a marking is valid according to the category, species, and current data this marking has.
+        /// </summary>
+        /// <param name="marking"></param>
+        /// <param name="category"></param>
+        /// <param name="species"></param>
+        /// <returns></returns>
+        public bool IsValidMarking(Marking marking, MarkingCategories category, string species)
+        {
+            if (!TryGetMarking(marking, out var proto))
+            {
+                return false;
+            }
+
+            if (proto.MarkingCategory != category ||
+                proto.SpeciesRestrictions != null && !proto.SpeciesRestrictions.Contains(species))
+            {
+                return false;
+            }
+
+            if (marking.MarkingColors.Count != proto.Sprites.Count)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        private void OnPrototypeReload(PrototypesReloadedEventArgs args)
+        {
+            if(!args.ByType.TryGetValue(typeof(MarkingPrototype), out var set))
+                return;
+
+
+            _index.RemoveAll(i => set.Modified.ContainsKey(i.ID));
+
+            foreach (var prototype in set.Modified.Values)
+            {
+                var markingPrototype = (MarkingPrototype) prototype;
+                _index.Add(markingPrototype);
+            }
+        }
+    }
+}

Content.Shared/Humanoid/Markings/MarkingPoints.cs

@@ -0,0 +1,51 @@
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.List;
+
+namespace Content.Shared.Humanoid.Markings;
+
+[DataDefinition]
+[Serializable, NetSerializable]
+public sealed class MarkingPoints
+{
+    [DataField("points", required: true)]
+    public int Points = 0;
+    [DataField("required", required: true)]
+    public bool Required = false;
+    // Default markings for this layer.
+    [DataField("defaultMarkings", customTypeSerializer:typeof(PrototypeIdListSerializer<MarkingPrototype>))]
+    public List<string> DefaultMarkings = new();
+
+    public static Dictionary<MarkingCategories, MarkingPoints> CloneMarkingPointDictionary(Dictionary<MarkingCategories, MarkingPoints> self)
+    {
+        var clone = new Dictionary<MarkingCategories, MarkingPoints>();
+
+        foreach (var (category, points) in self)
+        {
+            clone[category] = new MarkingPoints()
+            {
+                Points = points.Points,
+                Required = points.Required,
+                DefaultMarkings = points.DefaultMarkings
+            };
+        }
+
+        return clone;
+    }
+}
+
+[Prototype("markingPoints")]
+public sealed class MarkingPointsPrototype : IPrototype
+{
+    [IdDataField] public string ID { get; } = default!;
+
+    /// <summary>
+    ///     If the user of this marking point set is only allowed to
+    ///     use whitelisted markings, and not globally usable markings.
+    ///     Only used for validation and profile construction. Ignored anywhere else.
+    /// </summary>
+    [DataField("onlyWhitelisted")] public bool OnlyWhitelisted;
+
+    [DataField("points", required: true)]
+    public Dictionary<MarkingCategories, MarkingPoints> Points { get; } = default!;
+}

Content.Shared/Humanoid/Markings/MarkingPrototype.cs

@@ -0,0 +1,34 @@
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.Humanoid.Markings
+{
+    [Prototype("marking")]
+    public sealed class MarkingPrototype : IPrototype
+    {
+        [IdDataField]
+        public string ID { get; } = "uwu";
+
+        public string Name { get; private set; } = default!;
+
+        [DataField("bodyPart", required: true)]
+        public HumanoidVisualLayers BodyPart { get; } = default!;
+
+        [DataField("markingCategory", required: true)]
+        public MarkingCategories MarkingCategory { get; } = default!;
+
+        [DataField("speciesRestriction")]
+        public List<string>? SpeciesRestrictions { get; }
+
+        [DataField("followSkinColor")]
+        public bool FollowSkinColor { get; } = false;
+
+        [DataField("sprites", required: true)]
+        public List<SpriteSpecifier> Sprites { get; private set; } = default!;
+
+        public Marking AsMarking()
+        {
+            return new Marking(ID, Sprites.Count);
+        }
+    }
+}

Content.Shared/Humanoid/Markings/MarkingsComponent.cs

@@ -0,0 +1,26 @@
+namespace Content.Shared.Humanoid.Markings
+{
+    [RegisterComponent]
+    public sealed class MarkingsComponent : Component
+    {
+        public Dictionary<HumanoidVisualLayers, List<Marking>> ActiveMarkings = new();
+
+        // Layer points for the attached mob. This is verified client side (but should be verified server side, eventually as well),
+        // but upon render for the given entity with this component, it will start subtracting
+        // points from this set. Upon depletion, no more sprites in this layer will be
+        // rendered. If an entry is null, however, it is considered 'unlimited points' for
+        // that layer.
+        //
+        // Layer points are useful for restricting the amount of markings a specific layer can use
+        // for specific mobs (i.e., a lizard should only use one set of horns and maybe two frills),
+        // and all species with selectable tails should have exactly one tail)
+        //
+        // If something is required, then something must be selected in that category. Otherwise,
+        // the first instance of a marking in that category will be added to a character
+        // upon round start.
+        [DataField("layerPoints")]
+        public Dictionary<MarkingCategories, MarkingPoints> LayerPoints = new();
+    }
+
+
+}

Content.Shared/Humanoid/Markings/MarkingsSet.cs

@@ -0,0 +1,778 @@
+using System.Collections;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Content.Shared.Humanoid.Prototypes;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Humanoid.Markings;
+
+// the better version of MarkingsSet
+// This one should ensure that a set is valid. Dependency retrieval is
+// probably not a good idea, and any dependency references should last
+// only for the length of a call, and not the lifetime of the set itself.
+//
+// Compared to MarkingsSet, this should allow for server-side authority.
+// Instead of sending the set over, we can instead just send the dictionary
+// and build the set from there. We can also just send a list and rebuild
+// the set without validating points (we're assuming that the server
+
+/// <summary>
+///     Marking set. For humanoid markings.
+/// </summary>
+/// <remarks>
+///     This is serializable for the admin panel that sets markings on demand for a player.
+///     Most APIs that accept a set of markings usually use a List of type Marking instead.
+/// </remarks>
+[Serializable, NetSerializable]
+public sealed class MarkingSet
+{
+    /// <summary>
+    ///     Every single marking in this set.
+    /// </summary>
+    /// <remarks>
+    ///     The original version of MarkingSet preserved ordering across all
+    ///     markings - this one should instead preserve ordering across all
+    ///     categories, but not marking categories themselves. This is because
+    ///     the layers that markings appear in are guaranteed to be in the correct
+    ///     order. This is here to make lookups slightly faster, even if the n of
+    ///     a marking set is relatively small, and to encapsulate another important
+    ///     feature of markings, which is the limit of markings you can put on a
+    ///     humanoid.
+    /// </remarks>
+    private Dictionary<MarkingCategories, List<Marking>> _markings = new();
+
+    // why i didn't encapsulate this in the first place, i won't know
+
+    /// <summary>
+    ///     Marking points for each category.
+    /// </summary>
+    private Dictionary<MarkingCategories, MarkingPoints> _points = new();
+
+    public IReadOnlyList<Marking> this[MarkingCategories category] => _markings[category];
+
+    public MarkingSet()
+    {}
+
+    /// <summary>
+    ///     Construct a MarkingSet using a list of markings, and a points
+    ///     dictionary. This will set up the points dictionary, and
+    ///     process the list, truncating if necessary. Markings that
+    ///     do not exist as a prototype will be removed.
+    /// </summary>
+    /// <param name="markings">The lists of markings to use.</param>
+    /// <param name="pointsPrototype">The ID of the points dictionary prototype.</param>
+    public MarkingSet(List<Marking> markings, string pointsPrototype, MarkingManager? markingManager = null, IPrototypeManager? prototypeManager = null)
+    {
+        IoCManager.Resolve(ref markingManager, ref prototypeManager);
+
+        if (!prototypeManager.TryIndex(pointsPrototype, out MarkingPointsPrototype? points))
+        {
+            return;
+        }
+
+        _points = MarkingPoints.CloneMarkingPointDictionary(points.Points);
+
+        foreach (var marking in markings)
+        {
+            if (!markingManager.TryGetMarking(marking, out var prototype))
+            {
+                continue;
+            }
+
+            AddBack(prototype.MarkingCategory, marking);
+        }
+    }
+
+    /// <summary>
+    ///     Construct a MarkingSet using a dictionary of markings,
+    ///     without point validation. This will still validate every
+    ///     marking, to ensure that it can be placed into the set.
+    /// </summary>
+    /// <param name="markings">The list of markings to use.</param>
+    public MarkingSet(List<Marking> markings, MarkingManager? markingManager = null)
+    {
+        IoCManager.Resolve(ref markingManager);
+
+        foreach (var marking in markings)
+        {
+            if (!markingManager.TryGetMarking(marking, out var prototype))
+            {
+                continue;
+            }
+
+            AddBack(prototype.MarkingCategory, marking);
+        }
+    }
+
+    /// <summary>
+    ///     Construct a MarkingSet by deep cloning another set.
+    /// </summary>
+    /// <param name="other">The other marking set.</param>
+    public MarkingSet(MarkingSet other)
+    {
+        foreach (var (key, list) in other._markings)
+        {
+            foreach (var marking in list)
+            {
+                AddBack(key, new(marking));
+            }
+        }
+
+        _points = MarkingPoints.CloneMarkingPointDictionary(other._points);
+    }
+
+    /// <summary>
+    ///     Filters markings based on species restrictions in the marking's prototype from this marking set.
+    /// </summary>
+    /// <param name="species">The species to filter.</param>
+    /// <param name="markingManager">Marking manager.</param>
+    /// <param name="prototypeManager">Prototype manager.</param>
+    public void FilterSpecies(string species, MarkingManager? markingManager = null, IPrototypeManager? prototypeManager = null)
+    {
+        IoCManager.Resolve(ref markingManager);
+        IoCManager.Resolve(ref prototypeManager);
+
+        var toRemove = new List<(MarkingCategories category, string id)>();
+        var speciesProto = prototypeManager.Index<SpeciesPrototype>(species);
+        var onlyWhitelisted = prototypeManager.Index<MarkingPointsPrototype>(speciesProto.MarkingPoints).OnlyWhitelisted;
+
+        foreach (var (category, list) in _markings)
+        {
+            foreach (var marking in list)
+            {
+                if (!markingManager.TryGetMarking(marking, out var prototype))
+                {
+                    toRemove.Add((category, marking.MarkingId));
+                    continue;
+                }
+
+                if (onlyWhitelisted && prototype.SpeciesRestrictions == null)
+                {
+                    toRemove.Add((category, marking.MarkingId));
+                }
+
+                if (prototype.SpeciesRestrictions != null
+                    && !prototype.SpeciesRestrictions.Contains(species))
+                {
+                    toRemove.Add((category, marking.MarkingId));
+                }
+            }
+        }
+
+        foreach (var remove in toRemove)
+        {
+            Remove(remove.category, remove.id);
+        }
+    }
+
+    /// <summary>
+    ///     Ensures that all markings in this set are valid.
+    /// </summary>
+    /// <param name="markingManager">Marking manager.</param>
+    public void EnsureValid(MarkingManager? markingManager = null)
+    {
+        IoCManager.Resolve(ref markingManager);
+
+        var toRemove = new List<int>();
+        foreach (var (category, list) in _markings)
+        {
+            for (var i = 0; i < list.Count; i++)
+            {
+                if (!markingManager.TryGetMarking(list[i], out var marking))
+                {
+                    toRemove.Add(i);
+                    continue;
+                }
+
+                if (marking.Sprites.Count != list[i].MarkingColors.Count)
+                {
+                    list[i] = new Marking(marking.ID, marking.Sprites.Count);
+                }
+            }
+
+            foreach (var i in toRemove)
+            {
+                Remove(category, i);
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Ensures that the default markings as defined by the marking point set in this marking set are applied.
+    /// </summary>
+    /// <param name="skinColor">Color to apply.</param>
+    /// <param name="markingManager">Marking manager.</param>
+    public void EnsureDefault(Color? skinColor = null, MarkingManager? markingManager = null)
+    {
+        IoCManager.Resolve(ref markingManager);
+
+        foreach (var (category, points) in _points)
+        {
+            if (points.Points <= 0 || points.DefaultMarkings.Count <= 0)
+            {
+                continue;
+            }
+
+            var index = 0;
+            while (points.Points > 0 || index < points.DefaultMarkings.Count)
+            {
+                if (markingManager.Markings.TryGetValue(points.DefaultMarkings[index], out var prototype))
+                {
+                    Marking marking;
+                    if (skinColor == null)
+                    {
+                        marking = new Marking(points.DefaultMarkings[index], prototype.Sprites.Count);
+                    }
+                    else
+                    {
+                        var colors = new List<Color>();
+
+                        for (var i = 0; i < prototype.Sprites.Count; i++)
+                        {
+                            colors.Add(skinColor.Value);
+                        }
+
+                        marking = new Marking(points.DefaultMarkings[index], colors);
+                    }
+
+                    AddBack(category, marking);
+                }
+
+                index++;
+            }
+        }
+    }
+
+    /// <summary>
+    ///     How many points are left in this marking set's category
+    /// </summary>
+    /// <param name="category">The category to check</param>
+    /// <returns>A number equal or greater than zero if the category exists, -1 otherwise.</returns>
+    public int PointsLeft(MarkingCategories category)
+    {
+        if (!_points.TryGetValue(category, out var points))
+        {
+            return -1;
+        }
+
+        return points.Points;
+    }
+
+    /// <summary>
+    ///     Add a marking to the front of the category's list of markings.
+    /// </summary>
+    /// <param name="category">Category to add the marking to.</param>
+    /// <param name="marking">The marking instance in question.</param>
+    public void AddFront(MarkingCategories category, Marking marking)
+    {
+        if (!marking.Forced && _points.TryGetValue(category, out var points))
+        {
+            if (points.Points <= 0)
+            {
+                return;
+            }
+
+            points.Points--;
+        }
+
+        if (!_markings.TryGetValue(category, out var markings))
+        {
+            markings = new();
+            _markings[category] = markings;
+        }
+
+        markings.Insert(0, marking);
+    }
+
+    /// <summary>
+    ///     Add a marking to the back of the category's list of markings.
+    /// </summary>
+    /// <param name="category"></param>
+    /// <param name="marking"></param>
+    public void AddBack(MarkingCategories category, Marking marking)
+    {
+        if (!marking.Forced && _points.TryGetValue(category, out var points))
+        {
+            if (points.Points <= 0)
+            {
+                return;
+            }
+
+            points.Points--;
+        }
+
+        if (!_markings.TryGetValue(category, out var markings))
+        {
+            markings = new();
+            _markings[category] = markings;
+        }
+
+
+        markings.Add(marking);
+    }
+
+    /// <summary>
+    ///     Adds a category to this marking set.
+    /// </summary>
+    /// <param name="category"></param>
+    /// <returns></returns>
+    public List<Marking> AddCategory(MarkingCategories category)
+    {
+        var markings = new List<Marking>();
+        _markings.Add(category, markings);
+        return markings;
+    }
+
+    /// <summary>
+    ///     Replace a marking at a given index in a marking category with another marking.
+    /// </summary>
+    /// <param name="category">The category to replace the marking in.</param>
+    /// <param name="index">The index of the marking.</param>
+    /// <param name="marking">The marking to insert.</param>
+    public void Replace(MarkingCategories category, int index, Marking marking)
+    {
+        if (index < 0 || !_markings.TryGetValue(category, out var markings)
+            || index >= markings.Count)
+        {
+            return;
+        }
+
+        markings[index] = marking;
+    }
+
+    /// <summary>
+    ///     Remove a marking by category and ID.
+    /// </summary>
+    /// <param name="category">The category that contains the marking.</param>
+    /// <param name="id">The marking's ID.</param>
+    /// <returns>True if removed, false otherwise.</returns>
+    public bool Remove(MarkingCategories category, string id)
+    {
+        if (!_markings.TryGetValue(category, out var markings))
+        {
+            return false;
+        }
+
+        for (var i = 0; i < markings.Count; i++)
+        {
+            if (markings[i].MarkingId != id)
+            {
+                continue;
+            }
+
+            if (!markings[i].Forced && _points.TryGetValue(category, out var points))
+            {
+                points.Points++;
+            }
+
+            markings.RemoveAt(i);
+            return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Remove a marking by category and index.
+    /// </summary>
+    /// <param name="category">The category that contains the marking.</param>
+    /// <param name="idx">The marking's index.</param>
+    /// <returns>True if removed, false otherwise.</returns>
+    public void Remove(MarkingCategories category, int idx)
+    {
+        if (!_markings.TryGetValue(category, out var markings))
+        {
+            return;
+        }
+
+        if (idx < 0 || idx >= markings.Count)
+        {
+            return;
+        }
+
+        if (!markings[idx].Forced && _points.TryGetValue(category, out var points))
+        {
+            points.Points++;
+        }
+
+        markings.RemoveAt(idx);
+    }
+
+    /// <summary>
+    ///     Remove an entire category from this marking set.
+    /// </summary>
+    /// <param name="category">The category to remove.</param>
+    /// <returns>True if removed, false otherwise.</returns>
+    public bool RemoveCategory(MarkingCategories category)
+    {
+        if (!_markings.TryGetValue(category, out var markings))
+        {
+            return false;
+        }
+
+        if (_points.TryGetValue(category, out var points))
+        {
+            foreach (var marking in markings)
+            {
+                if (marking.Forced)
+                {
+                    continue;
+                }
+
+                points.Points++;
+            }
+        }
+
+        _markings.Remove(category);
+        return true;
+    }
+
+    /// <summary>
+    ///     Clears all markings from this marking set.
+    /// </summary>
+    public void Clear()
+    {
+        foreach (var category in Enum.GetValues<MarkingCategories>())
+        {
+            RemoveCategory(category);
+        }
+    }
+
+    /// <summary>
+    ///     Attempt to find the index of a marking in a category by ID.
+    /// </summary>
+    /// <param name="category">The category to search in.</param>
+    /// <param name="id">The ID to search for.</param>
+    /// <returns>The index of the marking, otherwise a negative number.</returns>
+    public int FindIndexOf(MarkingCategories category, string id)
+    {
+        if (!_markings.TryGetValue(category, out var markings))
+        {
+            return -1;
+        }
+
+        return markings.FindIndex(m => m.MarkingId == id);
+    }
+
+    /// <summary>
+    ///     Tries to get an entire category from this marking set.
+    /// </summary>
+    /// <param name="category">The category to fetch.</param>
+    /// <param name="markings">A read only list of the all markings in that category.</param>
+    /// <returns>True if successful, false otherwise.</returns>
+    public bool TryGetCategory(MarkingCategories category, [NotNullWhen(true)] out IReadOnlyList<Marking>? markings)
+    {
+        markings = null;
+
+        if (_markings.TryGetValue(category, out var list))
+        {
+            markings = list;
+            return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Tries to get a marking from this marking set, by category.
+    /// </summary>
+    /// <param name="category">The category to search in.</param>
+    /// <param name="id">The ID to search for.</param>
+    /// <param name="marking">The marking, if it was retrieved.</param>
+    /// <returns>True if successful, false otherwise.</returns>
+    public bool TryGetMarking(MarkingCategories category, string id, [NotNullWhen(true)] out Marking? marking)
+    {
+        marking = null;
+
+        if (!_markings.TryGetValue(category, out var markings))
+        {
+            return false;
+        }
+
+        foreach (var m in markings)
+        {
+            if (m.MarkingId == id)
+            {
+                marking = m;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    ///     Shifts a marking's rank towards the front of the list
+    /// </summary>
+    /// <param name="category">The category to shift in.</param>
+    /// <param name="idx">Index of the marking.</param>
+    public void ShiftRankUp(MarkingCategories category, int idx)
+    {
+        if (!_markings.TryGetValue(category, out var markings))
+        {
+            return;
+        }
+
+        if (idx < 0 || idx >= markings.Count || idx - 1 < 0)
+        {
+            return;
+        }
+
+        (markings[idx - 1], markings[idx]) = (markings[idx], markings[idx - 1]);
+    }
+
+    /// <summary>
+    ///     Shifts a marking's rank upwards from the end of the list
+    /// </summary>
+    /// <param name="category">The category to shift in.</param>
+    /// <param name="idx">Index of the marking from the end</param>
+    public void ShiftRankUpFromEnd(MarkingCategories category, int idx)
+    {
+        if (!_markings.TryGetValue(category, out var markings))
+        {
+            return;
+        }
+
+        ShiftRankUp(category, markings.Count - idx - 1);
+    }
+
+    /// <summary>
+    ///     Shifts a marking's rank towards the end of the list
+    /// </summary>
+    /// <param name="category">The category to shift in.</param>
+    /// <param name="idx">Index of the marking.</param>
+    public void ShiftRankDown(MarkingCategories category, int idx)
+    {
+        if (!_markings.TryGetValue(category, out var markings))
+        {
+            return;
+        }
+
+        if (idx < 0 || idx >= markings.Count || idx + 1 >= markings.Count)
+        {
+            return;
+        }
+
+        (markings[idx + 1], markings[idx]) = (markings[idx], markings[idx + 1]);
+    }
+
+    /// <summary>
+    ///     Shifts a marking's rank downwards from the end of the list
+    /// </summary>
+    /// <param name="category">The category to shift in.</param>
+    /// <param name="idx">Index of the marking from the end</param>
+    public void ShiftRankDownFromEnd(MarkingCategories category, int idx)
+    {
+        if (!_markings.TryGetValue(category, out var markings))
+        {
+            return;
+        }
+
+        ShiftRankDown(category, markings.Count - idx - 1);
+    }
+
+    /// <summary>
+    ///     Gets all markings in this set as an enumerator. Lists will be organized, but categories may be in any order.
+    /// </summary>
+    /// <returns>An enumerator of <see cref="Marking"/>s.</returns>
+    public ForwardMarkingEnumerator GetForwardEnumerator()
+    {
+        var markings = new List<Marking>();
+        foreach (var (_, list) in _markings)
+        {
+            markings.AddRange(list);
+        }
+
+        return new ForwardMarkingEnumerator(markings);
+    }
+
+    /// <summary>
+    ///     Gets an enumerator of markings in this set, but only for one category.
+    /// </summary>
+    /// <param name="category">The category to fetch.</param>
+    /// <returns>An enumerator of <see cref="Marking"/>s in that category.</returns>
+    public ForwardMarkingEnumerator GetForwardEnumerator(MarkingCategories category)
+    {
+        var markings = new List<Marking>();
+        if (_markings.TryGetValue(category, out var listing))
+        {
+            markings = new(listing);
+        }
+
+        return new ForwardMarkingEnumerator(markings);
+    }
+
+    /// <summary>
+    ///     Gets all markings in this set as an enumerator, but in reverse order. Lists will be in reverse order, but categories may be in any order.
+    /// </summary>
+    /// <returns>An enumerator of <see cref="Marking"/>s in reverse.</returns>
+    public ReverseMarkingEnumerator GetReverseEnumerator()
+    {
+        var markings = new List<Marking>();
+        foreach (var (_, list) in _markings)
+        {
+            markings.AddRange(list);
+        }
+
+        return new ReverseMarkingEnumerator(markings);
+    }
+
+    /// <summary>
+    ///     Gets an enumerator of markings in this set in reverse order, but only for one category.
+    /// </summary>
+    /// <param name="category">The category to fetch.</param>
+    /// <returns>An enumerator of <see cref="Marking"/>s in that category, in reverse order.</returns>
+    public ReverseMarkingEnumerator GetReverseEnumerator(MarkingCategories category)
+    {
+        var markings = new List<Marking>();
+        if (_markings.TryGetValue(category, out var listing))
+        {
+            markings = new(listing);
+        }
+
+        return new ReverseMarkingEnumerator(markings);
+    }
+
+    public bool CategoryEquals(MarkingCategories category, MarkingSet other)
+    {
+        if (!_markings.TryGetValue(category, out var markings)
+            || !other._markings.TryGetValue(category, out var markingsOther))
+        {
+            return false;
+        }
+
+        return markings.SequenceEqual(markingsOther);
+    }
+
+    public bool Equals(MarkingSet other)
+    {
+        foreach (var (category, _) in _markings)
+        {
+            if (!CategoryEquals(category, other))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    ///     Gets a difference of marking categories between two marking sets
+    /// </summary>
+    /// <param name="other">The other marking set.</param>
+    /// <returns>Enumerator of marking categories that were different between the two.</returns>
+    public IEnumerable<MarkingCategories> CategoryDifference(MarkingSet other)
+    {
+        foreach (var (category, _) in _markings)
+        {
+            if (!CategoryEquals(category, other))
+            {
+                yield return category;
+            }
+        }
+    }
+}
+
+public sealed class ForwardMarkingEnumerator : IEnumerable<Marking>
+{
+    private List<Marking> _markings;
+
+    public ForwardMarkingEnumerator(List<Marking> markings)
+    {
+        _markings = markings;
+    }
+
+    public IEnumerator<Marking> GetEnumerator()
+    {
+        return new MarkingsEnumerator(_markings, false);
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return GetEnumerator();
+    }
+}
+
+public sealed class ReverseMarkingEnumerator : IEnumerable<Marking>
+{
+    private List<Marking> _markings;
+
+    public ReverseMarkingEnumerator(List<Marking> markings)
+    {
+        _markings = markings;
+    }
+
+    public IEnumerator<Marking> GetEnumerator()
+    {
+        return new MarkingsEnumerator(_markings, true);
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return GetEnumerator();
+    }
+}
+
+public sealed class MarkingsEnumerator : IEnumerator<Marking>
+{
+    private List<Marking> _markings;
+    private bool _reverse;
+
+    int position;
+
+    public MarkingsEnumerator(List<Marking> markings, bool reverse)
+    {
+        _markings = markings;
+        _reverse = reverse;
+
+        if (_reverse)
+        {
+            position = _markings.Count;
+        }
+        else
+        {
+            position = -1;
+        }
+    }
+
+    public bool MoveNext()
+    {
+        if (_reverse)
+        {
+            position--;
+            return (position >= 0);
+        }
+        else
+        {
+            position++;
+            return (position < _markings.Count);
+        }
+    }
+
+    public void Reset()
+    {
+        if (_reverse)
+        {
+            position = _markings.Count;
+        }
+        else
+        {
+            position = -1;
+        }
+    }
+
+    public void Dispose()
+    {}
+
+    object IEnumerator.Current
+    {
+        get => _markings[position];
+    }
+
+    public Marking Current
+    {
+        get => _markings[position];
+    }
+}

Content.Shared/Humanoid/Prototypes/HumanoidProfilePrototype.cs

@@ -0,0 +1,17 @@
+using Content.Shared.Preferences;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.Humanoid.Prototypes;
+
+[Prototype("humanoidProfile")]
+public sealed class HumanoidProfilePrototype : IPrototype
+{
+    [IdDataField]
+    public string ID { get; } = default!;
+
+    [DataField("customBaseLayers")]
+    public Dictionary<HumanoidVisualLayers, CustomBaseLayerInfo> CustomBaseLayers = new();
+
+    [DataField("profile")]
+    public HumanoidCharacterProfile Profile { get; } = HumanoidCharacterProfile.Default();
+}

Content.Shared/Humanoid/Prototypes/HumanoidSpritePrototypes.cs

@@ -0,0 +1,76 @@
+using Content.Shared.Humanoid.Markings;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.Humanoid.Prototypes;
+
+/// <summary>
+///     Base sprites for a species (e.g., what replaces the empty tagged layer,
+///     or settings per layer)
+/// </summary>
+[Prototype("speciesBaseSprites")]
+public sealed class HumanoidSpeciesBaseSpritesPrototype : IPrototype
+{
+     [IdDataField]
+     public string ID { get; } = default!;
+
+     /// <summary>
+     ///     Sprites that this species will use on the given humanoid
+     ///     visual layer. If a key entry is empty, it is assumed that the
+     ///     visual layer will not be in use on this species, and will
+     ///     be ignored.
+     /// </summary>
+     [DataField("sprites", required: true)]
+     public Dictionary<HumanoidVisualLayers, string> Sprites = new();
+}
+
+/// <summary>
+///     Humanoid species sprite layer. This is what defines the base layer of
+///     a humanoid species sprite, and also defines how markings can appear over
+///     that sprite (or at least, the layer this sprite is on).
+/// </summary>
+[Prototype("humanoidBaseSprite")]
+public sealed class HumanoidSpeciesSpriteLayer : IPrototype
+{
+    [IdDataField]
+    public string ID { get; } = default!;
+    /// <summary>
+    ///     The base sprite for this sprite layer. This is what
+    ///     will replace the empty layer tagged by the enum
+    ///     tied to this layer.
+    ///
+    ///     If this is null, no sprite will be displayed, and the
+    ///     layer will be invisible until otherwise set.
+    /// </summary>
+    [DataField("baseSprite")]
+    public SpriteSpecifier? BaseSprite { get; }
+
+    /// <summary>
+    ///     The alpha of this layer. Ensures that
+    ///     this layer will start with this percentage
+    ///     of alpha.
+    /// </summary>
+    [DataField("layerAlpha")]
+    public float LayerAlpha { get; } = 1.0f;
+
+    /// <summary>
+    ///     If this sprite layer should allow markings or not.
+    /// </summary>
+    [DataField("allowsMarkings")]
+    public bool AllowsMarkings { get; } = true;
+
+    /// <summary>
+    ///     If this layer should always match the
+    ///     skin tone in a character profile.
+    /// </summary>
+    [DataField("matchSkin")]
+    public bool MatchSkin { get; } = true;
+
+    /// <summary>
+    ///     If any markings that go on this layer should
+    ///     match the skin tone of this part, including
+    ///     alpha.
+    /// </summary>
+    [DataField("markingsMatchSkin")]
+    public bool MarkingsMatchSkin { get; }
+}

Content.Shared/Humanoid/Prototypes/SpeciesPrototype.cs

@@ -0,0 +1,88 @@
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
+
+namespace Content.Shared.Humanoid.Prototypes;
+
+[Prototype("species")]
+public sealed class SpeciesPrototype : IPrototype
+{
+    /// <summary>
+    /// Prototype ID of the species.
+    /// </summary>
+    [IdDataField]
+    public string ID { get; } = default!;
+
+    /// <summary>
+    /// User visible name of the species.
+    /// </summary>
+    [DataField("name", required: true)]
+    public string Name { get; } = default!;
+
+    /// <summary>
+    ///     Descriptor. Unused...? This is intended
+    ///     for an eventual integration into IdentitySystem
+    ///     (i.e., young human person, young lizard person, etc.)
+    /// </summary>
+    [DataField("descriptor")]
+    public string Descriptor { get; } = "humanoid";
+
+    /// <summary>
+    /// Whether the species is available "at round start" (In the character editor)
+    /// </summary>
+    [DataField("roundStart", required: true)]
+    public bool RoundStart { get; } = false;
+
+    // The below two are to avoid fetching information about the species from the entity
+    // prototype.
+
+    // This one here is a utility field, and is meant to *avoid* having to duplicate
+    // the massive SpriteComponent found in every species.
+    // Species implementors can just override SpriteComponent if they want a custom
+    // sprite layout, and leave this null. Keep in mind that this will disable
+    // sprite accessories.
+
+    [DataField("sprites")]
+    public string SpriteSet { get; } = default!;
+
+    /// <summary>
+    ///     The limit of body markings that you can place on this species.
+    /// </summary>
+    [DataField("markingLimits")]
+    public string MarkingPoints { get; } = default!;
+
+    /// <summary>
+    ///     Humanoid species variant used by this entity.
+    /// </summary>
+    [DataField("prototype", required: true, customTypeSerializer:typeof(PrototypeIdSerializer<EntityPrototype>))]
+    public string Prototype { get; } = default!;
+
+    /// <summary>
+    /// Prototype used by the species for the dress-up doll in various menus.
+    /// </summary>
+    [DataField("dollPrototype", required: true, customTypeSerializer:typeof(PrototypeIdSerializer<EntityPrototype>))]
+    public string DollPrototype { get; } = default!;
+
+    /// <summary>
+    /// Method of skin coloration used by the species.
+    /// </summary>
+    [DataField("skinColoration", required: true)]
+    public HumanoidSkinColor SkinColoration { get; }
+
+    [DataField("maleFirstNames")]
+    public string MaleFirstNames { get; } = "names_first_male";
+
+    [DataField("femaleFirstNames")]
+    public string FemaleFirstNames { get; } = "names_first_female";
+
+    [DataField("lastNames")]
+    public string LastNames { get; } = "names_last";
+
+    [DataField("naming")]
+    public SpeciesNaming Naming { get; } = SpeciesNaming.FirstLast;
+}
+
+public enum SpeciesNaming : byte
+{
+    FirstLast,
+    FirstDashFirst,
+}

Content.Shared/Humanoid/Sex.cs

@@ -0,0 +1,62 @@
+using Content.Shared.Dataset;
+using Content.Shared.Humanoid.Prototypes;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+
+namespace Content.Shared.Humanoid
+{
+    public enum Sex : byte
+    {
+        Male,
+        Female
+    }
+
+    public static class SexExtensions
+    {
+        public static string GetName(this Sex sex, string species, IPrototypeManager? prototypeManager = null, IRobustRandom? random = null)
+        {
+            IoCManager.Resolve(ref prototypeManager);
+            IoCManager.Resolve(ref random);
+
+            // if they have an old species or whatever just fall back to human I guess?
+            // Some downstream is probably gonna have this eventually but then they can deal with fallbacks.
+            if (!prototypeManager.TryIndex(species, out SpeciesPrototype? speciesProto))
+            {
+                speciesProto = prototypeManager.Index<SpeciesPrototype>("Human");
+                Logger.Warning($"Unable to find species {species} for name, falling back to Human");
+            }
+
+            switch (speciesProto.Naming)
+            {
+                case SpeciesNaming.FirstDashFirst:
+                    return $"{GetFirstName(sex, speciesProto, prototypeManager, random)}-{GetFirstName(sex, speciesProto, prototypeManager, random)}";
+                case SpeciesNaming.FirstLast:
+                default:
+                    return $"{GetFirstName(sex, speciesProto, prototypeManager, random)} {GetLastName(sex, speciesProto, prototypeManager, random)}";
+            }
+        }
+
+        public static string GetFirstName(this Sex sex, SpeciesPrototype speciesProto, IPrototypeManager? protoManager = null, IRobustRandom? random = null)
+        {
+            IoCManager.Resolve(ref protoManager);
+            IoCManager.Resolve(ref random);
+
+            switch (sex)
+            {
+                case Sex.Male:
+                    return random.Pick(protoManager.Index<DatasetPrototype>(speciesProto.MaleFirstNames).Values);
+                case Sex.Female:
+                    return random.Pick(protoManager.Index<DatasetPrototype>(speciesProto.FemaleFirstNames).Values);
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+        }
+
+        public static string GetLastName(this Sex sex, SpeciesPrototype speciesProto, IPrototypeManager? protoManager = null, IRobustRandom? random = null)
+        {
+            IoCManager.Resolve(ref protoManager);
+            IoCManager.Resolve(ref random);
+            return random.Pick(protoManager.Index<DatasetPrototype>(speciesProto.LastNames).Values);
+        }
+    }
+}

Content.Shared/Humanoid/SharedHumanoidComponent.cs

@@ -0,0 +1,62 @@
+using System.Linq;
+using Content.Shared.Humanoid.Prototypes;
+using Content.Shared.Preferences;
+using Robust.Shared.Enums;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
+
+namespace Content.Shared.Humanoid;
+
+public abstract class SharedHumanoidComponent : Component
+{
+    /// <summary>
+    ///     Current species. Dictates things like base body sprites,
+    ///     base humanoid to spawn, etc.
+    /// </summary>
+    [DataField("species", customTypeSerializer: typeof(PrototypeIdSerializer<SpeciesPrototype>))]
+    public string Species { get; set; } = default!;
+
+    /// <summary>
+    ///     The initial profile and base layers to apply to this humanoid.
+    /// </summary>
+    [DataField("initial", customTypeSerializer: typeof(PrototypeIdSerializer<HumanoidProfilePrototype>))]
+    public string Initial { get; } = default!;
+
+    /// <summary>
+    ///     Skin color of this humanoid.
+    /// </summary>
+    [DataField("skinColor")]
+    public Color SkinColor { get; set;  } = Color.FromHex("#C0967F");
+
+    /// <summary>
+    ///     Visual layers currently hidden. This will affect the base sprite
+    ///     on this humanoid layer, and any markings that sit above it.
+    /// </summary>
+    [ViewVariables] public readonly HashSet<HumanoidVisualLayers> HiddenLayers = new();
+
+    [DataField("sex")] public Sex Sex = Sex.Male;
+}
+
+[DataDefinition]
+[Serializable, NetSerializable]
+public sealed class CustomBaseLayerInfo
+{
+    public CustomBaseLayerInfo(string id, Color color)
+    {
+        ID = id;
+        Color = color;
+    }
+
+    /// <summary>
+    ///     ID of this custom base layer. Must be a <see cref="HumanoidSpeciesSpriteLayer"/>.
+    /// </summary>
+    [DataField("id")]
+    public string ID { get; }
+
+    /// <summary>
+    ///     Color of this custom base layer.
+    /// </summary>
+    [DataField("color")]
+    public Color Color { get; }
+}

Content.Shared/Humanoid/SharedHumanoidMarkingModifierSystem.cs

@@ -0,0 +1,55 @@
+using Content.Shared.Humanoid.Markings;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Humanoid;
+
+[Serializable, NetSerializable]
+public enum HumanoidMarkingModifierKey
+{
+    Key
+}
+
+[Serializable, NetSerializable]
+public sealed class HumanoidMarkingModifierMarkingSetMessage : BoundUserInterfaceMessage
+{
+    public MarkingSet MarkingSet { get; }
+    public bool ResendState { get; }
+
+    public HumanoidMarkingModifierMarkingSetMessage(MarkingSet set, bool resendState)
+    {
+        MarkingSet = set;
+        ResendState = resendState;
+    }
+}
+
+[Serializable, NetSerializable]
+public sealed class HumanoidMarkingModifierBaseLayersSetMessage : BoundUserInterfaceMessage
+{
+    public HumanoidMarkingModifierBaseLayersSetMessage(HumanoidVisualLayers layer, CustomBaseLayerInfo? info, bool resendState)
+    {
+        Layer = layer;
+        Info = info;
+        ResendState = resendState;
+    }
+
+    public HumanoidVisualLayers Layer { get; }
+    public CustomBaseLayerInfo? Info { get; }
+    public bool ResendState { get; }
+}
+
+[Serializable, NetSerializable]
+public sealed class HumanoidMarkingModifierState : BoundUserInterfaceState
+{
+    public HumanoidMarkingModifierState(MarkingSet markingSet, string species, Color skinColor, Dictionary<HumanoidVisualLayers, CustomBaseLayerInfo> customBaseLayers)
+    {
+        MarkingSet = markingSet;
+        Species = species;
+        SkinColor = skinColor;
+        CustomBaseLayers = customBaseLayers;
+    }
+
+    public MarkingSet MarkingSet { get; }
+    public string Species { get; }
+    public Color SkinColor { get; }
+    public Dictionary<HumanoidVisualLayers, CustomBaseLayerInfo> CustomBaseLayers { get; }
+}

Content.Shared/Humanoid/SharedHumanoidSystem.cs

@@ -0,0 +1,45 @@
+using Content.Shared.Humanoid.Markings;
+using Content.Shared.Preferences;
+
+namespace Content.Shared.Humanoid;
+
+/// <summary>
+///     HumanoidSystem. Primarily deals with the appearance and visual data
+///     of a humanoid entity. HumanoidVisualizer is what deals with actually
+///     organizing the sprites and setting up the sprite component's layers.
+///
+///     This is a shared system, because while it is server authoritative,
+///     you still need a local copy so that players can set up their
+///     characters.
+/// </summary>
+public abstract class SharedHumanoidSystem : EntitySystem
+{
+    [Dependency] private SharedAppearanceSystem _appearance = default!;
+
+    public const string DefaultSpecies = "Human";
+
+    public void SetAppearance(EntityUid uid,
+        string species,
+        Dictionary<HumanoidVisualLayers, CustomBaseLayerInfo> customBaseLayer,
+        Color skinColor,
+        List<HumanoidVisualLayers> visLayers,
+        List<Marking> markings)
+    {
+        var data = new HumanoidVisualizerData(species, customBaseLayer, skinColor, visLayers, markings);
+
+        // Locally raise an event for this, because there might be some systems interested
+        // in this.
+        RaiseLocalEvent(uid, new HumanoidAppearanceUpdateEvent(data), true);
+        _appearance.SetData(uid, HumanoidVisualizerKey.Key, data);
+    }
+}
+
+public sealed class HumanoidAppearanceUpdateEvent : EntityEventArgs
+{
+    public HumanoidVisualizerData Data { get; }
+
+    public HumanoidAppearanceUpdateEvent(HumanoidVisualizerData data)
+    {
+        Data = data;
+    }
+}

Content.Shared/Humanoid/SkinColor.cs

@@ -0,0 +1,147 @@
+namespace Content.Shared.Humanoid;
+
+public static class SkinColor
+{
+    public static Color ValidHumanSkinTone => Color.FromHsv(new Vector4(0.25f, 0.2f, 1f, 1f));
+
+    /// <summary>
+    ///     Turn a color into a valid tinted hue skin tone.
+    /// </summary>
+    /// <param name="color">The color to validate</param>
+    /// <returns>Validated tinted hue skin tone</returns>
+    public static Color ValidTintedHuesSkinTone(Color color)
+    {
+        return TintedHues(color);
+    }
+
+    /// <summary>
+    ///     Get a human skin tone based on a scale of 0 to 100.
+    /// </summary>
+    /// <param name="tone">Skin tone. Valid range is 0 to 100, inclusive. 0 is gold/yellowish, 100 is dark brown.</param>
+    /// <returns>A human skin tone.</returns>
+    /// <exception cref="ArgumentException">Exception if the value is under 0 or over 100.</exception>
+    public static Color HumanSkinTone(int tone)
+    {
+        // 0 - 100, 0 being gold/yellowish and 100 being dark
+        // HSV based
+        //
+        // 0 - 20 changes the hue
+        // 20 - 100 changes the value
+        // 0 is 45 - 20 - 100
+        // 20 is 25 - 20 - 100
+        // 100 is 25 - 100 - 20
+
+        if (tone < 0 || tone > 100)
+        {
+            throw new ArgumentException("Skin tone value was under 0 or over 100.");
+        }
+
+        var rangeOffset = tone - 20;
+
+        float hue = 25;
+        float sat = 20;
+        float val = 100;
+
+        if (rangeOffset <= 0)
+        {
+            hue += Math.Abs(rangeOffset);
+        }
+        else
+        {
+            sat += rangeOffset;
+            val -= rangeOffset;
+        }
+
+        var color = Color.FromHsv(new Vector4(hue / 360, sat / 100, val / 100, 1.0f));
+
+        return color;
+    }
+
+    /// <summary>
+    ///     Gets a human skin tone from a given color.
+    /// </summary>
+    /// <param name="color"></param>
+    /// <returns></returns>
+    /// <remarks>
+    ///     Does not cause an exception if the color is not originally from the human color range.
+    ///     Instead, it will return the approximation of the skin tone value.
+    /// </remarks>
+    public static float HumanSkinToneFromColor(Color color)
+    {
+        var hsv = Color.ToHsv(color);
+        // check for hue/value first, if hue is lower than this percentage
+        // and value is 1.0
+        // then it'll be hue
+        if (Math.Clamp(hsv.X, 25f / 360f, 1) > 25f / 360f
+            && hsv.Z == 1.0)
+        {
+            return Math.Abs(45 - (hsv.X * 360));
+        }
+        // otherwise it'll directly be the saturation
+        else
+        {
+            return hsv.Y * 100;
+        }
+    }
+
+    /// <summary>
+    ///     Verify if a color is in the human skin tone range.
+    /// </summary>
+    /// <param name="color">The color to verify</param>
+    /// <returns>True if valid, false otherwise.</returns>
+    public static bool VerifyHumanSkinTone(Color color)
+    {
+        var colorValues = Color.ToHsv(color);
+
+        var hue = colorValues.X * 360f;
+        var sat = colorValues.Y * 100f;
+        var val = colorValues.Z * 100f;
+        // rangeOffset makes it so that this value
+        // is 25 <= hue <= 45
+        if (hue < 25 || hue > 45)
+        {
+            return false;
+        }
+
+        // rangeOffset makes it so that these two values
+        // are 20 <= sat <= 100 and 20 <= val <= 100
+        // where saturation increases to 100 and value decreases to 20
+        if (sat < 20 || val < 20)
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    ///     Convert a color to the 'tinted hues' skin tone type.
+    /// </summary>
+    /// <param name="color">Color to convert</param>
+    /// <returns>Tinted hue color</returns>
+    public static Color TintedHues(Color color)
+    {
+        var newColor = Color.ToHsv(color);
+        newColor.Y = .1f;
+
+        return Color.FromHsv(newColor);
+    }
+
+    /// <summary>
+    ///     Verify if this color is a valid tinted hue color type, or not.
+    /// </summary>
+    /// <param name="color">The color to verify</param>
+    /// <returns>True if valid, false otherwise</returns>
+    public static bool VerifyTintedHues(Color color)
+    {
+        // tinted hues just ensures saturation is always .1, or 10% saturation at all times
+        return Color.ToHsv(color).Y != .1f;
+    }
+}
+
+public enum HumanoidSkinColor : byte
+{
+    HumanToned,
+    Hues,
+    TintedHues, //This gives a color tint to a humanoid's skin (10% saturation with full hue range).
+}