From a30cae21f632a86459a15cc5feb6e20c597af645 Mon Sep 17 00:00:00 2001
From: Flipp Syder <76629141+vulppine@users.noreply.github.com>
Date: Thu, 5 May 2022 01:07:42 -0700
Subject: [PATCH] Markings (#7072)

Co-authored-by: metalgearsloth <31366439+metalgearsloth@users.noreply.github.com>
Co-authored-by: metalgearsloth <comedian_vs_clown@hotmail.com>
---
 .../Systems/HumanoidAppearanceSystem.cs       |   11 +-
 Content.Client/Markings/MarkingPicker.xaml    |   28 +
 Content.Client/Markings/MarkingPicker.xaml.cs |  439 +++++++
 Content.Client/Markings/MarkingsSystem.cs     |  162 +++
 .../Preferences/UI/HumanoidProfileEditor.xaml |   12 +-
 .../UI/HumanoidProfileEditor.xaml.cs          |  120 +-
 ...20220310173734_SpeciesMarkings.Designer.cs | 1040 +++++++++++++++++
 .../20220310173734_SpeciesMarkings.cs         |   26 +
 .../PostgresServerDbContextModelSnapshot.cs   |    5 +
 ...20220310173728_SpeciesMarkings.Designer.cs |  989 ++++++++++++++++
 .../Sqlite/20220310173728_SpeciesMarkings.cs  |   26 +
 .../SqliteServerDbContextModelSnapshot.cs     |    5 +
 Content.Server.Database/Model.cs              |    1 +
 Content.Server/Database/ServerDbBase.cs       |   29 +-
 .../HumanoidCharacterAppearance.cs            |   40 +-
 .../HumanoidVisualLayers.cs                   |    7 +-
 .../HumanoidVisualLayersExtension.cs          |    7 +-
 Content.Shared/Entry/EntryPoint.cs            |    2 +
 Content.Shared/IoC/SharedContentIoC.cs        |    2 +
 Content.Shared/Markings/Marking.cs            |  105 ++
 Content.Shared/Markings/MarkingCategories.cs  |   19 +
 Content.Shared/Markings/MarkingManager.cs     |   68 ++
 Content.Shared/Markings/MarkingPrototype.cs   |   39 +
 Content.Shared/Markings/MarkingsComponent.cs  |   58 +
 Content.Shared/Markings/MarkingsSet.cs        |  283 +++++
 .../Preferences/HumanoidCharacterProfile.cs   |    2 +-
 Content.Shared/Species/SpeciesPrototype.cs    |    2 -
 .../Server/Preferences/ServerDbSqliteTests.cs |    4 +-
 Resources/Locale/en-US/markings/cat.ftl       |    2 +
 Resources/Locale/en-US/markings/reptilian.ftl |   41 +
 .../ui/humanoid-profile-editor.ftl            |    1 +
 .../en-US/preferences/ui/markings-picker.ftl  |   20 +
 .../Mobs/Customization/Markings/cat_parts.yml |   19 +
 .../Mobs/Customization/Markings/reptilian.yml |  130 +++
 .../Entities/Mobs/Species/human.yml           |    9 +
 .../Entities/Mobs/Species/reptilian.yml       |   89 +-
 .../cat_parts.rsi/ears_cat_inner.png          |  Bin 0 -> 5181 bytes
 .../cat_parts.rsi/ears_cat_outer.png          |  Bin 0 -> 5836 bytes
 .../Customization/cat_parts.rsi/meta.json     |    2 +
 .../Customization/cat_parts.rsi/tail_cat.png  |  Bin 0 -> 247 bytes
 .../masking_helpers.rsi/meta.json             |    2 +-
 .../masking_helpers.rsi/none.png              |  Bin 0 -> 83 bytes
 .../reptilian_parts.rsi/meta.json             |   16 +
 .../reptilian_parts.rsi/tail_dtiger.png       |  Bin 0 -> 6716 bytes
 .../reptilian_parts.rsi/tail_ltiger.png       |  Bin 0 -> 7315 bytes
 .../reptilian_parts.rsi/tail_smooth.png       |  Bin 0 -> 7022 bytes
 .../reptilian_parts.rsi/tail_spikes.png       |  Bin 0 -> 6817 bytes
 47 files changed, 3785 insertions(+), 77 deletions(-)
 create mode 100644 Content.Client/Markings/MarkingPicker.xaml
 create mode 100644 Content.Client/Markings/MarkingPicker.xaml.cs
 create mode 100644 Content.Client/Markings/MarkingsSystem.cs
 create mode 100644 Content.Server.Database/Migrations/Postgres/20220310173734_SpeciesMarkings.Designer.cs
 create mode 100644 Content.Server.Database/Migrations/Postgres/20220310173734_SpeciesMarkings.cs
 create mode 100644 Content.Server.Database/Migrations/Sqlite/20220310173728_SpeciesMarkings.Designer.cs
 create mode 100644 Content.Server.Database/Migrations/Sqlite/20220310173728_SpeciesMarkings.cs
 create mode 100644 Content.Shared/Markings/Marking.cs
 create mode 100644 Content.Shared/Markings/MarkingCategories.cs
 create mode 100644 Content.Shared/Markings/MarkingManager.cs
 create mode 100644 Content.Shared/Markings/MarkingPrototype.cs
 create mode 100644 Content.Shared/Markings/MarkingsComponent.cs
 create mode 100644 Content.Shared/Markings/MarkingsSet.cs
 create mode 100644 Resources/Locale/en-US/markings/cat.ftl
 create mode 100644 Resources/Locale/en-US/markings/reptilian.ftl
 create mode 100644 Resources/Locale/en-US/preferences/ui/markings-picker.ftl
 create mode 100644 Resources/Prototypes/Entities/Mobs/Customization/Markings/cat_parts.yml
 create mode 100644 Resources/Prototypes/Entities/Mobs/Customization/Markings/reptilian.yml
 create mode 100644 Resources/Textures/Mobs/Customization/cat_parts.rsi/ears_cat_inner.png
 create mode 100644 Resources/Textures/Mobs/Customization/cat_parts.rsi/ears_cat_outer.png
 create mode 100644 Resources/Textures/Mobs/Customization/cat_parts.rsi/meta.json
 create mode 100644 Resources/Textures/Mobs/Customization/cat_parts.rsi/tail_cat.png
 create mode 100644 Resources/Textures/Mobs/Customization/masking_helpers.rsi/none.png
 create mode 100644 Resources/Textures/Mobs/Customization/reptilian_parts.rsi/tail_dtiger.png
 create mode 100644 Resources/Textures/Mobs/Customization/reptilian_parts.rsi/tail_ltiger.png
 create mode 100644 Resources/Textures/Mobs/Customization/reptilian_parts.rsi/tail_smooth.png
 create mode 100644 Resources/Textures/Mobs/Customization/reptilian_parts.rsi/tail_spikes.png

diff --git a/Content.Client/CharacterAppearance/Systems/HumanoidAppearanceSystem.cs b/Content.Client/CharacterAppearance/Systems/HumanoidAppearanceSystem.cs
index fbb4940ced..328d4f0e62 100644
--- a/Content.Client/CharacterAppearance/Systems/HumanoidAppearanceSystem.cs
+++ b/Content.Client/CharacterAppearance/Systems/HumanoidAppearanceSystem.cs
@@ -22,13 +22,13 @@ namespace Content.Client.CharacterAppearance.Systems
             SubscribeLocalEvent<HumanoidAppearanceBodyPartRemovedEvent>(BodyPartRemoved);
         }
 
-        private readonly HumanoidVisualLayers[] _bodyPartLayers = {
+        public readonly static HumanoidVisualLayers[] BodyPartLayers = {
             HumanoidVisualLayers.Chest,
             HumanoidVisualLayers.Head,
             HumanoidVisualLayers.Snout,
-            HumanoidVisualLayers.Frills,
-            HumanoidVisualLayers.TailBehind,
-            HumanoidVisualLayers.TailFront,
+            HumanoidVisualLayers.HeadTop,
+            HumanoidVisualLayers.HeadSide,
+            HumanoidVisualLayers.Tail,
             HumanoidVisualLayers.Eyes,
             HumanoidVisualLayers.RArm,
             HumanoidVisualLayers.LArm,
@@ -94,10 +94,11 @@ namespace Content.Client.CharacterAppearance.Systems
                 sprite.LayerSetSprite(facialLayer, facialHairPrototype.Sprite);
             }
 
-            foreach (var layer in _bodyPartLayers)
+            foreach (var layer in BodyPartLayers)
             {
                 // Not every mob may have the furry layers hence we just skip it.
                 if (!sprite.LayerMapTryGet(layer, out var actualLayer)) continue;
+                if (!sprite[actualLayer].Visible) continue;
 
                 sprite.LayerSetColor(actualLayer, component.Appearance.SkinColor);
             }
diff --git a/Content.Client/Markings/MarkingPicker.xaml b/Content.Client/Markings/MarkingPicker.xaml
new file mode 100644
index 0000000000..193a8796cd
--- /dev/null
+++ b/Content.Client/Markings/MarkingPicker.xaml
@@ -0,0 +1,28 @@
+<Control xmlns="https://spacestation14.io">
+    <!-- Primary container -->
+    <BoxContainer Orientation="Vertical" HorizontalExpand="True">
+        <!-- Marking lists -->
+        <BoxContainer Orientation="Horizontal" SeparationOverride="5" HorizontalExpand="True">
+            <!-- Unused markings -->
+            <BoxContainer Orientation="Vertical" HorizontalExpand="True">
+                <Label Text="{Loc 'markings-unused'}" />
+                <OptionButton Name="CMarkingCategoryButton" />
+                <ItemList Name="CMarkingsUnused" VerticalExpand="True" MinSize="300 250" />
+                <Label Name="CMarkingPoints" Text="uwu" />
+                <Button Name="CMarkingAdd" Text="{Loc 'markings-add'}" />
+            </BoxContainer>
+            <!-- Used markings -->
+            <BoxContainer Orientation="Vertical" HorizontalExpand="True">
+                <Label Text="{Loc 'markings-used'}" />
+                <ItemList Name="CMarkingsUsed" VerticalExpand="True" MinSize="300 250" />
+                <BoxContainer Orientation="Horizontal" SeparationOverride="5">
+                    <Button Name="CMarkingRankUp" Text="{Loc 'markings-rank-up'}" HorizontalExpand="True" />
+                    <Button Name="CMarkingRankDown" Text="{Loc 'markings-rank-down'}" HorizontalExpand="True" />
+                </BoxContainer>
+                <Button Name="CMarkingRemove" Text="{Loc 'markings-remove'}" />
+            </BoxContainer>
+        </BoxContainer>
+        <!-- Colors -->
+        <BoxContainer Name="CMarkingColors" Orientation="Vertical" Visible="False" />
+    </BoxContainer>
+</Control>
diff --git a/Content.Client/Markings/MarkingPicker.xaml.cs b/Content.Client/Markings/MarkingPicker.xaml.cs
new file mode 100644
index 0000000000..50a4e04dc9
--- /dev/null
+++ b/Content.Client/Markings/MarkingPicker.xaml.cs
@@ -0,0 +1,439 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Content.Client.CharacterAppearance;
+using Content.Client.Stylesheets;
+using Content.Shared.CharacterAppearance;
+using Content.Shared.Markings;
+using Content.Shared.Species;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Client.Utility;
+using Robust.Shared.IoC;
+using Robust.Shared.Localization;
+using Robust.Shared.Log;
+using Robust.Shared.Maths;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+using static Robust.Client.UserInterface.Controls.BoxContainer;
+
+namespace Content.Client.Markings
+{
+    [GenerateTypedNameReferences]
+    public sealed partial class MarkingPicker : Control
+    {
+        [Dependency] private readonly MarkingManager _markingManager = default!;
+        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
+        public Action<MarkingsSet>? OnMarkingAdded;
+        public Action<MarkingsSet>? OnMarkingRemoved;
+        public Action<MarkingsSet>? OnMarkingColorChange;
+        public Action<MarkingsSet>? OnMarkingRankChange;
+
+        private List<Color> _currentMarkingColors = new();
+
+        private Dictionary<MarkingCategories, MarkingPoints> PointLimits = new();
+        private Dictionary<MarkingCategories, MarkingPoints> PointsUsed = new();
+
+        private ItemList.Item? _selectedMarking;
+        private ItemList.Item? _selectedUnusedMarking;
+        private MarkingCategories _selectedMarkingCategory = MarkingCategories.Chest;
+
+        private MarkingsSet _currentMarkings = new();
+
+        private List<MarkingCategories> _markingCategories = Enum.GetValues<MarkingCategories>().ToList();
+
+        private string _currentSpecies = SpeciesManager.DefaultSpecies;
+
+        public void SetData(MarkingsSet newMarkings, string species)
+        {
+            _currentMarkings = newMarkings;
+            _currentSpecies = species;
+
+            // Should marking limits be dependent on species prototypes,
+            // or should it be dependent on the entity the
+            // species contains? Having marking points as a part of
+            // the component allows for any arbitrary thing to have
+            // a marking (at this point, it's practically a sprite decoration),
+            // but having it as a part of a species makes markings instead
+            // be dependent on humanoid variants for constraints
+            SpeciesPrototype speciesPrototype = _prototypeManager.Index<SpeciesPrototype>(species);
+            EntityPrototype body = _prototypeManager.Index<EntityPrototype>(speciesPrototype.Prototype);
+
+            body.TryGetComponent("Markings", out MarkingsComponent? markingsComponent);
+
+            PointLimits = markingsComponent!.LayerPoints;
+            PointsUsed = MarkingPoints.CloneMarkingPointDictionary(PointLimits);
+
+            Populate();
+            PopulateUsed();
+        }
+
+        public MarkingPicker()
+        {
+            RobustXamlLoader.Load(this);
+            IoCManager.InjectDependencies(this);
+
+            for (int i = 0; i < _markingCategories.Count; i++)
+            {
+                CMarkingCategoryButton.AddItem(Loc.GetString($"markings-category-{_markingCategories[i].ToString()}"), i);
+            }
+            CMarkingCategoryButton.SelectId(_markingCategories.IndexOf(MarkingCategories.Chest));
+            CMarkingCategoryButton.OnItemSelected +=  OnCategoryChange;
+            CMarkingsUnused.OnItemSelected += item =>
+               _selectedUnusedMarking = CMarkingsUnused[item.ItemIndex];
+
+            CMarkingAdd.OnPressed += args =>
+                MarkingAdd();
+
+            CMarkingsUsed.OnItemSelected += OnUsedMarkingSelected;
+
+            CMarkingRemove.OnPressed += args =>
+                MarkingRemove();
+
+            CMarkingRankUp.OnPressed += _ => SwapMarkingUp();
+            CMarkingRankDown.OnPressed += _ => SwapMarkingDown();
+        }
+
+        private string GetMarkingName(MarkingPrototype marking) => Loc.GetString($"marking-{marking.ID}");
+        private List<string> GetMarkingStateNames(MarkingPrototype marking)
+        {
+            List<string> result = new();
+            foreach (var markingState in marking.Sprites)
+            {
+                switch (markingState)
+                {
+                    case SpriteSpecifier.Rsi rsi:
+                        result.Add(Loc.GetString($"marking-{marking.ID}-{rsi.RsiState}"));
+                        break;
+                    case SpriteSpecifier.Texture texture:
+                        result.Add(Loc.GetString($"marking-{marking.ID}-{texture.TexturePath.Filename}"));
+                        break;
+                }
+            }
+
+            return result;
+        }
+
+        public void Populate()
+        {
+            CMarkingsUnused.Clear();
+            _selectedUnusedMarking = null;
+
+            var markings = _markingManager.CategorizedMarkings();
+            foreach (var marking in markings[_selectedMarkingCategory])
+            {
+                if (_currentMarkings.Contains(marking.AsMarking())) continue;
+                if (marking.SpeciesRestrictions != null && !marking.SpeciesRestrictions.Contains(_currentSpecies)) continue;
+                var item = CMarkingsUnused.AddItem($"{GetMarkingName(marking)}", marking.Sprites[0].Frame0());
+                item.Metadata = marking;
+            }
+
+            if (PointsUsed.ContainsKey(_selectedMarkingCategory))
+            {
+                CMarkingPoints.Visible = true;
+            }
+            else
+            {
+                CMarkingPoints.Visible = false;
+            }
+        }
+
+        // Populate the used marking list. Returns a list of markings that weren't
+        // valid to add to the marking list.
+        public void PopulateUsed()
+        {
+            CMarkingsUsed.Clear();
+            CMarkingColors.Visible = false;
+            _selectedMarking = null;
+
+            // a little slower than the original process
+            // (the original method here had the logic
+            // tied with the presentation, which did it all
+            // in one go including display)
+            //
+            // BUT
+            //
+            // it's all client side
+            // so does it really matter???
+            //
+            // actual validation/filtering occurs server side, but
+            // it might be better to just have a Process function
+            // that just iterates through all the markings with
+            // a species and points dict to ensure that all markings
+            // that were given are valid?
+            //
+            // one of the larger issues is that this doesn't
+            // necessarily use the existing backing list, but rather it
+            // allocates entirely new lists instead to perform
+            // their functions, making a 'Process' function
+            // more desirable imo, since this isn't *really* used
+            // outside of this specific niche
+
+            var markings = new MarkingsSet(_currentMarkings);
+
+            // ensures all markings are valid
+            markings = MarkingsSet.EnsureValid(_currentMarkings, _markingManager);
+
+            // filters out all non-valid species markings
+            markings = MarkingsSet.FilterSpecies(_currentMarkings, _currentSpecies);
+
+            // processes all the points currently available
+            markings = MarkingsSet.ProcessPoints(_currentMarkings, PointsUsed);
+
+            // if the marking set has changed, invoke the event that involves changed marking sets
+            if (markings != _currentMarkings)
+            {
+                Logger.DebugS("Markings", "Marking set is different, resetting markings on dummy now");
+                _currentMarkings = markings;
+                OnMarkingRemoved?.Invoke(_currentMarkings);
+            }
+
+            IEnumerator markingEnumerator = _currentMarkings.GetReverseEnumerator();
+
+            // walk backwards through the list for visual purposes
+            while (markingEnumerator.MoveNext())
+            {
+                Marking marking = (Marking) markingEnumerator.Current;
+                var newMarking = _markingManager.Markings()[marking.MarkingId];
+                var _item = new ItemList.Item(CMarkingsUsed)
+                {
+                    Text = Loc.GetString("marking-used", ("marking-name", $"{GetMarkingName(newMarking)}"), ("marking-category", Loc.GetString($"markings-category-{newMarking.MarkingCategory}"))),
+                    Icon = newMarking.Sprites[0].Frame0(),
+                    Selectable = true,
+                    Metadata = newMarking,
+                    IconModulate = marking.MarkingColors[0]
+                };
+                CMarkingsUsed.Add(_item);
+            }
+
+            // since all the points have been processed, update the points visually
+            UpdatePoints();
+        }
+
+        private void SwapMarkingUp()
+        {
+            if (_selectedMarking == null)
+            {
+                return;
+            }
+
+            var i = CMarkingsUsed.IndexOf(_selectedMarking);
+            if (ShiftMarkingRank(i, -1))
+            {
+                OnMarkingRankChange?.Invoke(_currentMarkings);
+            }
+        }
+
+        private void SwapMarkingDown()
+        {
+            if (_selectedMarking == null)
+            {
+                return;
+            }
+
+            var i = CMarkingsUsed.IndexOf(_selectedMarking);
+            if (ShiftMarkingRank(i, 1))
+            {
+                OnMarkingRankChange?.Invoke(_currentMarkings);
+            }
+        }
+
+        private bool ShiftMarkingRank(int src, int places)
+        {
+            if (src + places >= CMarkingsUsed.Count || src + places < 0)
+            {
+                return false;
+            }
+
+            var visualDest = src + places; // what it would visually look like
+            var visualTemp = CMarkingsUsed[visualDest];
+            CMarkingsUsed[visualDest] = CMarkingsUsed[src];
+            CMarkingsUsed[src] = visualTemp;
+
+            switch (places)
+            {
+                // i.e., we're going down in rank
+                case < 0:
+                    _currentMarkings.ShiftRankDownFromEnd(src);
+                    break;
+                // i.e., we're going up in rank
+                case > 0:
+                    _currentMarkings.ShiftRankUpFromEnd(src);
+                    break;
+                // do nothing?
+                default:
+                    break;
+            }
+
+            return true;
+        }
+
+        // repopulate in case markings are restricted,
+        // and also filter out any markings that are now invalid
+        // attempt to preserve any existing markings as well:
+        // it would be frustrating to otherwise have all markings
+        // cleared, imo
+        public void SetSpecies(string species)
+        {
+            _currentSpecies = species;
+            var markingCount = _currentMarkings.Count;
+
+            SpeciesPrototype speciesPrototype = _prototypeManager.Index<SpeciesPrototype>(species);
+            EntityPrototype body = _prototypeManager.Index<EntityPrototype>(speciesPrototype.Prototype);
+
+            body.TryGetComponent("Markings", out MarkingsComponent? markingsComponent);
+
+            PointLimits = markingsComponent!.LayerPoints;
+            PointsUsed = MarkingPoints.CloneMarkingPointDictionary(PointLimits);
+
+            Populate();
+            PopulateUsed();
+        }
+
+        private void UpdatePoints()
+        {
+            if (PointsUsed.TryGetValue(_selectedMarkingCategory, out var pointsRemaining))
+            {
+                CMarkingPoints.Text = Loc.GetString("marking-points-remaining", ("points", pointsRemaining.Points));
+            }
+        }
+
+        private void OnCategoryChange(OptionButton.ItemSelectedEventArgs category)
+        {
+            CMarkingCategoryButton.SelectId(category.Id);
+            _selectedMarkingCategory = _markingCategories[category.Id];
+            Populate();
+            UpdatePoints();
+        }
+
+        // TODO: This should be using ColorSelectorSliders once that's merged, so
+        private void OnUsedMarkingSelected(ItemList.ItemListSelectedEventArgs item)
+        {
+            _selectedMarking = CMarkingsUsed[item.ItemIndex];
+            var prototype = (MarkingPrototype) _selectedMarking.Metadata!;
+
+            if (prototype.FollowSkinColor)
+            {
+                CMarkingColors.Visible = false;
+
+                return;
+            }
+
+            var stateNames = GetMarkingStateNames(prototype);
+            _currentMarkingColors.Clear();
+            CMarkingColors.DisposeAllChildren();
+            List<ColorSelectorSliders> colorSliders = new();
+            for (int i = 0; i < prototype.Sprites.Count; i++)
+            {
+                var colorContainer = new BoxContainer
+                {
+                    Orientation = LayoutOrientation.Vertical,
+                };
+
+                CMarkingColors.AddChild(colorContainer);
+
+                ColorSelectorSliders colorSelector = new ColorSelectorSliders();
+                colorSliders.Add(colorSelector);
+
+                colorContainer.AddChild(new Label { Text = $"{stateNames[i]} color:" });
+                colorContainer.AddChild(colorSelector);
+
+                var currentColor = new Color(
+                    _currentMarkings[_currentMarkings.Count - 1 - item.ItemIndex].MarkingColors[i].RByte,
+                    _currentMarkings[_currentMarkings.Count - 1 - item.ItemIndex].MarkingColors[i].GByte,
+                    _currentMarkings[_currentMarkings.Count - 1 - item.ItemIndex].MarkingColors[i].BByte
+                );
+                colorSelector.Color = currentColor;
+                _currentMarkingColors.Add(currentColor);
+                int colorIndex = _currentMarkingColors.IndexOf(currentColor);
+
+                Action<Color> colorChanged = delegate(Color color)
+                {
+                    _currentMarkingColors[colorIndex] = colorSelector.Color;
+
+                    ColorChanged(colorIndex);
+                };
+                colorSelector.OnColorChanged += colorChanged;
+            }
+
+            CMarkingColors.Visible = true;
+        }
+
+        private void ColorChanged(int colorIndex)
+        {
+            if (_selectedMarking is null) return;
+            var markingPrototype = (MarkingPrototype) _selectedMarking.Metadata!;
+            int markingIndex = _currentMarkings.FindIndexOf(markingPrototype.ID);
+
+            if (markingIndex < 0) return;
+
+            _selectedMarking.IconModulate = _currentMarkingColors[colorIndex];
+            _currentMarkings[markingIndex].SetColor(colorIndex, _currentMarkingColors[colorIndex]);
+            OnMarkingColorChange?.Invoke(_currentMarkings);
+        }
+
+        private void MarkingAdd()
+        {
+            if (_selectedUnusedMarking is null) return;
+
+            MarkingPrototype marking = (MarkingPrototype) _selectedUnusedMarking.Metadata!;
+
+            if (PointsUsed.TryGetValue(marking.MarkingCategory, out var points))
+            {
+                if (points.Points == 0)
+                {
+                    return;
+                }
+
+                points.Points--;
+            }
+
+            UpdatePoints();
+
+            _currentMarkings.AddBack(marking.AsMarking());
+
+            CMarkingsUnused.Remove(_selectedUnusedMarking);
+            var item = new ItemList.Item(CMarkingsUsed)
+            {
+                Text = Loc.GetString("marking-used", ("marking-name", $"{GetMarkingName(marking)}"), ("marking-category", Loc.GetString($"markings-category-{marking.MarkingCategory}"))),
+                Icon = marking.Sprites[0].Frame0(),
+                Selectable = true,
+                Metadata = marking,
+            };
+            CMarkingsUsed.Insert(0, item);
+
+            _selectedUnusedMarking = null;
+            OnMarkingAdded?.Invoke(_currentMarkings);
+        }
+
+        private void MarkingRemove()
+        {
+            if (_selectedMarking is null) return;
+
+            MarkingPrototype marking = (MarkingPrototype) _selectedMarking.Metadata!;
+
+            if (PointsUsed.TryGetValue(marking.MarkingCategory, out var points))
+            {
+                points.Points++;
+            }
+
+            UpdatePoints();
+
+            _currentMarkings.Remove(marking.AsMarking());
+            CMarkingsUsed.Remove(_selectedMarking);
+
+            if (marking.MarkingCategory == _selectedMarkingCategory)
+            {
+                var item = CMarkingsUnused.AddItem($"{GetMarkingName(marking)}", marking.Sprites[0].Frame0());
+                item.Metadata = marking;
+            }
+            _selectedMarking = null;
+            CMarkingColors.Visible = false;
+            OnMarkingRemoved?.Invoke(_currentMarkings);
+        }
+    }
+}
diff --git a/Content.Client/Markings/MarkingsSystem.cs b/Content.Client/Markings/MarkingsSystem.cs
new file mode 100644
index 0000000000..56bf347845
--- /dev/null
+++ b/Content.Client/Markings/MarkingsSystem.cs
@@ -0,0 +1,162 @@
+using System.Collections.Generic;
+using System.Linq;
+using Content.Client.CharacterAppearance.Systems;
+using Content.Shared.Markings;
+using Content.Shared.CharacterAppearance;
+using Content.Shared.CharacterAppearance.Systems;
+using Content.Shared.Preferences;
+using Robust.Client.GameObjects;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Log;
+using Robust.Shared.Utility;
+
+namespace Content.Client.Markings
+{
+    public sealed class MarkingsSystem : EntitySystem
+    {
+        [Dependency] private readonly MarkingManager _markingManager = default!;
+
+        public override void Initialize()
+        {
+            SubscribeLocalEvent<MarkingsComponent, SharedHumanoidAppearanceSystem.ChangedHumanoidAppearanceEvent>(UpdateMarkings);
+        }
+
+        public void ToggleMarkingVisibility(EntityUid uid, SpriteComponent body, HumanoidVisualLayers layer, bool toggle)
+        {
+            if(!EntityManager.TryGetComponent(uid, out MarkingsComponent? markings)) return;
+
+            if (markings.ActiveMarkings.TryGetValue(layer, out List<Marking>? layerMarkings))
+                foreach (Marking activeMarking in layerMarkings)
+                    body.LayerSetVisible(activeMarking.MarkingId, toggle);
+        }
+
+        public void SetActiveMarkings(EntityUid uid, MarkingsSet markingList, MarkingsComponent? markings = null)
+        {
+            if (!Resolve(uid, ref markings))
+            {
+                return;
+            }
+
+            markings.ActiveMarkings.Clear();
+
+            foreach (HumanoidVisualLayers layer in HumanoidAppearanceSystem.BodyPartLayers)
+            {
+                markings.ActiveMarkings.Add(layer, new List<Marking>());
+            }
+
+            foreach (var marking in markingList)
+            {
+                markings.ActiveMarkings[_markingManager.Markings()[marking.MarkingId].BodyPart].Add(marking);
+            }
+        }
+
+        public void UpdateMarkings(EntityUid uid, MarkingsComponent markings, SharedHumanoidAppearanceSystem.ChangedHumanoidAppearanceEvent args)
+        {
+            var appearance = args.Appearance;
+            if (!EntityManager.TryGetComponent(uid, out SpriteComponent? sprite)) return;
+            MarkingsSet totalMarkings = new MarkingsSet(appearance.Markings);
+
+            Dictionary<MarkingCategories, MarkingPoints> usedPoints = MarkingPoints.CloneMarkingPointDictionary(markings.LayerPoints);
+
+            var markingsEnumerator = appearance.Markings.GetReverseEnumerator();
+            // Reverse ordering
+            while (markingsEnumerator.MoveNext())
+            {
+                var marking = (Marking) markingsEnumerator.Current;
+                if (!_markingManager.IsValidMarking(marking, out MarkingPrototype? markingPrototype))
+                {
+                    continue;
+                }
+
+                if (usedPoints.TryGetValue(markingPrototype.MarkingCategory, out MarkingPoints? points))
+                {
+                    if (points.Points == 0)
+                    {
+                        continue;
+                    }
+
+                    points.Points--;
+                }
+
+                if (!sprite.LayerMapTryGet(markingPrototype.BodyPart, out int targetLayer))
+                {
+                    continue;
+                }
+
+                for (int j = 0; j < markingPrototype.Sprites.Count(); j++)
+                {
+                    var rsi = (SpriteSpecifier.Rsi) markingPrototype.Sprites[j];
+                    string layerId = $"{markingPrototype.ID}-{rsi.RsiState}";
+
+                    if (sprite.LayerMapTryGet(layerId, out var existingLayer))
+                    {
+                        sprite.RemoveLayer(existingLayer);
+                        sprite.LayerMapRemove(marking.MarkingId);
+                    }
+
+                    int layer = sprite.AddLayer(markingPrototype.Sprites[j], targetLayer + j + 1);
+                    sprite.LayerMapSet(layerId, layer);
+                    if (markingPrototype.FollowSkinColor)
+                    {
+                        sprite.LayerSetColor(layerId, appearance.SkinColor);
+                    }
+                    else
+                    {
+                        sprite.LayerSetColor(layerId, marking.MarkingColors[j]);
+                    }
+                }
+
+            }
+
+            // for each layer, check if it's required and
+            // if the points are greater than zero
+            //
+            // if so, then we start applying default markings
+            // until the point requirement is satisfied -
+            // this can also mean that a specific set of markings
+            // is applied on top of existing markings
+            //
+            // All default markings will follow the skin color of
+            // the current body.
+            foreach (var (layerType, points) in usedPoints)
+            {
+                if (points.Required && points.Points > 0)
+                {
+                    while (points.Points > 0)
+                    {
+                        // this all has to be checked, continues shouldn't occur because
+                        // points.Points needs to be subtracted
+                        if (points.DefaultMarkings.TryGetValue(points.Points - 1, out var marking)
+                                && _markingManager.Markings().TryGetValue(marking, out var markingPrototype)
+                                && markingPrototype.MarkingCategory == layerType // check if this actually belongs on this layer, too
+                                && sprite.LayerMapTryGet(markingPrototype.BodyPart, out int targetLayer))
+                        {
+                            for (int j = 0; j < markingPrototype.Sprites.Count(); j++)
+                            {
+                                var rsi = (SpriteSpecifier.Rsi) markingPrototype.Sprites[j];
+                                string layerId = $"{markingPrototype.ID}-{rsi.RsiState}";
+
+                                if (sprite.LayerMapTryGet(layerId, out var existingLayer))
+                                {
+                                    sprite.RemoveLayer(existingLayer);
+                                    sprite.LayerMapRemove(markingPrototype.ID);
+                                }
+
+                                int layer = sprite.AddLayer(markingPrototype.Sprites[j], targetLayer + j + 1);
+                                sprite.LayerMapSet(layerId, layer);
+                                sprite.LayerSetColor(layerId, appearance.SkinColor);
+                            }
+
+                            totalMarkings.AddBack(markingPrototype.AsMarking());
+                        }
+
+                        points.Points--;
+                    }
+                }
+            }
+
+            SetActiveMarkings(uid, totalMarkings, markings);
+        }
+    }
+}
diff --git a/Content.Client/Preferences/UI/HumanoidProfileEditor.xaml b/Content.Client/Preferences/UI/HumanoidProfileEditor.xaml
index 1dc9b1ed6b..f983aa68f2 100644
--- a/Content.Client/Preferences/UI/HumanoidProfileEditor.xaml
+++ b/Content.Client/Preferences/UI/HumanoidProfileEditor.xaml
@@ -1,7 +1,8 @@
 <Control xmlns="https://spacestation14.io"
          xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
          xmlns:magicmirror="clr-namespace:Content.Client.CharacterAppearance"
-         xmlns:prefUi="clr-namespace:Content.Client.Preferences.UI">
+         xmlns:prefUi="clr-namespace:Content.Client.Preferences.UI"
+         xmlns:markings="clr-namespace:Content.Client.Markings">
     <BoxContainer Orientation="Horizontal">
         <!-- Left side -->
         <BoxContainer Orientation="Vertical" Margin="10 10 10 10">
@@ -87,9 +88,10 @@
                             </BoxContainer>
                             <!-- Skin -->
                             <prefUi:HighlightedContainer>
-                                <BoxContainer HorizontalExpand="True">
+                                <BoxContainer HorizontalExpand="True" Orientation="Vertical">
                                     <Label Text="{Loc 'humanoid-profile-editor-skin-color-label'}" />
                                     <Slider HorizontalExpand="True" Name="CSkin" MinValue="0" MaxValue="100" Value="20" />
+                                    <BoxContainer Name="CRgbSkinColorContainer" Visible="False" Orientation="Vertical" HorizontalExpand="True"></BoxContainer>
                                 </BoxContainer>
                             </prefUi:HighlightedContainer>
                             <!-- Hair -->
@@ -136,6 +138,12 @@
                         <BoxContainer Name="CAntagList" Orientation="Vertical" />
                     </ScrollContainer>
                 </BoxContainer>
+                <BoxContainer Name="CMarkingsTab" Orientation="Vertical">
+                    <!-- Markings -->
+                    <ScrollContainer VerticalExpand="True">
+                        <markings:MarkingPicker Name="CMarkings" />
+                    </ScrollContainer>
+                </BoxContainer>
             </TabContainer>
         </BoxContainer>
         <!-- Right side -->
diff --git a/Content.Client/Preferences/UI/HumanoidProfileEditor.xaml.cs b/Content.Client/Preferences/UI/HumanoidProfileEditor.xaml.cs
index b039dd5ec8..381b9085a9 100644
--- a/Content.Client/Preferences/UI/HumanoidProfileEditor.xaml.cs
+++ b/Content.Client/Preferences/UI/HumanoidProfileEditor.xaml.cs
@@ -8,6 +8,7 @@ using Content.Client.Stylesheets;
 using Content.Shared.CharacterAppearance;
 using Content.Shared.CharacterAppearance.Systems;
 using Content.Shared.GameTicking;
+using Content.Shared.Markings;
 using Content.Shared.Preferences;
 using Content.Shared.Roles;
 using Content.Shared.Species;
@@ -91,8 +92,12 @@ namespace Content.Client.Preferences.UI
         private SpriteView? _previewSprite;
         private SpriteView? _previewSpriteSide;
 
+        private BoxContainer _rgbSkinColorContainer => CRgbSkinColorContainer;
+        private ColorSelectorSliders _rgbSkinColorSelector;
+
         private bool _isDirty;
         private bool _needUpdatePreview;
+        private bool _needsDummyRebuild;
         public int CharacterSlot;
         public HumanoidCharacterProfile? Profile;
 
@@ -194,7 +199,7 @@ namespace Content.Client.Preferences.UI
             {
                 CSpeciesButton.SelectId(args.Id);
                 SetSpecies(_speciesList[args.Id].ID);
-                OnSkinColorOnValueChanged(CSkin);
+                OnSkinColorOnValueChanged();
             };
 
             #endregion Species
@@ -209,7 +214,16 @@ namespace Content.Client.Preferences.UI
             // 0 is 45 - 20 - 100
             // 20 is 25 - 20 - 100
             // 100 is 25 - 100 - 20
-            _skinColor.OnValueChanged += OnSkinColorOnValueChanged;
+            _skinColor.OnValueChanged += _ =>
+            {
+                OnSkinColorOnValueChanged();
+            };
+
+            _rgbSkinColorContainer.AddChild(_rgbSkinColorSelector = new ColorSelectorSliders());
+            _rgbSkinColorSelector.OnColorChanged += _ =>
+            {
+                OnSkinColorOnValueChanged();
+            };
 
             #endregion
 
@@ -434,6 +448,16 @@ namespace Content.Client.Preferences.UI
 
             #endregion Save
 
+            #region Markings
+            _tabContainer.SetTabTitle(3, Loc.GetString("humanoid-profile-editor-markings-tab"));
+
+            CMarkings.OnMarkingAdded += OnMarkingChange;
+            CMarkings.OnMarkingRemoved += OnMarkingChange;
+            CMarkings.OnMarkingColorChange += OnMarkingChange;
+            CMarkings.OnMarkingRankChange += OnMarkingChange;
+
+            #endregion Markings
+
             #endregion Left
 
             if (preferencesManager.ServerDataLoaded)
@@ -443,10 +467,31 @@ namespace Content.Client.Preferences.UI
 
             preferencesManager.OnServerDataLoaded += LoadServerData;
 
+
             IsDirty = false;
         }
 
-        private void OnSkinColorOnValueChanged(Range range)
+        private void OnMarkingChange(MarkingsSet markings)
+        {
+            if (Profile is null)
+                return;
+
+            Profile = Profile.WithCharacterAppearance(Profile.Appearance.WithMarkings(markings));
+            NeedsDummyRebuild = true;
+            IsDirty = true;
+        }
+
+        private void OnMarkingColorChange(MarkingsSet markings)
+        {
+            if (Profile is null)
+                return;
+
+            Profile = Profile.WithCharacterAppearance(Profile.Appearance.WithMarkings(markings));
+            IsDirty = true;
+        }
+
+
+        private void OnSkinColorOnValueChanged()
         {
             if (Profile is null) return;
 
@@ -456,7 +501,14 @@ namespace Content.Client.Preferences.UI
             {
                 case SpeciesSkinColor.HumanToned:
                 {
-                    var rangeOffset = (int) range.Value - 20;
+                    var range = _skinColor.Value;
+                    if (!_skinColor.Visible)
+                    {
+                        _skinColor.Visible = true;
+                        _rgbSkinColorContainer.Visible = false;
+                    }
+
+                    var rangeOffset = (int) range - 20;
 
                     float hue = 25;
                     float sat = 20;
@@ -479,13 +531,20 @@ namespace Content.Client.Preferences.UI
                 }
                 case SpeciesSkinColor.Hues:
                 {
-                    var color = Color.FromHsv(new Vector4(range.Value / 100.0f, 1.0f, 1.0f, 1.0f));
+                    if (!_rgbSkinColorContainer.Visible)
+                    {
+                        _skinColor.Visible = false;
+                        _rgbSkinColorContainer.Visible = true;
+                    }
+
+                    var color = new Color(_rgbSkinColorSelector.Color.R, _rgbSkinColorSelector.Color.G, _rgbSkinColorSelector.Color.B);
                     Profile = Profile.WithCharacterAppearance(Profile.Appearance.WithSkinColor(color));
                     break;
                 }
             }
 
             IsDirty = true;
+            NeedsDummyRebuild = true; // ugh - fix this asap
         }
 
         protected override void Dispose(bool disposing)
@@ -557,6 +616,8 @@ namespace Content.Client.Preferences.UI
         {
             Profile = (HumanoidCharacterProfile) _preferencesManager.Preferences!.SelectedCharacter;
             CharacterSlot = _preferencesManager.Preferences.SelectedCharacterIndex;
+
+            NeedsDummyRebuild = true;
             UpdateControls();
         }
 
@@ -581,7 +642,9 @@ namespace Content.Client.Preferences.UI
         private void SetSpecies(string newSpecies)
         {
             Profile = Profile?.WithSpecies(newSpecies);
-            OnSkinColorOnValueChanged(CSkin); // Species may have special color prefs, make sure to update it.
+            OnSkinColorOnValueChanged(); // Species may have special color prefs, make sure to update it.
+            CMarkings.SetSpecies(newSpecies); // Repopulate the markings tab as well.
+            NeedsDummyRebuild = true;
             IsDirty = true;
         }
 
@@ -610,6 +673,7 @@ namespace Content.Client.Preferences.UI
             if (Profile != null)
             {
                 _preferencesManager.UpdateCharacter(Profile, CharacterSlot);
+                NeedsDummyRebuild = true;
                 OnProfileChanged?.Invoke(Profile, CharacterSlot);
             }
         }
@@ -625,6 +689,15 @@ namespace Content.Client.Preferences.UI
             }
         }
 
+        private bool NeedsDummyRebuild
+        {
+            get => _needsDummyRebuild;
+            set
+            {
+                _needsDummyRebuild = value;
+                _needUpdatePreview = true;
+            }
+        }
 
         private void UpdateNameEdit()
         {
@@ -650,12 +723,18 @@ namespace Content.Client.Preferences.UI
                 return;
 
             var skin = _prototypeManager.Index<SpeciesPrototype>(Profile.Species).SkinColoration;
-            var color = Color.ToHsv(Profile.Appearance.SkinColor);
 
             switch (skin)
             {
                 case SpeciesSkinColor.HumanToned:
                 {
+                    if (!_skinColor.Visible)
+                    {
+                        _skinColor.Visible = true;
+                        _rgbSkinColorContainer.Visible = false;
+                    }
+
+                    var color = Color.ToHsv(Profile.Appearance.SkinColor);
                     // check for hue/value first, if hue is lower than this percentage
                     // and value is 1.0
                     // then it'll be hue
@@ -673,13 +752,30 @@ namespace Content.Client.Preferences.UI
                 }
                 case SpeciesSkinColor.Hues:
                 {
-                    _skinColor.Value = color.X * 100;
+                    if (!_rgbSkinColorContainer.Visible)
+                    {
+                        _skinColor.Visible = false;
+                        _rgbSkinColorContainer.Visible = true;
+                    }
+
+                    // set the RGB values to the direct values otherwise
+                    _rgbSkinColorSelector.Color = Profile.Appearance.SkinColor;
                     break;
                 }
             }
 
         }
 
+        private void UpdateMarkings()
+        {
+            if (Profile == null)
+            {
+                return;
+            }
+
+            CMarkings.SetData(Profile.Appearance.Markings, Profile.Species);
+        }
+
         private void UpdateSpecies()
         {
             if (Profile == null)
@@ -758,7 +854,12 @@ namespace Content.Client.Preferences.UI
         {
             if (Profile is null)
                 return;
-            RebuildSpriteView();
+
+            if (_needsDummyRebuild)
+            {
+                RebuildSpriteView(); // Species change also requires sprite rebuild, so we'll do that now.
+                _needsDummyRebuild = false;
+            }
 
             EntitySystem.Get<SharedHumanoidAppearanceSystem>().UpdateFromProfile(_previewDummy!.Value, Profile);
             LobbyCharacterPreviewPanel.GiveDummyJobClothes(_previewDummy!.Value, Profile);
@@ -780,6 +881,7 @@ namespace Content.Client.Preferences.UI
             UpdateSaveButton();
             UpdateJobPriorities();
             UpdateAntagPreferences();
+            UpdateMarkings();
 
             _needUpdatePreview = true;
 
diff --git a/Content.Server.Database/Migrations/Postgres/20220310173734_SpeciesMarkings.Designer.cs b/Content.Server.Database/Migrations/Postgres/20220310173734_SpeciesMarkings.Designer.cs
new file mode 100644
index 0000000000..98c555da7a
--- /dev/null
+++ b/Content.Server.Database/Migrations/Postgres/20220310173734_SpeciesMarkings.Designer.cs
@@ -0,0 +1,1040 @@
+// <auto-generated />
+using System;
+using System.Net;
+using System.Text.Json;
+using Content.Server.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Content.Server.Database.Migrations.Postgres
+{
+    [DbContext(typeof(PostgresServerDbContext))]
+    [Migration("20220310173734_SpeciesMarkings")]
+    partial class SpeciesMarkings
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "6.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.Property<int?>("AdminRankId")
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text")
+                        .HasColumnName("title");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_admin");
+
+                    b.HasIndex("AdminRankId")
+                        .HasDatabaseName("IX_admin_admin_rank_id");
+
+                    b.ToTable("admin", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminFlag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_flag_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("AdminId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("admin_id");
+
+                    b.Property<string>("Flag")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("flag");
+
+                    b.Property<bool>("Negative")
+                        .HasColumnType("boolean")
+                        .HasColumnName("negative");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_flag");
+
+                    b.HasIndex("AdminId")
+                        .HasDatabaseName("IX_admin_flag_admin_id");
+
+                    b.HasIndex("Flag", "AdminId")
+                        .IsUnique();
+
+                    b.ToTable("admin_flag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_log_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("date");
+
+                    b.Property<short>("Impact")
+                        .HasColumnType("smallint")
+                        .HasColumnName("impact");
+
+                    b.Property<JsonDocument>("Json")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("json");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("message");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id", "RoundId")
+                        .HasName("PK_admin_log");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_log_round_id");
+
+                    b.HasIndex("Type")
+                        .HasDatabaseName("IX_admin_log_type");
+
+                    b.ToTable("admin_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogEntity", b =>
+                {
+                    b.Property<int>("Uid")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("uid");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Uid"));
+
+                    b.Property<int?>("AdminLogId")
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_log_id");
+
+                    b.Property<int?>("AdminLogRoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_log_round_id");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text")
+                        .HasColumnName("name");
+
+                    b.HasKey("Uid")
+                        .HasName("PK_admin_log_entity");
+
+                    b.HasIndex("AdminLogId", "AdminLogRoundId")
+                        .HasDatabaseName("IX_admin_log_entity_admin_log_id_admin_log_round_id");
+
+                    b.ToTable("admin_log_entity", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogPlayer", b =>
+                {
+                    b.Property<Guid>("PlayerUserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<int>("LogId")
+                        .HasColumnType("integer")
+                        .HasColumnName("log_id");
+
+                    b.Property<int>("RoundId")
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    b.HasKey("PlayerUserId", "LogId", "RoundId")
+                        .HasName("PK_admin_log_player");
+
+                    b.HasIndex("LogId", "RoundId");
+
+                    b.ToTable("admin_log_player", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRank", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_rank_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_rank");
+
+                    b.ToTable("admin_rank", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRankFlag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_rank_flag_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AdminRankId")
+                        .HasColumnType("integer")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Flag")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("flag");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_rank_flag");
+
+                    b.HasIndex("AdminRankId")
+                        .HasDatabaseName("IX_admin_rank_flag_admin_rank_id");
+
+                    b.HasIndex("Flag", "AdminRankId")
+                        .IsUnique();
+
+                    b.ToTable("admin_rank_flag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("antag_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AntagName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("antag_name");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_antag");
+
+                    b.HasIndex("ProfileId", "AntagName")
+                        .IsUnique();
+
+                    b.ToTable("antag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AssignedUserId", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("assigned_user_id_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("user_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_assigned_user_id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("UserName")
+                        .IsUnique();
+
+                    b.ToTable("assigned_user_id", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("connection_log_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<IPAddress>("Address")
+                        .IsRequired()
+                        .HasColumnType("inet")
+                        .HasColumnName("address");
+
+                    b.Property<byte?>("Denied")
+                        .HasColumnType("smallint")
+                        .HasColumnName("denied");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("bytea")
+                        .HasColumnName("hwid");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("time");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("user_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_connection_log");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("connection_log", (string)null);
+
+                    b.HasCheckConstraint("AddressNotIPv6MappedIPv4", "NOT inet '::ffff:0.0.0.0/96' >>= address");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("job_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("job_name");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("integer")
+                        .HasColumnName("priority");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_job");
+
+                    b.HasIndex("ProfileId")
+                        .HasDatabaseName("IX_job_profile_id");
+
+                    b.HasIndex("ProfileId", "JobName")
+                        .IsUnique();
+
+                    b.HasIndex(new[] { "ProfileId" }, "IX_job_one_high_priority")
+                        .IsUnique()
+                        .HasFilter("priority = 3");
+
+                    b.ToTable("job", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("player_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("FirstSeenTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("first_seen_time");
+
+                    b.Property<IPAddress>("LastSeenAddress")
+                        .IsRequired()
+                        .HasColumnType("inet")
+                        .HasColumnName("last_seen_address");
+
+                    b.Property<byte[]>("LastSeenHWId")
+                        .HasColumnType("bytea")
+                        .HasColumnName("last_seen_hwid");
+
+                    b.Property<DateTime>("LastSeenTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("last_seen_time");
+
+                    b.Property<string>("LastSeenUserName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("last_seen_user_name");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_player");
+
+                    b.HasAlternateKey("UserId")
+                        .HasName("ak_player_user_id");
+
+                    b.HasIndex("LastSeenUserName");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("player", (string)null);
+
+                    b.HasCheckConstraint("LastSeenAddressNotIPv6MappedIPv4", "NOT inet '::ffff:0.0.0.0/96' >>= last_seen_address");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Preference", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("preference_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AdminOOCColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("admin_ooc_color");
+
+                    b.Property<int>("SelectedCharacterSlot")
+                        .HasColumnType("integer")
+                        .HasColumnName("selected_character_slot");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_preference");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("preference", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("profile_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("Age")
+                        .HasColumnType("integer")
+                        .HasColumnName("age");
+
+                    b.Property<string>("Backpack")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("backpack");
+
+                    b.Property<string>("CharacterName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("char_name");
+
+                    b.Property<string>("Clothing")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("clothing");
+
+                    b.Property<string>("EyeColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("eye_color");
+
+                    b.Property<string>("FacialHairColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("facial_hair_color");
+
+                    b.Property<string>("FacialHairName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("facial_hair_name");
+
+                    b.Property<string>("Gender")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("gender");
+
+                    b.Property<string>("HairColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("hair_color");
+
+                    b.Property<string>("HairName")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("hair_name");
+
+                    b.Property<string>("Markings")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("markings");
+
+                    b.Property<int>("PreferenceId")
+                        .HasColumnType("integer")
+                        .HasColumnName("preference_id");
+
+                    b.Property<int>("PreferenceUnavailable")
+                        .HasColumnType("integer")
+                        .HasColumnName("pref_unavailable");
+
+                    b.Property<string>("Sex")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("sex");
+
+                    b.Property<string>("SkinColor")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("skin_color");
+
+                    b.Property<int>("Slot")
+                        .HasColumnType("integer")
+                        .HasColumnName("slot");
+
+                    b.Property<string>("Species")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("species");
+
+                    b.HasKey("Id")
+                        .HasName("PK_profile");
+
+                    b.HasIndex("PreferenceId")
+                        .HasDatabaseName("IX_profile_preference_id");
+
+                    b.HasIndex("Slot", "PreferenceId")
+                        .IsUnique();
+
+                    b.ToTable("profile", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("round_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.HasKey("Id")
+                        .HasName("PK_round");
+
+                    b.ToTable("round", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("server_ban_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<ValueTuple<IPAddress, int>?>("Address")
+                        .HasColumnType("inet")
+                        .HasColumnName("address");
+
+                    b.Property<DateTime>("BanTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("ban_time");
+
+                    b.Property<Guid?>("BanningAdmin")
+                        .HasColumnType("uuid")
+                        .HasColumnName("banning_admin");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("bytea")
+                        .HasColumnName("hwid");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("reason");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_ban");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("server_ban", (string)null);
+
+                    b.HasCheckConstraint("AddressNotIPv6MappedIPv4", "NOT inet '::ffff:0.0.0.0/96' >>= address");
+
+                    b.HasCheckConstraint("HaveEitherAddressOrUserIdOrHWId", "address IS NOT NULL OR user_id IS NOT NULL OR hwid IS NOT NULL");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanHit", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("server_ban_hit_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("integer")
+                        .HasColumnName("ban_id");
+
+                    b.Property<int>("ConnectionId")
+                        .HasColumnType("integer")
+                        .HasColumnName("connection_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_ban_hit");
+
+                    b.HasIndex("BanId")
+                        .HasDatabaseName("IX_server_ban_hit_ban_id");
+
+                    b.HasIndex("ConnectionId")
+                        .HasDatabaseName("IX_server_ban_hit_connection_id");
+
+                    b.ToTable("server_ban_hit", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("server_role_ban_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<ValueTuple<IPAddress, int>?>("Address")
+                        .HasColumnType("inet")
+                        .HasColumnName("address");
+
+                    b.Property<DateTime>("BanTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("ban_time");
+
+                    b.Property<Guid?>("BanningAdmin")
+                        .HasColumnType("uuid")
+                        .HasColumnName("banning_admin");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("bytea")
+                        .HasColumnName("hwid");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("reason");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("role_id");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_role_ban");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("server_role_ban", (string)null);
+
+                    b.HasCheckConstraint("AddressNotIPv6MappedIPv4", "NOT inet '::ffff:0.0.0.0/96' >>= address");
+
+                    b.HasCheckConstraint("HaveEitherAddressOrUserIdOrHWId", "address IS NOT NULL OR user_id IS NOT NULL OR hwid IS NOT NULL");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleUnban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("role_unban_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("integer")
+                        .HasColumnName("ban_id");
+
+                    b.Property<DateTime>("UnbanTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("unban_time");
+
+                    b.Property<Guid?>("UnbanningAdmin")
+                        .HasColumnType("uuid")
+                        .HasColumnName("unbanning_admin");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_role_unban");
+
+                    b.HasIndex("BanId")
+                        .IsUnique();
+
+                    b.ToTable("server_role_unban", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerUnban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("unban_id");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("integer")
+                        .HasColumnName("ban_id");
+
+                    b.Property<DateTime>("UnbanTime")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("unban_time");
+
+                    b.Property<Guid?>("UnbanningAdmin")
+                        .HasColumnType("uuid")
+                        .HasColumnName("unbanning_admin");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_unban");
+
+                    b.HasIndex("BanId")
+                        .IsUnique();
+
+                    b.ToTable("server_unban", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Whitelist", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_whitelist");
+
+                    b.ToTable("whitelist", (string)null);
+                });
+
+            modelBuilder.Entity("PlayerRound", b =>
+                {
+                    b.Property<int>("PlayersId")
+                        .HasColumnType("integer")
+                        .HasColumnName("players_id");
+
+                    b.Property<int>("RoundsId")
+                        .HasColumnType("integer")
+                        .HasColumnName("rounds_id");
+
+                    b.HasKey("PlayersId", "RoundsId")
+                        .HasName("PK_player_round");
+
+                    b.HasIndex("RoundsId")
+                        .HasDatabaseName("IX_player_round_rounds_id");
+
+                    b.ToTable("player_round", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminRank", "AdminRank")
+                        .WithMany("Admins")
+                        .HasForeignKey("AdminRankId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_admin_rank_admin_rank_id");
+
+                    b.Navigation("AdminRank");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminFlag", b =>
+                {
+                    b.HasOne("Content.Server.Database.Admin", "Admin")
+                        .WithMany("Flags")
+                        .HasForeignKey("AdminId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_flag_admin_admin_id");
+
+                    b.Navigation("Admin");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany("AdminLogs")
+                        .HasForeignKey("RoundId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_round_round_id");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogEntity", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminLog", null)
+                        .WithMany("Entities")
+                        .HasForeignKey("AdminLogId", "AdminLogRoundId")
+                        .HasConstraintName("FK_admin_log_entity_admin_log_admin_log_id_admin_log_round_id");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogPlayer", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminLogs")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_player_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.AdminLog", "Log")
+                        .WithMany("Players")
+                        .HasForeignKey("LogId", "RoundId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_player_admin_log_log_id_round_id");
+
+                    b.Navigation("Log");
+
+                    b.Navigation("Player");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRankFlag", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminRank", "Rank")
+                        .WithMany("Flags")
+                        .HasForeignKey("AdminRankId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_rank_flag_admin_rank_admin_rank_id");
+
+                    b.Navigation("Rank");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Antags")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_antag_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Jobs")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_job_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.HasOne("Content.Server.Database.Preference", "Preference")
+                        .WithMany("Profiles")
+                        .HasForeignKey("PreferenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_profile_preference_preference_id");
+
+                    b.Navigation("Preference");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanHit", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerBan", "Ban")
+                        .WithMany("BanHits")
+                        .HasForeignKey("BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_ban_hit_server_ban_ban_id");
+
+                    b.HasOne("Content.Server.Database.ConnectionLog", "Connection")
+                        .WithMany("BanHits")
+                        .HasForeignKey("ConnectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_ban_hit_connection_log_connection_id");
+
+                    b.Navigation("Ban");
+
+                    b.Navigation("Connection");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleUnban", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerRoleBan", "Ban")
+                        .WithOne("Unban")
+                        .HasForeignKey("Content.Server.Database.ServerRoleUnban", "BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_role_unban_server_role_ban_ban_id");
+
+                    b.Navigation("Ban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerUnban", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerBan", "Ban")
+                        .WithOne("Unban")
+                        .HasForeignKey("Content.Server.Database.ServerUnban", "BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_unban_server_ban_ban_id");
+
+                    b.Navigation("Ban");
+                });
+
+            modelBuilder.Entity("PlayerRound", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", null)
+                        .WithMany()
+                        .HasForeignKey("PlayersId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_player_round_player_players_id");
+
+                    b.HasOne("Content.Server.Database.Round", null)
+                        .WithMany()
+                        .HasForeignKey("RoundsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_player_round_round_rounds_id");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.Navigation("Entities");
+
+                    b.Navigation("Players");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRank", b =>
+                {
+                    b.Navigation("Admins");
+
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.Navigation("BanHits");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.Navigation("AdminLogs");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Preference", b =>
+                {
+                    b.Navigation("Profiles");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.Navigation("Antags");
+
+                    b.Navigation("Jobs");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.Navigation("AdminLogs");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.Navigation("BanHits");
+
+                    b.Navigation("Unban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.Navigation("Unban");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Content.Server.Database/Migrations/Postgres/20220310173734_SpeciesMarkings.cs b/Content.Server.Database/Migrations/Postgres/20220310173734_SpeciesMarkings.cs
new file mode 100644
index 0000000000..ce5dcc6156
--- /dev/null
+++ b/Content.Server.Database/Migrations/Postgres/20220310173734_SpeciesMarkings.cs
@@ -0,0 +1,26 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Content.Server.Database.Migrations.Postgres
+{
+    public partial class SpeciesMarkings : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "markings",
+                table: "profile",
+                type: "text",
+                nullable: false,
+                defaultValue: "");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "markings",
+                table: "profile");
+        }
+    }
+}
diff --git a/Content.Server.Database/Migrations/Postgres/PostgresServerDbContextModelSnapshot.cs b/Content.Server.Database/Migrations/Postgres/PostgresServerDbContextModelSnapshot.cs
index dc1c83b1d1..7f5bd8eaf0 100644
--- a/Content.Server.Database/Migrations/Postgres/PostgresServerDbContextModelSnapshot.cs
+++ b/Content.Server.Database/Migrations/Postgres/PostgresServerDbContextModelSnapshot.cs
@@ -595,6 +595,11 @@ namespace Content.Server.Database.Migrations.Postgres
                         .HasColumnType("text")
                         .HasColumnName("hair_name");
 
+                    b.Property<string>("Markings")
+                        .IsRequired()
+                        .HasColumnType("text")
+                        .HasColumnName("markings");
+
                     b.Property<int>("PreferenceId")
                         .HasColumnType("integer")
                         .HasColumnName("preference_id");
diff --git a/Content.Server.Database/Migrations/Sqlite/20220310173728_SpeciesMarkings.Designer.cs b/Content.Server.Database/Migrations/Sqlite/20220310173728_SpeciesMarkings.Designer.cs
new file mode 100644
index 0000000000..85d6918eaf
--- /dev/null
+++ b/Content.Server.Database/Migrations/Sqlite/20220310173728_SpeciesMarkings.Designer.cs
@@ -0,0 +1,989 @@
+// <auto-generated />
+using System;
+using Content.Server.Database;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Content.Server.Database.Migrations.Sqlite
+{
+    [DbContext(typeof(SqliteServerDbContext))]
+    [Migration("20220310173728_SpeciesMarkings")]
+    partial class SpeciesMarkings
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "6.0.0");
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.Property<int?>("AdminRankId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("title");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_admin");
+
+                    b.HasIndex("AdminRankId")
+                        .HasDatabaseName("IX_admin_admin_rank_id");
+
+                    b.ToTable("admin", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminFlag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_flag_id");
+
+                    b.Property<Guid>("AdminId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("admin_id");
+
+                    b.Property<string>("Flag")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("flag");
+
+                    b.Property<bool>("Negative")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("negative");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_flag");
+
+                    b.HasIndex("AdminId")
+                        .HasDatabaseName("IX_admin_flag_admin_id");
+
+                    b.HasIndex("Flag", "AdminId")
+                        .IsUnique();
+
+                    b.ToTable("admin_flag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_log_id");
+
+                    b.Property<int>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.Property<DateTime>("Date")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("date");
+
+                    b.Property<sbyte>("Impact")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("impact");
+
+                    b.Property<string>("Json")
+                        .IsRequired()
+                        .HasColumnType("jsonb")
+                        .HasColumnName("json");
+
+                    b.Property<string>("Message")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("message");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("type");
+
+                    b.HasKey("Id", "RoundId")
+                        .HasName("PK_admin_log");
+
+                    b.HasIndex("RoundId")
+                        .HasDatabaseName("IX_admin_log_round_id");
+
+                    b.HasIndex("Type")
+                        .HasDatabaseName("IX_admin_log_type");
+
+                    b.ToTable("admin_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogEntity", b =>
+                {
+                    b.Property<int>("Uid")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("uid");
+
+                    b.Property<int?>("AdminLogId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_log_id");
+
+                    b.Property<int?>("AdminLogRoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_log_round_id");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.HasKey("Uid")
+                        .HasName("PK_admin_log_entity");
+
+                    b.HasIndex("AdminLogId", "AdminLogRoundId")
+                        .HasDatabaseName("IX_admin_log_entity_admin_log_id_admin_log_round_id");
+
+                    b.ToTable("admin_log_entity", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogPlayer", b =>
+                {
+                    b.Property<Guid>("PlayerUserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("player_user_id");
+
+                    b.Property<int>("LogId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("log_id");
+
+                    b.Property<int>("RoundId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.HasKey("PlayerUserId", "LogId", "RoundId")
+                        .HasName("PK_admin_log_player");
+
+                    b.HasIndex("LogId", "RoundId");
+
+                    b.ToTable("admin_log_player", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRank", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_rank");
+
+                    b.ToTable("admin_rank", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRankFlag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_rank_flag_id");
+
+                    b.Property<int>("AdminRankId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("admin_rank_id");
+
+                    b.Property<string>("Flag")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("flag");
+
+                    b.HasKey("Id")
+                        .HasName("PK_admin_rank_flag");
+
+                    b.HasIndex("AdminRankId")
+                        .HasDatabaseName("IX_admin_rank_flag_admin_rank_id");
+
+                    b.HasIndex("Flag", "AdminRankId")
+                        .IsUnique();
+
+                    b.ToTable("admin_rank_flag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("antag_id");
+
+                    b.Property<string>("AntagName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("antag_name");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_antag");
+
+                    b.HasIndex("ProfileId", "AntagName")
+                        .IsUnique();
+
+                    b.ToTable("antag", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AssignedUserId", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("assigned_user_id_id");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_assigned_user_id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.HasIndex("UserName")
+                        .IsUnique();
+
+                    b.ToTable("assigned_user_id", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("connection_log_id");
+
+                    b.Property<string>("Address")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("address");
+
+                    b.Property<byte?>("Denied")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("denied");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("BLOB")
+                        .HasColumnName("hwid");
+
+                    b.Property<DateTime>("Time")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("time");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_name");
+
+                    b.HasKey("Id")
+                        .HasName("PK_connection_log");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("connection_log", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("job_id");
+
+                    b.Property<string>("JobName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("job_name");
+
+                    b.Property<int>("Priority")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("priority");
+
+                    b.Property<int>("ProfileId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_job");
+
+                    b.HasIndex("ProfileId")
+                        .HasDatabaseName("IX_job_profile_id");
+
+                    b.HasIndex("ProfileId", "JobName")
+                        .IsUnique();
+
+                    b.HasIndex(new[] { "ProfileId" }, "IX_job_one_high_priority")
+                        .IsUnique()
+                        .HasFilter("priority = 3");
+
+                    b.ToTable("job", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("player_id");
+
+                    b.Property<DateTime>("FirstSeenTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("first_seen_time");
+
+                    b.Property<string>("LastSeenAddress")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_seen_address");
+
+                    b.Property<byte[]>("LastSeenHWId")
+                        .HasColumnType("BLOB")
+                        .HasColumnName("last_seen_hwid");
+
+                    b.Property<DateTime>("LastSeenTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_seen_time");
+
+                    b.Property<string>("LastSeenUserName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("last_seen_user_name");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_player");
+
+                    b.HasAlternateKey("UserId")
+                        .HasName("ak_player_user_id");
+
+                    b.HasIndex("LastSeenUserName");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("player", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Preference", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("preference_id");
+
+                    b.Property<string>("AdminOOCColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("admin_ooc_color");
+
+                    b.Property<int>("SelectedCharacterSlot")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("selected_character_slot");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_preference");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("preference", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("profile_id");
+
+                    b.Property<int>("Age")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("age");
+
+                    b.Property<string>("Backpack")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("backpack");
+
+                    b.Property<string>("CharacterName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("char_name");
+
+                    b.Property<string>("Clothing")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("clothing");
+
+                    b.Property<string>("EyeColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("eye_color");
+
+                    b.Property<string>("FacialHairColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("facial_hair_color");
+
+                    b.Property<string>("FacialHairName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("facial_hair_name");
+
+                    b.Property<string>("Gender")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("gender");
+
+                    b.Property<string>("HairColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("hair_color");
+
+                    b.Property<string>("HairName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("hair_name");
+
+                    b.Property<string>("Markings")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("markings");
+
+                    b.Property<int>("PreferenceId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("preference_id");
+
+                    b.Property<int>("PreferenceUnavailable")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("pref_unavailable");
+
+                    b.Property<string>("Sex")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("sex");
+
+                    b.Property<string>("SkinColor")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("skin_color");
+
+                    b.Property<int>("Slot")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("slot");
+
+                    b.Property<string>("Species")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("species");
+
+                    b.HasKey("Id")
+                        .HasName("PK_profile");
+
+                    b.HasIndex("PreferenceId")
+                        .HasDatabaseName("IX_profile_preference_id");
+
+                    b.HasIndex("Slot", "PreferenceId")
+                        .IsUnique();
+
+                    b.ToTable("profile", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("round_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_round");
+
+                    b.ToTable("round", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_ban_id");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("address");
+
+                    b.Property<DateTime>("BanTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("ban_time");
+
+                    b.Property<Guid?>("BanningAdmin")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("banning_admin");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("BLOB")
+                        .HasColumnName("hwid");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("reason");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_ban");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("server_ban", (string)null);
+
+                    b.HasCheckConstraint("HaveEitherAddressOrUserIdOrHWId", "address IS NOT NULL OR user_id IS NOT NULL OR hwid IS NOT NULL");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanHit", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_ban_hit_id");
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ban_id");
+
+                    b.Property<int>("ConnectionId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("connection_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_ban_hit");
+
+                    b.HasIndex("BanId")
+                        .HasDatabaseName("IX_server_ban_hit_ban_id");
+
+                    b.HasIndex("ConnectionId")
+                        .HasDatabaseName("IX_server_ban_hit_connection_id");
+
+                    b.ToTable("server_ban_hit", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("server_role_ban_id");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("address");
+
+                    b.Property<DateTime>("BanTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("ban_time");
+
+                    b.Property<Guid?>("BanningAdmin")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("banning_admin");
+
+                    b.Property<DateTime?>("ExpirationTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("expiration_time");
+
+                    b.Property<byte[]>("HWId")
+                        .HasColumnType("BLOB")
+                        .HasColumnName("hwid");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("reason");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("role_id");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_role_ban");
+
+                    b.HasIndex("Address");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("server_role_ban", (string)null);
+
+                    b.HasCheckConstraint("HaveEitherAddressOrUserIdOrHWId", "address IS NOT NULL OR user_id IS NOT NULL OR hwid IS NOT NULL");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleUnban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("role_unban_id");
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ban_id");
+
+                    b.Property<DateTime>("UnbanTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("unban_time");
+
+                    b.Property<Guid?>("UnbanningAdmin")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("unbanning_admin");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_role_unban");
+
+                    b.HasIndex("BanId")
+                        .IsUnique();
+
+                    b.ToTable("server_role_unban", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerUnban", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("unban_id");
+
+                    b.Property<int>("BanId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("ban_id");
+
+                    b.Property<DateTime>("UnbanTime")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("unban_time");
+
+                    b.Property<Guid?>("UnbanningAdmin")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("unbanning_admin");
+
+                    b.HasKey("Id")
+                        .HasName("PK_server_unban");
+
+                    b.HasIndex("BanId")
+                        .IsUnique();
+
+                    b.ToTable("server_unban", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Whitelist", b =>
+                {
+                    b.Property<Guid>("UserId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("user_id");
+
+                    b.HasKey("UserId")
+                        .HasName("PK_whitelist");
+
+                    b.ToTable("whitelist", (string)null);
+                });
+
+            modelBuilder.Entity("PlayerRound", b =>
+                {
+                    b.Property<int>("PlayersId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("players_id");
+
+                    b.Property<int>("RoundsId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("rounds_id");
+
+                    b.HasKey("PlayersId", "RoundsId")
+                        .HasName("PK_player_round");
+
+                    b.HasIndex("RoundsId")
+                        .HasDatabaseName("IX_player_round_rounds_id");
+
+                    b.ToTable("player_round", (string)null);
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminRank", "AdminRank")
+                        .WithMany("Admins")
+                        .HasForeignKey("AdminRankId")
+                        .OnDelete(DeleteBehavior.SetNull)
+                        .HasConstraintName("FK_admin_admin_rank_admin_rank_id");
+
+                    b.Navigation("AdminRank");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminFlag", b =>
+                {
+                    b.HasOne("Content.Server.Database.Admin", "Admin")
+                        .WithMany("Flags")
+                        .HasForeignKey("AdminId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_flag_admin_admin_id");
+
+                    b.Navigation("Admin");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.HasOne("Content.Server.Database.Round", "Round")
+                        .WithMany("AdminLogs")
+                        .HasForeignKey("RoundId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_round_round_id");
+
+                    b.Navigation("Round");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogEntity", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminLog", null)
+                        .WithMany("Entities")
+                        .HasForeignKey("AdminLogId", "AdminLogRoundId")
+                        .HasConstraintName("FK_admin_log_entity_admin_log_admin_log_id_admin_log_round_id");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLogPlayer", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", "Player")
+                        .WithMany("AdminLogs")
+                        .HasForeignKey("PlayerUserId")
+                        .HasPrincipalKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_player_player_player_user_id");
+
+                    b.HasOne("Content.Server.Database.AdminLog", "Log")
+                        .WithMany("Players")
+                        .HasForeignKey("LogId", "RoundId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_log_player_admin_log_log_id_round_id");
+
+                    b.Navigation("Log");
+
+                    b.Navigation("Player");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRankFlag", b =>
+                {
+                    b.HasOne("Content.Server.Database.AdminRank", "Rank")
+                        .WithMany("Flags")
+                        .HasForeignKey("AdminRankId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_admin_rank_flag_admin_rank_admin_rank_id");
+
+                    b.Navigation("Rank");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Antag", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Antags")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_antag_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Job", b =>
+                {
+                    b.HasOne("Content.Server.Database.Profile", "Profile")
+                        .WithMany("Jobs")
+                        .HasForeignKey("ProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_job_profile_profile_id");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.HasOne("Content.Server.Database.Preference", "Preference")
+                        .WithMany("Profiles")
+                        .HasForeignKey("PreferenceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_profile_preference_preference_id");
+
+                    b.Navigation("Preference");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBanHit", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerBan", "Ban")
+                        .WithMany("BanHits")
+                        .HasForeignKey("BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_ban_hit_server_ban_ban_id");
+
+                    b.HasOne("Content.Server.Database.ConnectionLog", "Connection")
+                        .WithMany("BanHits")
+                        .HasForeignKey("ConnectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_ban_hit_connection_log_connection_id");
+
+                    b.Navigation("Ban");
+
+                    b.Navigation("Connection");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleUnban", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerRoleBan", "Ban")
+                        .WithOne("Unban")
+                        .HasForeignKey("Content.Server.Database.ServerRoleUnban", "BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_role_unban_server_role_ban_ban_id");
+
+                    b.Navigation("Ban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerUnban", b =>
+                {
+                    b.HasOne("Content.Server.Database.ServerBan", "Ban")
+                        .WithOne("Unban")
+                        .HasForeignKey("Content.Server.Database.ServerUnban", "BanId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_server_unban_server_ban_ban_id");
+
+                    b.Navigation("Ban");
+                });
+
+            modelBuilder.Entity("PlayerRound", b =>
+                {
+                    b.HasOne("Content.Server.Database.Player", null)
+                        .WithMany()
+                        .HasForeignKey("PlayersId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_player_round_player_players_id");
+
+                    b.HasOne("Content.Server.Database.Round", null)
+                        .WithMany()
+                        .HasForeignKey("RoundsId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired()
+                        .HasConstraintName("FK_player_round_round_rounds_id");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Admin", b =>
+                {
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminLog", b =>
+                {
+                    b.Navigation("Entities");
+
+                    b.Navigation("Players");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.AdminRank", b =>
+                {
+                    b.Navigation("Admins");
+
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ConnectionLog", b =>
+                {
+                    b.Navigation("BanHits");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Player", b =>
+                {
+                    b.Navigation("AdminLogs");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Preference", b =>
+                {
+                    b.Navigation("Profiles");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Profile", b =>
+                {
+                    b.Navigation("Antags");
+
+                    b.Navigation("Jobs");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.Round", b =>
+                {
+                    b.Navigation("AdminLogs");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerBan", b =>
+                {
+                    b.Navigation("BanHits");
+
+                    b.Navigation("Unban");
+                });
+
+            modelBuilder.Entity("Content.Server.Database.ServerRoleBan", b =>
+                {
+                    b.Navigation("Unban");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/Content.Server.Database/Migrations/Sqlite/20220310173728_SpeciesMarkings.cs b/Content.Server.Database/Migrations/Sqlite/20220310173728_SpeciesMarkings.cs
new file mode 100644
index 0000000000..e65290a535
--- /dev/null
+++ b/Content.Server.Database/Migrations/Sqlite/20220310173728_SpeciesMarkings.cs
@@ -0,0 +1,26 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Content.Server.Database.Migrations.Sqlite
+{
+    public partial class SpeciesMarkings : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "markings",
+                table: "profile",
+                type: "TEXT",
+                nullable: false,
+                defaultValue: "");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "markings",
+                table: "profile");
+        }
+    }
+}
diff --git a/Content.Server.Database/Migrations/Sqlite/SqliteServerDbContextModelSnapshot.cs b/Content.Server.Database/Migrations/Sqlite/SqliteServerDbContextModelSnapshot.cs
index 742b98f2b9..4e76722de8 100644
--- a/Content.Server.Database/Migrations/Sqlite/SqliteServerDbContextModelSnapshot.cs
+++ b/Content.Server.Database/Migrations/Sqlite/SqliteServerDbContextModelSnapshot.cs
@@ -553,6 +553,11 @@ namespace Content.Server.Database.Migrations.Sqlite
                         .HasColumnType("TEXT")
                         .HasColumnName("hair_name");
 
+                    b.Property<string>("Markings")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("markings");
+
                     b.Property<int>("PreferenceId")
                         .HasColumnType("INTEGER")
                         .HasColumnName("preference_id");
diff --git a/Content.Server.Database/Model.cs b/Content.Server.Database/Model.cs
index 77a9bb4655..59cdc20450 100644
--- a/Content.Server.Database/Model.cs
+++ b/Content.Server.Database/Model.cs
@@ -199,6 +199,7 @@ namespace Content.Server.Database
         public string Sex { get; set; } = null!;
         public string Gender { get; set; } = null!;
         public string Species { get; set; } = null!;
+        public string Markings { get; set; } = null!;
         public string HairName { get; set; } = null!;
         public string HairColor { get; set; } = null!;
         public string FacialHairName { get; set; } = null!;
diff --git a/Content.Server/Database/ServerDbBase.cs b/Content.Server/Database/ServerDbBase.cs
index 0ae229bc98..80a094a685 100644
--- a/Content.Server/Database/ServerDbBase.cs
+++ b/Content.Server/Database/ServerDbBase.cs
@@ -7,6 +7,7 @@ using System.Threading.Tasks;
 using Content.Server.Administration.Logs;
 using Content.Shared.Administration.Logs;
 using Content.Shared.CharacterAppearance;
+using Content.Shared.Markings;
 using Content.Shared.Preferences;
 using Microsoft.EntityFrameworkCore;
 using Robust.Shared.Enums;
@@ -172,6 +173,24 @@ namespace Content.Server.Database
             if (Enum.TryParse<Gender>(profile.Gender, true, out var genderVal))
                 gender = genderVal;
 
+            List<Marking> markings = new();
+            if (profile.Markings != null && profile.Markings.Length != 0)
+            {
+                List<string>? markingsRaw = JsonSerializer.Deserialize<List<string>>(profile.Markings);
+                if (markingsRaw != null)
+                {
+                    foreach (var marking in markingsRaw)
+                    {
+                        var parsed = Marking.ParseFromDbString(marking);
+
+                        if (parsed is null) continue;
+
+                        markings.Add(parsed);
+                    }
+                }
+            }
+            var markingsSet = new MarkingsSet(markings);
+
             return new HumanoidCharacterProfile(
                 profile.CharacterName,
                 profile.Species,
@@ -185,7 +204,8 @@ namespace Content.Server.Database
                     profile.FacialHairName,
                     Color.FromHex(profile.FacialHairColor),
                     Color.FromHex(profile.EyeColor),
-                    Color.FromHex(profile.SkinColor)
+                    Color.FromHex(profile.SkinColor),
+                    markingsSet
                 ),
                 clothing,
                 backpack,
@@ -198,6 +218,12 @@ namespace Content.Server.Database
         private static Profile ConvertProfiles(HumanoidCharacterProfile humanoid, int slot)
         {
             var appearance = (HumanoidCharacterAppearance) humanoid.CharacterAppearance;
+            List<string> markingStrings = new();
+            foreach (var marking in appearance.Markings)
+            {
+                markingStrings.Add(marking.ToString());
+            }
+            var markings = JsonSerializer.Serialize(markingStrings);
 
             var entity = new Profile
             {
@@ -214,6 +240,7 @@ namespace Content.Server.Database
                 SkinColor = appearance.SkinColor.ToHex(),
                 Clothing = humanoid.Clothing.ToString(),
                 Backpack = humanoid.Backpack.ToString(),
+                Markings = markings,
                 Slot = slot,
                 PreferenceUnavailable = (DbPreferenceUnavailableMode) humanoid.PreferenceUnavailable
             };
diff --git a/Content.Shared/CharacterAppearance/HumanoidCharacterAppearance.cs b/Content.Shared/CharacterAppearance/HumanoidCharacterAppearance.cs
index 780efa7305..6b08d93e25 100644
--- a/Content.Shared/CharacterAppearance/HumanoidCharacterAppearance.cs
+++ b/Content.Shared/CharacterAppearance/HumanoidCharacterAppearance.cs
@@ -1,5 +1,7 @@
-using Robust.Shared.Random;
+using Content.Shared.Markings;
+using Robust.Shared.Random;
 using Robust.Shared.Serialization;
+using System.Linq;
 
 namespace Content.Shared.CharacterAppearance
 {
@@ -11,7 +13,8 @@ namespace Content.Shared.CharacterAppearance
             string facialHairStyleId,
             Color facialHairColor,
             Color eyeColor,
-            Color skinColor)
+            Color skinColor,
+            MarkingsSet markings)
         {
             HairStyleId = hairStyleId;
             HairColor = ClampColor(hairColor);
@@ -19,6 +22,7 @@ namespace Content.Shared.CharacterAppearance
             FacialHairColor = ClampColor(facialHairColor);
             EyeColor = ClampColor(eyeColor);
             SkinColor = ClampColor(skinColor);
+            Markings = markings;
         }
 
         public string HairStyleId { get; }
@@ -27,35 +31,41 @@ namespace Content.Shared.CharacterAppearance
         public Color FacialHairColor { get; }
         public Color EyeColor { get; }
         public Color SkinColor { get; }
+        public MarkingsSet Markings { get; }
 
         public HumanoidCharacterAppearance WithHairStyleName(string newName)
         {
-            return new(newName, HairColor, FacialHairStyleId, FacialHairColor, EyeColor, SkinColor);
+            return new(newName, HairColor, FacialHairStyleId, FacialHairColor, EyeColor, SkinColor, Markings);
         }
 
         public HumanoidCharacterAppearance WithHairColor(Color newColor)
         {
-            return new(HairStyleId, newColor, FacialHairStyleId, FacialHairColor, EyeColor, SkinColor);
+            return new(HairStyleId, newColor, FacialHairStyleId, FacialHairColor, EyeColor, SkinColor, Markings);
         }
 
         public HumanoidCharacterAppearance WithFacialHairStyleName(string newName)
         {
-            return new(HairStyleId, HairColor, newName, FacialHairColor, EyeColor, SkinColor);
+            return new(HairStyleId, HairColor, newName, FacialHairColor, EyeColor, SkinColor, Markings);
         }
 
         public HumanoidCharacterAppearance WithFacialHairColor(Color newColor)
         {
-            return new(HairStyleId, HairColor, FacialHairStyleId, newColor, EyeColor, SkinColor);
+            return new(HairStyleId, HairColor, FacialHairStyleId, newColor, EyeColor, SkinColor, Markings);
         }
 
         public HumanoidCharacterAppearance WithEyeColor(Color newColor)
         {
-            return new(HairStyleId, HairColor, FacialHairStyleId, FacialHairColor, newColor, SkinColor);
+            return new(HairStyleId, HairColor, FacialHairStyleId, FacialHairColor, newColor, SkinColor, Markings);
         }
 
         public HumanoidCharacterAppearance WithSkinColor(Color newColor)
         {
-            return new(HairStyleId, HairColor, FacialHairStyleId, FacialHairColor, EyeColor, newColor);
+            return new(HairStyleId, HairColor, FacialHairStyleId, FacialHairColor, EyeColor, newColor, Markings);
+        }
+
+        public HumanoidCharacterAppearance WithMarkings(MarkingsSet newMarkings)
+        {
+            return new(HairStyleId, HairColor, FacialHairStyleId, FacialHairColor, EyeColor, SkinColor, newMarkings);
         }
 
         public static HumanoidCharacterAppearance Default()
@@ -66,7 +76,8 @@ namespace Content.Shared.CharacterAppearance
                 HairStyles.DefaultFacialHairStyle,
                 Color.Black,
                 Color.Black,
-                Color.FromHex("#C0967F")
+                Color.FromHex("#C0967F"),
+                new MarkingsSet()
             );
         }
 
@@ -90,7 +101,7 @@ namespace Content.Shared.CharacterAppearance
                 .WithBlue(RandomizeColor(newHairColor.B));
 
             // TODO: Add random eye and skin color
-            return new HumanoidCharacterAppearance(newHairStyle, newHairColor, newFacialHairStyle, newHairColor, Color.Black, Color.FromHex("#C0967F"));
+            return new HumanoidCharacterAppearance(newHairStyle, newHairColor, newFacialHairStyle, newHairColor, Color.Black, Color.FromHex("#C0967F"), new MarkingsSet());
 
             float RandomizeColor(float channel)
             {
@@ -103,7 +114,7 @@ namespace Content.Shared.CharacterAppearance
             return new(color.RByte, color.GByte, color.BByte);
         }
 
-        public static HumanoidCharacterAppearance EnsureValid(HumanoidCharacterAppearance appearance)
+        public static HumanoidCharacterAppearance EnsureValid(HumanoidCharacterAppearance appearance, string species)
         {
             var mgr = IoCManager.Resolve<SpriteAccessoryManager>();
             var hairStyleId = appearance.HairStyleId;
@@ -123,13 +134,17 @@ namespace Content.Shared.CharacterAppearance
             var eyeColor = ClampColor(appearance.EyeColor);
             var skinColor = ClampColor(appearance.SkinColor);
 
+            var validMarkingsSet = MarkingsSet.EnsureValid(appearance.Markings);
+            validMarkingsSet = MarkingsSet.FilterSpecies(validMarkingsSet, species);
+
             return new HumanoidCharacterAppearance(
                 hairStyleId,
                 hairColor,
                 facialHairStyleId,
                 facialHairColor,
                 eyeColor,
-                skinColor);
+                skinColor,
+                validMarkingsSet);
         }
 
         public bool MemberwiseEquals(ICharacterAppearance maybeOther)
@@ -141,6 +156,7 @@ namespace Content.Shared.CharacterAppearance
             if (!FacialHairColor.Equals(other.FacialHairColor)) return false;
             if (!EyeColor.Equals(other.EyeColor)) return false;
             if (!SkinColor.Equals(other.SkinColor)) return false;
+            if (!Markings.Equals(other.Markings)) return false;
             return true;
         }
     }
diff --git a/Content.Shared/CharacterAppearance/HumanoidVisualLayers.cs b/Content.Shared/CharacterAppearance/HumanoidVisualLayers.cs
index 662a5256b6..28de91d641 100644
--- a/Content.Shared/CharacterAppearance/HumanoidVisualLayers.cs
+++ b/Content.Shared/CharacterAppearance/HumanoidVisualLayers.cs
@@ -5,14 +5,14 @@ namespace Content.Shared.CharacterAppearance
     [Serializable, NetSerializable]
     public enum HumanoidVisualLayers : byte
     {
-        TailBehind,
+        Tail,
         Hair,
         FacialHair,
         Chest,
         Head,
         Snout,
-        Frills,
-        Horns,
+        HeadSide, // side parts (i.e., frills)
+        HeadTop,  // top parts (i.e., ears)
         Eyes,
         RArm,
         LArm,
@@ -22,7 +22,6 @@ namespace Content.Shared.CharacterAppearance
         LLeg,
         RFoot,
         LFoot,
-        TailFront,
         Handcuffs,
         StencilMask,
         Fire,
diff --git a/Content.Shared/CharacterAppearance/HumanoidVisualLayersExtension.cs b/Content.Shared/CharacterAppearance/HumanoidVisualLayersExtension.cs
index ed7d3f9204..c2fdead121 100644
--- a/Content.Shared/CharacterAppearance/HumanoidVisualLayersExtension.cs
+++ b/Content.Shared/CharacterAppearance/HumanoidVisualLayersExtension.cs
@@ -17,14 +17,13 @@ namespace Content.Shared.CharacterAppearance
                     yield return HumanoidVisualLayers.Chest;
                     break;
                 case BodyPartType.Tail:
-                    yield return HumanoidVisualLayers.TailFront;
-                    yield return HumanoidVisualLayers.TailBehind;
+                    yield return HumanoidVisualLayers.Tail;
                     break;
                 case BodyPartType.Head:
                     yield return HumanoidVisualLayers.Head;
                     yield return HumanoidVisualLayers.Snout;
-                    yield return HumanoidVisualLayers.Frills;
-                    yield return HumanoidVisualLayers.Horns;
+                    yield return HumanoidVisualLayers.HeadSide;
+                    yield return HumanoidVisualLayers.HeadTop;
                     yield return HumanoidVisualLayers.Eyes;
                     yield return HumanoidVisualLayers.FacialHair;
                     yield return HumanoidVisualLayers.Hair;
diff --git a/Content.Shared/Entry/EntryPoint.cs b/Content.Shared/Entry/EntryPoint.cs
index a30db91b08..1fb5bfef31 100644
--- a/Content.Shared/Entry/EntryPoint.cs
+++ b/Content.Shared/Entry/EntryPoint.cs
@@ -6,6 +6,7 @@ using Content.Shared.Chemistry.Reagent;
 using Content.Shared.IoC;
 using Content.Shared.Localizations;
 using Content.Shared.Maps;
+using Content.Shared.Markings;
 using Robust.Shared.ContentPack;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
@@ -38,6 +39,7 @@ namespace Content.Shared.Entry
             _initTileDefinitions();
             CheckReactions();
             IoCManager.Resolve<SpriteAccessoryManager>().Initialize();
+            IoCManager.Resolve<MarkingManager>().Initialize();
         }
 
         private void CheckReactions()
diff --git a/Content.Shared/IoC/SharedContentIoC.cs b/Content.Shared/IoC/SharedContentIoC.cs
index cacd9c6102..71136ff0b5 100644
--- a/Content.Shared/IoC/SharedContentIoC.cs
+++ b/Content.Shared/IoC/SharedContentIoC.cs
@@ -1,4 +1,5 @@
 using Content.Shared.CharacterAppearance;
+using Content.Shared.Markings;
 using Robust.Shared.IoC;
 
 namespace Content.Shared.IoC
@@ -8,6 +9,7 @@ namespace Content.Shared.IoC
         public static void Register()
         {
             IoCManager.Register<SpriteAccessoryManager, SpriteAccessoryManager>();
+            IoCManager.Register<MarkingManager, MarkingManager>();
         }
     }
 }
diff --git a/Content.Shared/Markings/Marking.cs b/Content.Shared/Markings/Marking.cs
new file mode 100644
index 0000000000..213ce9ea62
--- /dev/null
+++ b/Content.Shared/Markings/Marking.cs
@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+using Robust.Shared.Maths;
+using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Shared.Markings
+{
+    [Serializable, NetSerializable]
+    public sealed class Marking : IEquatable<Marking>, IComparable<Marking>, IComparable<string>
+    {
+        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)
+            : this(markingId, new List<Color>())
+        {
+        }
+        */
+
+        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;
+        }
+
+        [DataField("markingId")]
+        [ViewVariables]
+        public string MarkingId { get; } = default!;
+
+        [DataField("markingColor")]
+        [ViewVariables]
+        public IReadOnlyList<Color> MarkingColors => _markingColors;
+
+        public void SetColor(int colorIndex, Color color) =>
+            _markingColors[colorIndex] = color;
+
+        public int CompareTo(Marking? marking)
+        {
+            if (marking == null) return 1;
+            else return this.MarkingId.CompareTo(marking.MarkingId);
+        }
+
+        public int CompareTo(string? markingId)
+        {
+            if (markingId == null) return 1;
+            return this.MarkingId.CompareTo(markingId);
+        }
+
+        public bool Equals(Marking? other)
+        {
+            if (other == null) return false;
+            return (this.MarkingId.Equals(other.MarkingId));
+        }
+
+
+        // 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);
+        }
+    }
+}
diff --git a/Content.Shared/Markings/MarkingCategories.cs b/Content.Shared/Markings/MarkingCategories.cs
new file mode 100644
index 0000000000..cf432377ac
--- /dev/null
+++ b/Content.Shared/Markings/MarkingCategories.cs
@@ -0,0 +1,19 @@
+using System;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Markings
+{
+    [Serializable, NetSerializable]
+    public enum MarkingCategories : byte
+    {
+        Head,
+        HeadTop,
+        HeadSide,
+        Snout,
+        Chest,
+        Arms,
+        Legs,
+        Tail,
+        Overlay
+    }
+}
diff --git a/Content.Shared/Markings/MarkingManager.cs b/Content.Shared/Markings/MarkingManager.cs
new file mode 100644
index 0000000000..1aede82c02
--- /dev/null
+++ b/Content.Shared/Markings/MarkingManager.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using Robust.Shared.IoC;
+using Robust.Shared.Log;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.Markings
+{
+    public sealed class MarkingManager
+    {
+        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
+        private readonly List<MarkingPrototype> _index = new();
+        private readonly Dictionary<MarkingCategories, List<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 List<MarkingPrototype>());
+
+            foreach (var prototype in _prototypeManager.EnumeratePrototypes<MarkingPrototype>())
+            {
+                _index.Add(prototype);
+                _markingDict[prototype.MarkingCategory].Add(prototype);
+                _markings.Add(prototype.ID, prototype);
+            }
+        }
+
+        public IReadOnlyDictionary<string, MarkingPrototype> Markings() => _markings;
+        public IReadOnlyDictionary<MarkingCategories, List<MarkingPrototype>> CategorizedMarkings() => _markingDict;
+
+        public IReadOnlyDictionary<MarkingCategories, List<MarkingPrototype>> MarkingsBySpecies(string species)
+        {
+            var result = new Dictionary<MarkingCategories, List<MarkingPrototype>>(_markingDict);
+
+            foreach (var list in result.Values)
+            {
+                list.RemoveAll(marking => marking.SpeciesRestrictions != null && marking.SpeciesRestrictions.Contains(species));
+            }
+
+            return result;
+        }
+
+        public bool IsValidMarking(Marking marking, [NotNullWhen(true)] out MarkingPrototype? markingResult)
+        {
+            return _markings.TryGetValue(marking.MarkingId, out markingResult);
+        }
+
+        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);
+            }
+        }
+    }
+}
diff --git a/Content.Shared/Markings/MarkingPrototype.cs b/Content.Shared/Markings/MarkingPrototype.cs
new file mode 100644
index 0000000000..927493edc7
--- /dev/null
+++ b/Content.Shared/Markings/MarkingPrototype.cs
@@ -0,0 +1,39 @@
+using System.Collections.Generic;
+using Content.Shared.CharacterAppearance;
+using Robust.Shared.Localization;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.Utility;
+
+namespace Content.Shared.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);
+        }
+    }
+}
diff --git a/Content.Shared/Markings/MarkingsComponent.cs b/Content.Shared/Markings/MarkingsComponent.cs
new file mode 100644
index 0000000000..fb9ad37ab7
--- /dev/null
+++ b/Content.Shared/Markings/MarkingsComponent.cs
@@ -0,0 +1,58 @@
+using System.Collections.Generic;
+using Content.Shared.CharacterAppearance;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Serialization.Manager.Attributes;
+
+namespace Content.Shared.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();
+    }
+
+    [DataDefinition]
+    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")]
+        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;
+        }
+    }
+}
diff --git a/Content.Shared/Markings/MarkingsSet.cs b/Content.Shared/Markings/MarkingsSet.cs
new file mode 100644
index 0000000000..e47d5cd266
--- /dev/null
+++ b/Content.Shared/Markings/MarkingsSet.cs
@@ -0,0 +1,283 @@
+using System.Collections;
+using System.Linq;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Markings;
+
+// TODO: Maybe put points logic into here too? It would make some sense
+// but it would have to be a template loaded in, otherwise clients could
+// send really invalid points sets that would have to be verified on the
+// server/client every time
+//
+// currently marking point constraints are just validated upon data send
+// from the client's UI (which might be a nono, means that connections
+// can just send garbage marking sets and it will save on the server)
+// and when an entity is rendered, (which is OK enough)
+//
+// equally, we'd need to access references every time we wanted to get
+// the managers required, which... not *terrible* if we do null default
+// params
+[Serializable, NetSerializable]
+public class MarkingsSet : IEnumerable, IEquatable<MarkingsSet>
+{
+    // if you want a rust style VecDeque, you're looking at
+    // the wrong place, i just wanted a similar API + some
+    // markings specific functions
+    private List<Marking> _markings = new();
+
+    public int Count
+    {
+        get => _markings.Count;
+    }
+
+    public MarkingsSet()
+    {
+    }
+
+    public MarkingsSet(List<Marking> markings)
+    {
+        _markings = markings;
+    }
+
+    public MarkingsSet(MarkingsSet other)
+    {
+        _markings = new(other._markings);
+    }
+
+    public Marking this[int idx] => Index(idx);
+
+    public Marking Index(int idx)
+    {
+        return _markings[idx];
+    }
+
+    // Gets a marking idx spaces from the back of the list.
+    public Marking IndexReverse(int idx)
+    {
+        return _markings[_markings.Count - 1 - idx];
+    }
+
+    public void AddFront(Marking marking)
+    {
+        _markings.Insert(0, marking);
+    }
+
+    public void AddBack(Marking marking)
+    {
+        _markings.Add(marking);
+    }
+
+    public bool Remove(Marking marking)
+    {
+        return _markings.Remove(marking);
+    }
+
+    public bool Contains(Marking marking)
+    {
+        return _markings.Contains(marking);
+    }
+
+    public int FindIndexOf(string id)
+    {
+        return _markings.FindIndex(m => m.MarkingId == id);
+    }
+
+    // Shifts a marking's rank upwards (i.e., towards the front of the list)
+    public void ShiftRankUp(int idx)
+    {
+        if (idx < 0 || idx >= _markings.Count || idx - 1 < 0)
+        {
+            return;
+        }
+
+        var temp = _markings[idx - 1];
+        _markings[idx - 1] = _markings[idx];
+        _markings[idx] = temp;
+    }
+
+    // Shifts up from the back (i.e., 2nd position from end)
+    public void ShiftRankUpFromEnd(int idx)
+    {
+        ShiftRankUp(Count - idx - 1);
+    }
+
+    // Ditto, but the opposite direction.
+    public void ShiftRankDown(int idx)
+    {
+        if (idx < 0 || idx >= _markings.Count || idx + 1 >= _markings.Count)
+        {
+            return;
+        }
+
+        var temp = _markings[idx + 1];
+        _markings[idx + 1] = _markings[idx];
+        _markings[idx] = temp;
+    }
+
+    // Ditto as above.
+    public void ShiftRankDownFromEnd(int idx)
+    {
+        ShiftRankDown(Count - idx - 1);
+    }
+
+    // Ensures that all markings in a set are valid.
+    public static MarkingsSet EnsureValid(MarkingsSet set, MarkingManager? manager = null)
+    {
+        if (manager == null)
+        {
+            manager = IoCManager.Resolve<MarkingManager>();
+        }
+
+        var newList = set._markings.Where(marking => manager.Markings().ContainsKey(marking.MarkingId)).ToList();
+
+        set._markings = newList;
+
+        return set;
+    }
+
+    // Filters out markings based on species.
+    public static MarkingsSet FilterSpecies(MarkingsSet set, string species)
+    {
+        var _markingsManager = IoCManager.Resolve<MarkingManager>();
+        var newList = set._markings.Where(marking =>
+        {
+            if (!_markingsManager.Markings().TryGetValue(marking.MarkingId, out MarkingPrototype? prototype))
+            {
+                return false;
+            }
+
+            if (prototype.SpeciesRestrictions != null)
+            {
+                if (!prototype.SpeciesRestrictions.Contains(species))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }).ToList();
+
+        set._markings = newList;
+
+        return set;
+    }
+
+    // Processes a MarkingsSet using the given dictionary of MarkingPoints.
+    public static MarkingsSet ProcessPoints(MarkingsSet set, Dictionary<MarkingCategories, MarkingPoints> points)
+    {
+        var finalSet = new List<Marking>();
+        var _markingsManager = IoCManager.Resolve<MarkingManager>();
+
+        foreach (var marking in set)
+        {
+            if (_markingsManager.Markings().TryGetValue(marking.MarkingId, out MarkingPrototype? markingPrototype))
+            {
+                if (points.TryGetValue(markingPrototype.MarkingCategory, out var pointsRemaining))
+                {
+                    if (pointsRemaining.Points == 0)
+                    {
+                        continue;
+                    }
+
+                    pointsRemaining.Points--;
+
+                    finalSet.Add(marking);
+                }
+                else
+                {
+                    // points don't exist otherwise
+                    finalSet.Add(marking);
+                }
+            }
+        }
+
+        set._markings = finalSet;
+
+        return set;
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return (IEnumerator) GetEnumerator();
+    }
+
+    public MarkingsEnumerator GetEnumerator()
+    {
+        return new MarkingsEnumerator(_markings, false);
+    }
+
+    public IEnumerator GetReverseEnumerator()
+    {
+        return (IEnumerator) new MarkingsEnumerator(_markings, true);
+    }
+
+    public bool Equals(MarkingsSet? set)
+    {
+        if (set == null)
+        {
+            return false;
+        }
+
+        return _markings.SequenceEqual(set._markings);
+    }
+}
+
+public class MarkingsEnumerator : IEnumerator
+{
+    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;
+        }
+    }
+
+    object IEnumerator.Current
+    {
+        get => _markings[position];
+    }
+
+    public Marking Current
+    {
+        get => _markings[position];
+    }
+}
diff --git a/Content.Shared/Preferences/HumanoidCharacterProfile.cs b/Content.Shared/Preferences/HumanoidCharacterProfile.cs
index a961cc6455..4c7d2f986a 100644
--- a/Content.Shared/Preferences/HumanoidCharacterProfile.cs
+++ b/Content.Shared/Preferences/HumanoidCharacterProfile.cs
@@ -302,7 +302,7 @@ namespace Content.Shared.Preferences
                 name = RandomName();
             }
 
-            var appearance = HumanoidCharacterAppearance.EnsureValid(Appearance);
+            var appearance = HumanoidCharacterAppearance.EnsureValid(Appearance, Species);
 
             var prefsUnavailableMode = PreferenceUnavailable switch
             {
diff --git a/Content.Shared/Species/SpeciesPrototype.cs b/Content.Shared/Species/SpeciesPrototype.cs
index 435b93c540..fd0fab0dda 100644
--- a/Content.Shared/Species/SpeciesPrototype.cs
+++ b/Content.Shared/Species/SpeciesPrototype.cs
@@ -43,8 +43,6 @@ public sealed class SpeciesPrototype : IPrototype
     /// </summary>
     [DataField("skinColoration", required: true)]
     public SpeciesSkinColor SkinColoration { get; }
-
-
 }
 
 public enum SpeciesSkinColor
diff --git a/Content.Tests/Server/Preferences/ServerDbSqliteTests.cs b/Content.Tests/Server/Preferences/ServerDbSqliteTests.cs
index bc44046019..7c4aaa780f 100644
--- a/Content.Tests/Server/Preferences/ServerDbSqliteTests.cs
+++ b/Content.Tests/Server/Preferences/ServerDbSqliteTests.cs
@@ -6,6 +6,7 @@ using System.Threading.Tasks;
 using Content.Server.Database;
 using Content.Shared.CharacterAppearance;
 using Content.Shared.GameTicking;
+using Content.Shared.Markings;
 using Content.Shared.Preferences;
 using Microsoft.Data.Sqlite;
 using Microsoft.EntityFrameworkCore;
@@ -52,7 +53,8 @@ namespace Content.Tests.Server.Preferences
                     "Shaved",
                     Color.Aquamarine,
                     Color.Azure,
-                    Color.Beige
+                    Color.Beige,
+                    new MarkingsSet()
                 ),
                 ClothingPreference.Jumpskirt,
                 BackpackPreference.Backpack,
diff --git a/Resources/Locale/en-US/markings/cat.ftl b/Resources/Locale/en-US/markings/cat.ftl
new file mode 100644
index 0000000000..b187d0115b
--- /dev/null
+++ b/Resources/Locale/en-US/markings/cat.ftl
@@ -0,0 +1,2 @@
+marking-CatEars = Cat Ears
+marking-CatTail = Cat Tail
diff --git a/Resources/Locale/en-US/markings/reptilian.ftl b/Resources/Locale/en-US/markings/reptilian.ftl
new file mode 100644
index 0000000000..96aaf0667a
--- /dev/null
+++ b/Resources/Locale/en-US/markings/reptilian.ftl
@@ -0,0 +1,41 @@
+marking-LizardFrillsShort-frills_short = Lizard Frills (Short)
+marking-LizardFrillsShort = Lizard Frills (Short)
+
+marking-LizardFrillsSimple-frills_simple = Lizard Frills (Simple)
+marking-LizardFrillsSimple = Lizard Frills (Simple)
+
+marking-LizardFrillsAquatic-frills_aquatic = Lizard Frills (Aquatic)
+marking-LizardFrillsAquatic = Lizard Frills (Aquatic)
+
+marking-LizardHornsAngler-horns_angler = Lizard Horns (Angler)
+marking-LizardHornsAngler = Lizard Horns (Angler)
+
+marking-LizardHornsCurled-horns_curled = Lizard Horns (Curled)
+marking-LizardHornsCurled = Lizard Horns (Curled)
+
+marking-LizardHornsRam-horns_ram = Lizard Horns (Ram)
+marking-LizardHornsRam = Lizard Horns (Ram)
+
+marking-LizardHornsShort-horns_short = Lizard Horns (Short)
+marking-LizardHornsShort = Lizard Horns (Short)
+
+marking-LizardHornsSimple-horns_simple = Lizard Horns
+marking-LizardHornsSimple = Lizard Horns
+
+marking-LizardTailSmooth-tail_smooth = Lizard Tail (Smooth)
+marking-LizardTailSmooth = Lizard Tail (Smooth)
+
+marking-LizardTailSpikes-tail_spikes = Lizard Tail (Spiky)
+marking-LizardTailSpikes = Lizard Tail (Spiky)
+
+marking-LizardTailLTiger-tail_ltiger = Lizard Tail (Light Tiger Stripes)
+marking-LizardTailLTiger = Lizard Tail (Light Tiger Stripes)
+
+marking-LizardTailDTiger-tail_dtiger = Lizard Tail (Dark Tiger Stripes)
+marking-LizardTailDTiger = Lizard Tail (Dark Tiger Stripes)
+
+marking-LizardSnoutRound-snout_round = Lizard Snout (Round)
+marking-LizardSnoutRound = Lizard Snout (Round)
+
+marking-LizardSnoutSharp-snout_sharp = Lizard Snout (Sharp)
+marking-LizardSnoutSharp = Lizard Snout (Sharp)
diff --git a/Resources/Locale/en-US/preferences/ui/humanoid-profile-editor.ftl b/Resources/Locale/en-US/preferences/ui/humanoid-profile-editor.ftl
index 99957b02a9..659e54de8c 100644
--- a/Resources/Locale/en-US/preferences/ui/humanoid-profile-editor.ftl
+++ b/Resources/Locale/en-US/preferences/ui/humanoid-profile-editor.ftl
@@ -35,3 +35,4 @@ humanoid-profile-editor-job-priority-medium-button = Medium
 humanoid-profile-editor-job-priority-low-button = Low
 humanoid-profile-editor-job-priority-never-button = Never
 humanoid-profile-editor-naming-rules-warning = Warning: Offensive or LRP IC names will lead to admin intervention on this server. Read our \[Rules\] for more.
+humanoid-profile-editor-markings-tab = Markings
diff --git a/Resources/Locale/en-US/preferences/ui/markings-picker.ftl b/Resources/Locale/en-US/preferences/ui/markings-picker.ftl
new file mode 100644
index 0000000000..6388915699
--- /dev/null
+++ b/Resources/Locale/en-US/preferences/ui/markings-picker.ftl
@@ -0,0 +1,20 @@
+markings-used = Used Markings
+markings-unused = Unused Markings
+markings-add = Add Marking
+markings-remove = Remove Marking
+markings-rank-up = Up
+markings-rank-down = Down
+marking-points-remaining = Points remaining: {$points}
+marking-used = {$marking-name} ({$marking-category})
+
+# Categories
+
+markings-category-Head = Head
+markings-category-HeadTop = Head (Top)
+markings-category-HeadSide = Head (Side)
+markings-category-Snout = Snout
+markings-category-Chest = Chest
+markings-category-Arms = Arms
+markings-category-Legs = Legs
+markings-category-Tail = Tail
+markings-category-Overlay = Overlay
diff --git a/Resources/Prototypes/Entities/Mobs/Customization/Markings/cat_parts.yml b/Resources/Prototypes/Entities/Mobs/Customization/Markings/cat_parts.yml
new file mode 100644
index 0000000000..1098c39fe8
--- /dev/null
+++ b/Resources/Prototypes/Entities/Mobs/Customization/Markings/cat_parts.yml
@@ -0,0 +1,19 @@
+- type: marking
+  id: CatEars
+  bodyPart: HeadTop
+  markingCategory: HeadTop
+  speciesRestriction: [Human]
+  sprites:
+  - sprite: Mobs/Customization/cat_parts.rsi/
+    state: ears_cat_outer
+  - sprite: Mobs/Customization/cat_parts.rsi/
+    state: ears_cat_inner
+
+- type: marking
+  id: CatTail
+  bodyPart: Tail
+  markingCategory: Tail
+  speciesRestriction: [Human]
+  sprites:
+  - sprite: Mobs/Customization/cat_parts.rsi/
+    state: tail_cat
diff --git a/Resources/Prototypes/Entities/Mobs/Customization/Markings/reptilian.yml b/Resources/Prototypes/Entities/Mobs/Customization/Markings/reptilian.yml
new file mode 100644
index 0000000000..fd0953ef8a
--- /dev/null
+++ b/Resources/Prototypes/Entities/Mobs/Customization/Markings/reptilian.yml
@@ -0,0 +1,130 @@
+- type: marking
+  id: LizardFrillsAquatic
+  bodyPart: HeadSide
+  markingCategory: HeadSide
+  speciesRestriction: [Reptilian]
+  sprites:
+  - sprite: Mobs/Customization/reptilian_parts.rsi/
+    state: frills_aquatic
+
+- type: marking
+  id: LizardFrillsShort
+  bodyPart: HeadSide
+  markingCategory: HeadSide
+  speciesRestriction: [Reptilian]
+  sprites:
+  - sprite: Mobs/Customization/reptilian_parts.rsi/
+    state: frills_short
+
+- type: marking
+  id: LizardFrillsSimple
+  bodyPart: HeadSide
+  markingCategory: HeadSide
+  speciesRestriction: [Reptilian]
+  sprites:
+  - sprite: Mobs/Customization/reptilian_parts.rsi/
+    state: frills_simple
+
+- type: marking
+  id: LizardHornsAngler
+  bodyPart: HeadTop
+  markingCategory: HeadTop
+  speciesRestriction: [Reptilian]
+  sprites:
+  - sprite: Mobs/Customization/reptilian_parts.rsi/
+    state: horns_angler
+
+- type: marking
+  id: LizardHornsCurled
+  bodyPart: HeadTop
+  markingCategory: HeadTop
+  speciesRestriction: [Reptilian]
+  sprites:
+  - sprite: Mobs/Customization/reptilian_parts.rsi/
+    state: horns_curled
+
+- type: marking
+  id: LizardHornsRam
+  bodyPart: HeadTop
+  markingCategory: HeadTop
+  speciesRestriction: [Reptilian]
+  sprites:
+  - sprite: Mobs/Customization/reptilian_parts.rsi/
+    state: horns_ram
+
+- type: marking
+  id: LizardHornsShort
+  bodyPart: HeadTop
+  markingCategory: HeadTop
+  speciesRestriction: [Reptilian]
+  sprites:
+  - sprite: Mobs/Customization/reptilian_parts.rsi/
+    state: horns_short
+
+- type: marking
+  id: LizardHornsSimple
+  bodyPart: HeadTop
+  markingCategory: HeadTop
+  speciesRestriction: [Reptilian]
+  sprites:
+  - sprite: Mobs/Customization/reptilian_parts.rsi/
+    state: horns_simple
+
+- type: marking
+  id: LizardTailSmooth
+  bodyPart: Tail
+  markingCategory: Tail
+  speciesRestriction: [Reptilian]
+  sprites:
+  - sprite: Mobs/Customization/reptilian_parts.rsi/
+    state: tail_smooth
+
+- type: marking
+  id: LizardTailSpikes
+  bodyPart: Tail
+  markingCategory: Tail
+  speciesRestriction: [Reptilian]
+  sprites:
+  - sprite: Mobs/Customization/reptilian_parts.rsi/
+    state: tail_spikes
+
+- type: marking
+  id: LizardTailLTiger
+  bodyPart: Tail
+  markingCategory: Tail
+  speciesRestriction: [Reptilian]
+  sprites:
+  - sprite: Mobs/Customization/reptilian_parts.rsi/
+    state: tail_ltiger
+
+- type: marking
+  id: LizardTailDTiger
+  bodyPart: Tail
+  markingCategory: Tail
+  speciesRestriction: [Reptilian]
+  sprites:
+  - sprite: Mobs/Customization/reptilian_parts.rsi/
+    state: tail_dtiger
+
+- type: marking
+  id: LizardSnoutRound
+  bodyPart: Snout
+  markingCategory: Snout
+  followSkinColor: true
+  speciesRestriction: [Reptilian]
+  sprites:
+  - sprite: Mobs/Customization/reptilian_parts.rsi/
+    state: snout_round
+
+- type: marking
+  id: LizardSnoutSharp
+  bodyPart: Snout
+  markingCategory: Snout
+  followSkinColor: true
+  speciesRestriction: [Reptilian]
+  sprites:
+  - sprite: Mobs/Customization/reptilian_parts.rsi/
+    state: snout_sharp
+
+
+
diff --git a/Resources/Prototypes/Entities/Mobs/Species/human.yml b/Resources/Prototypes/Entities/Mobs/Species/human.yml
index d057ad619c..8ed633aaa0 100644
--- a/Resources/Prototypes/Entities/Mobs/Species/human.yml
+++ b/Resources/Prototypes/Entities/Mobs/Species/human.yml
@@ -162,6 +162,14 @@
     - map: [ "head" ]
     - map: [ "pocket1" ]
     - map: [ "pocket2" ]
+  - type: Markings
+    layerPoints:
+      Tail:
+        points: 0
+        required: false
+      HeadTop:
+        points: 0
+        required: false
   - type: Physics
     bodyType: KinematicController
   - type: Fixtures
@@ -395,6 +403,7 @@
       - map: [ "pocket2" ]
       - map: ["hand-left"]
       - map: ["hand-right"]
+    - type: Markings 
     - type: Physics
       bodyType: Dynamic
     - type: Fixtures
diff --git a/Resources/Prototypes/Entities/Mobs/Species/reptilian.yml b/Resources/Prototypes/Entities/Mobs/Species/reptilian.yml
index a8650b3f46..0ad8a07a40 100644
--- a/Resources/Prototypes/Entities/Mobs/Species/reptilian.yml
+++ b/Resources/Prototypes/Entities/Mobs/Species/reptilian.yml
@@ -9,16 +9,32 @@
   - type: Icon
     sprite: Mobs/Species/Reptilian/parts.rsi
     state: full
+  - type: Markings
+    layerPoints:
+      Tail:
+        points: 1
+        required: true
+        defaultMarkings: [LizardTailSmooth] 
+      Snout:
+        points: 1
+        required: true
+        defaultMarkings: [LizardSnoutRound]
+      HeadTop:
+        points: 1
+        required: false
+      HeadSide:
+        points: 1
+        required: false
   - type: Sprite
     netsync: false
     noRot: true
     drawdepth: Mobs
     scale: 1, 1
     layers:
-      - map: [ "enum.HumanoidVisualLayers.TailBehind" ]
-        color: "#34a223"
-        state: tail_smooth_behind
-        sprite: Mobs/Customization/reptilian_parts.rsi
+      - map: [ "enum.HumanoidVisualLayers.Tail" ]
+        sprite: Mobs/Customization/masking_helpers.rsi
+        state: none
+        visible: false
       - map: [ "enum.HumanoidVisualLayers.Chest" ]
         color: "#34a223"
         sprite: Mobs/Species/Reptilian/parts.rsi
@@ -28,9 +44,9 @@
         sprite: Mobs/Species/Reptilian/parts.rsi
         state: head_m
       - map: [ "enum.HumanoidVisualLayers.Snout" ]
-        color: "#34a223"
-        state: snout_round
-        sprite: Mobs/Customization/reptilian_parts.rsi
+        sprite: Mobs/Customization/masking_helpers.rsi
+        state: none
+        visible: false
       - map: [ "enum.HumanoidVisualLayers.Eyes" ]
         color: "#008800"
         sprite: Mobs/Customization/eyes.rsi
@@ -88,20 +104,17 @@
       - map: [ "ears" ]
       - map: [ "outerClothing" ]
       - map: [ "eyes" ]
-      - map: [ "enum.HumanoidVisualLayers.TailFront" ]
-        color: "#34a223"
-        state: tail_smooth_front
-        sprite: Mobs/Customization/reptilian_parts.rsi
       - map: [ "belt" ]
       - map: [ "neck" ]
       - map: [ "back" ]
-      - map: [ "enum.HumanoidVisualLayers.Frills" ]
-        state: frills_simple
-        color: "#34a223"
-        sprite: Mobs/Customization/reptilian_parts.rsi
-      - map: [ "enum.HumanoidVisualLayers.Horns" ]
-        state: horns_simple
-        sprite: Mobs/Customization/reptilian_parts.rsi
+      - map: [ "enum.HumanoidVisualLayers.HeadSide" ]
+        sprite: Mobs/Customization/masking_helpers.rsi
+        state: none
+        visible: false
+      - map: [ "enum.HumanoidVisualLayers.HeadTop" ]
+        sprite: Mobs/Customization/masking_helpers.rsi
+        state: none
+        visible: false
       - map: [ "mask" ]
       - map: [ "head" ]
       - map: [ "pocket1" ]
@@ -138,16 +151,30 @@
   noSpawn: true
   description: A dummy reptilian meant to be used in character setup.
   components:
+  - type: Markings
+    layerPoints:
+      Tail:
+        points: 1
+        required: true
+        defaultMarkings: [LizardTailSmooth] 
+      Snout:
+        points: 1
+        required: true
+        defaultMarkings: [LizardSnoutRound]
+      HeadTop:
+        points: 1
+        required: false
+      HeadSide:
+        points: 1
+        required: false
   - type: Sprite
     netsync: false
     noRot: true
     drawdepth: Mobs
     scale: 1, 1
     layers:
-      - map: [ "enum.HumanoidVisualLayers.TailBehind" ]
-        color: "#34a223"
-        state: tail_smooth_behind
-        sprite: Mobs/Customization/reptilian_parts.rsi
+      - map: [ "enum.HumanoidVisualLayers.Tail" ]
+        visible: false
       - map: [ "enum.HumanoidVisualLayers.Chest" ]
         color: "#34a223"
         sprite: Mobs/Species/Reptilian/parts.rsi
@@ -157,9 +184,7 @@
         sprite: Mobs/Species/Reptilian/parts.rsi
         state: head_m
       - map: [ "enum.HumanoidVisualLayers.Snout" ]
-        color: "#34a223"
-        state: snout_round
-        sprite: Mobs/Customization/reptilian_parts.rsi
+        visible: false
       - map: [ "enum.HumanoidVisualLayers.Eyes" ]
         color: "#008800"
         sprite: Mobs/Customization/eyes.rsi
@@ -217,19 +242,13 @@
       - map: [ "ears" ]
       - map: [ "outerClothing" ]
       - map: [ "eyes" ]
-      - map: [ "enum.HumanoidVisualLayers.TailFront" ]
-        color: "#34a223"
-        state: tail_smooth_front
-        sprite: Mobs/Customization/reptilian_parts.rsi
       - map: [ "belt" ]
       - map: [ "neck" ]
       - map: [ "back" ]
-      - map: [ "enum.HumanoidVisualLayers.Frills" ]
-        state: frills_simple
-        sprite: Mobs/Customization/reptilian_parts.rsi
-      - map: [ "enum.HumanoidVisualLayers.Horns" ]
-        state: horns_simple
-        sprite: Mobs/Customization/reptilian_parts.rsi
+      - map: [ "enum.HumanoidVisualLayers.HeadSide" ]
+        visible: false
+      - map: [ "enum.HumanoidVisualLayers.HeadTop" ]
+        visible: false
       - map: [ "mask" ]
       - map: [ "head" ]
       - map: [ "pocket1" ]
diff --git a/Resources/Textures/Mobs/Customization/cat_parts.rsi/ears_cat_inner.png b/Resources/Textures/Mobs/Customization/cat_parts.rsi/ears_cat_inner.png
new file mode 100644
index 0000000000000000000000000000000000000000..db8e8b67da3cee3d5eaa7bf86cc9467b78847546
GIT binary patch
literal 5181
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

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Mobs/Customization/cat_parts.rsi/ears_cat_outer.png b/Resources/Textures/Mobs/Customization/cat_parts.rsi/ears_cat_outer.png
new file mode 100644
index 0000000000000000000000000000000000000000..0eef3afc75506394c2e40c9d41bc4a01364fe19c
GIT binary patch
literal 5836
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

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Mobs/Customization/cat_parts.rsi/meta.json b/Resources/Textures/Mobs/Customization/cat_parts.rsi/meta.json
new file mode 100644
index 0000000000..77c6e978d2
--- /dev/null
+++ b/Resources/Textures/Mobs/Customization/cat_parts.rsi/meta.json
@@ -0,0 +1,2 @@
+{"version": 1, "size": {"x": 32, "y": 32}, "license": "CC-BY-SA-3.0", "copyright": "https://github.com/tgstation/tgstation/blob/master/icons/mob/mutant_bodyparts.dmi", "states": [{"name":"ears_cat_inner","directions":4},{"name":"ears_cat_outer","directions":4},{"name":"tail_cat","directions":4}]}
+
diff --git a/Resources/Textures/Mobs/Customization/cat_parts.rsi/tail_cat.png b/Resources/Textures/Mobs/Customization/cat_parts.rsi/tail_cat.png
new file mode 100644
index 0000000000000000000000000000000000000000..bb6b2de8efd423d8f408003834500366fd8a6c32
GIT binary patch
literal 247
zcmeAS@N?(olHy`uVBq!ia0vp^4j|0I1|(Ny7TyC=`#fD7Ln`LHz2(SvSb@jo;zD<?
zTfgNSCTZ{N?kbg4P%!_$c5y}zkCTxQQ1PRaOC$7-R{fjk)*5;6jL)Qd#}z%R-d4Y;
znl&@BT)pM`E{=ZfLoSDy*6<k|TKm0T@93(lk;`_Me!TSk$^P7rKm$OaV5VU5i<#%1
zl=`>LyM1k5#-@dl%6#%!asJ{vtQD4uJo|WX=9+p#nYRal#t1lFalY_*?P}&%+G{-a
p%)H4I_tkEL)p32Bnam)g+WGr6+c*7XiYo>2JYD@<);T3K0RS^iWfK4Z

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Mobs/Customization/masking_helpers.rsi/meta.json b/Resources/Textures/Mobs/Customization/masking_helpers.rsi/meta.json
index 530b0c4848..ead033a613 100644
--- a/Resources/Textures/Mobs/Customization/masking_helpers.rsi/meta.json
+++ b/Resources/Textures/Mobs/Customization/masking_helpers.rsi/meta.json
@@ -1 +1 @@
-{"version": 1, "size": {"x": 32, "y": 32}, "states": [{"name": "female_full", "directions": 4, "delays": [[1.0], [1.0], [1.0], [1.0]]}, {"name": "female_top", "directions": 4, "delays": [[1.0], [1.0], [1.0], [1.0]]}]}
\ No newline at end of file
+{"version": 1, "size": {"x": 32, "y": 32}, "states": [{"name": "female_full", "directions": 4, "delays": [[1.0], [1.0], [1.0], [1.0]]}, {"name": "female_top", "directions": 4, "delays": [[1.0], [1.0], [1.0], [1.0]]}, {"name": "none"}]}
diff --git a/Resources/Textures/Mobs/Customization/masking_helpers.rsi/none.png b/Resources/Textures/Mobs/Customization/masking_helpers.rsi/none.png
new file mode 100644
index 0000000000000000000000000000000000000000..6e3cb09bcf701bc53ecc7886c19b82d386469aa6
GIT binary patch
literal 83
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=fdzDNh&2kcv5P4>B?Wc})uc*XMaS
bfSB*u1QZw;C7n&)0XYnwu6{1-oD!M<tCSLC

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Mobs/Customization/reptilian_parts.rsi/meta.json b/Resources/Textures/Mobs/Customization/reptilian_parts.rsi/meta.json
index 5f8b7b955c..f674cbe42f 100644
--- a/Resources/Textures/Mobs/Customization/reptilian_parts.rsi/meta.json
+++ b/Resources/Textures/Mobs/Customization/reptilian_parts.rsi/meta.json
@@ -39,6 +39,22 @@
             "name": "tail_ltiger_behind",
             "directions": 4
         },
+	{
+	    "name": "tail_smooth",
+	    "directions": 4
+	},
+	{
+	    "name": "tail_spikes",
+	    "directions": 4
+	},
+	{
+	    "name": "tail_dtiger",
+	    "directions": 4
+	},
+	{
+	    "name": "tail_ltiger",
+	    "directions": 4
+	},
         {
             "name": "snout_round",
             "directions": 4
diff --git a/Resources/Textures/Mobs/Customization/reptilian_parts.rsi/tail_dtiger.png b/Resources/Textures/Mobs/Customization/reptilian_parts.rsi/tail_dtiger.png
new file mode 100644
index 0000000000000000000000000000000000000000..a4fe8f6c908a6317dd7293a2e7a54c328e52e674
GIT binary patch
literal 6716
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
B*T4V(

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Mobs/Customization/reptilian_parts.rsi/tail_ltiger.png b/Resources/Textures/Mobs/Customization/reptilian_parts.rsi/tail_ltiger.png
new file mode 100644
index 0000000000000000000000000000000000000000..19c5633cec634aae95a6074290389a703edfa61f
GIT binary patch
literal 7315
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

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Mobs/Customization/reptilian_parts.rsi/tail_smooth.png b/Resources/Textures/Mobs/Customization/reptilian_parts.rsi/tail_smooth.png
new file mode 100644
index 0000000000000000000000000000000000000000..b5bfd9f97b9db2909db9582ea7735b3ed3459ead
GIT binary patch
literal 7022
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
K2E}@wC;tQ64}*^Y

literal 0
HcmV?d00001

diff --git a/Resources/Textures/Mobs/Customization/reptilian_parts.rsi/tail_spikes.png b/Resources/Textures/Mobs/Customization/reptilian_parts.rsi/tail_spikes.png
new file mode 100644
index 0000000000000000000000000000000000000000..81f01e6c84f85c2e67bb2902d5e06c346e0decd4
GIT binary patch
literal 6817
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
DbCe87

literal 0
HcmV?d00001