Humanoid appearance refactor (#10882)

* initial commit - species prototype modifications - markings points as its own file - shared humanoid component * adds a tool to convert sprite accessories to markings (in go) * removes a fmt call * converts sprite accessory to markings * adds hair and facial hair to marking categories * multiple changes - humanoid visualizer system - markings modifications for visualizer - modifications to shared humanoid component - lays out a base for humanoid system * hidden layers, ports some properties from appearance component, shrinks DefaultMarkings a little * squishes the initialize event calls into one function adds stuff to set species/skin color externally from a server message - currently laid out as if it a dirty call to a networked component, may be subject to change (server-side has not been implemented yet) * makes the sprite pipeline more obvious * apply all markings, hidden layer set replacement * ensures that markings are cleared when the new set is applied * starts refactoring markingsset (unfinished) * more additions to the markingset api * adds constructor logic to markingset * adds a method to filter out markings in a set based on a given species * fixes enumerators in markingset * adds validator into MarkingSet, fixes ForwardMarkingEnumerator * modifications to the humanoid visual system * ensuredefault in markingset * oop * fixes up data keys, populates OnAppearanceChange in visualizer * changes to humanoid component, markings marking equality is now more strict, humanoidcomponent is now implemented for client as a child of sharedhumanoidcomponent * markings are now applied the visualizer by diffing them * base sprites are now applied to humanoids from humanoidvisualizer * passes along base sprite settings to the marking application so that markings know to follow skin color/alpha or not (see: slimes) * custom base layers on humanoids * merges all data keys into one data class for humanoid visualizers * setappearance in sharedhumanoidsystem, removes custombaselayercolors * humanoidcomponent, system (empty) in server * adds some basic public API functions to HumanoidSystem * add marking, remove marking * changes appearance MarkingsSet to a List<Marking>, adds listener for PlayerSpawnCompleteEvent in HumanoidSystem * ensuredefaultmarkings, oninit for humanoids * markingmanager API changes * removes MarkingsSet * LoadProfile, adjusts randomization in humanoid appearance to account for species * base layer settings in humanoidsystem, eye color from profile * rearranges files to centralize under Humanoid namespace * more reorganization, deletes some stuff gotta break stuff to make other things work, right? goodbye SpriteAccessory... * fixes a good chunk of server-side issues still does not compile, yet * singlemarkingpicker xaml layout * singlemarkingpicker logic * magic mirror window (varying pieces of it, mostly client-oriented) * removes some imports, gives MagicMirror a BUI class (not filled in yet) * populates magic mirror BUI functionality / window callbacks * fixes up some errors in humanoidprofileeditor * changes to SingleMarkingPicker SingleMarkingPicker now accepts a List<Marking>, species, and total possible markings available in that marking category * fixes up hair pickers on humanoid profile editor * fixes the errors in markingpicker * markingsystem is now gone * fixes a bunch of build errors * so that's why i did it like that * namespace issues, adds robustxamlloader to singlemarkingpicker * another robustxamlloader * human, lizard sprites/points * prototype fixes, deletion of old spriteaccessory * component registration, fixes dwarf skin toning no, 'ReptilianToned' does not exist * removes component registration from abstract humanoid component * visualizer data now cloneable * serialize for visualizer key * zero-count edge case * missing semi-colon moment * setspecies in humanoidsystem * ensures that default markings, if empty, will cause ensuredefault to skip over that given category * tryadd instead of add * whoops * diff and apply should properly apply markings now * always ensure default, fixes double load for player spawning * apply skin color now sets the skin color property in humanoidcomponent * removes sprite from a few species prototypes * sprite changes for specific base layers based on humanoid sex * layer ordering fix, and a missing base layer should now disallow markings on that layer * anymarking base layer, adds the right leg/foot for humans * loading a profile will now clear all markings on that humanoid * adds missing layers for humans * separates species.yml into respective species prototype files * ensures that if layer visibility was changed, all markings have to be reapplied * server-side enforcement of hiding hair (and other head-related markings) when equipping things that hide hair * slime fix, clothingsystem now dictates layer visibility server side * sussy * layer settings should now ensure a marking should match the skin tone * whoops * skincolor static class and functions in UI * skin color validation in humanoidcharacterappearance * markingpicker now shows only the markings for the selected category in used * getter for slot in singlemarkingpicker now ensures slot is 0 if markings exists * FilterSpecies no longer attempts to do removal while iterating * expands for SingleMarkingPicker * humanoid base dummy has blank layers now (and snout/tail/headside/headtop) * fixes an issue with visualizer system if the marking count was different but the markings themselves were (somewhat) the same * whoops * adds edge case handlers for count differences in humanoid markings * preview now loads profile instead of directly setting appearance * moves marking set loading to update controls * clones a marking set in markingpicker by using the deep clone constructor * whoops (deep cloning a marking now copies the marking id) * adds replace function for markingset * points should now update after the markings are remove/added * merging base layer sprites into a humanoid should now clear them before merging * sets dirty range start to count only if the dirty range start was never set above 0 * fixes up some issues with singlemarkingpicker * color selector sliders in single marking picker should now expand * hair from hair pickers should now apply in profile loading (client-side) * category in singlemarkingpicker now sets the private category variable * slot selector should now populate * single marking picker buttons now have text, also shows the category name over all user-clickable elements * removes a comment * removing hair slots now sets it to bald, defaults to zero used slots if current hair is bald on hair/facial hair * random skin color, eye color * populate colors now checks if the marking count is greater than zero in singlemarkingpicker * hair/facial hair pickers now just get the first possible hair from the respective species list * different approach to random skin color * oh, that's why it wasn't working * randomize everything now just updates every single control * selecting a new marking in SingleMarkingPicker should attempt to copy over old colors, populate list now uses cache, * markingmanager now uses OnlyWhitelisted to populate by category and species * filterspecies now uses onlyWhitelist to filter markings based on whitelist or not * oops * ui fix for singlemarkingpicker, ensures that cache is not null if it is null when populatelist is called * order of operations for the horizontal expand for add/remove * hair pickers should now update when you add/remove the hair slot * fixes variable naming error in character appearance * loc string fix in singlemarkingpicker * lizards, vox now have onlyWhitelist, vox restriction for hair/facialhairs * having zero possible hairs should no longer cause an exception in randomization * setting species should now update hair pickers * ignore categories for marking picker * and a clear as well for the category button * places that functionality in its own function instead * adds eye base sprite, vox now also have their own custom eye sprites * loading a profile client-side should do FilterSpecies for markings now * client-side load profile does filter species after adding in the hairs now * magic mirror * callbacks now call the callback instead of adding it on construct * whoops * in removemarking too * adds missing synchronize calls * comments out an updateinterface call in magic mirror * magic mirror window title, minimum sizing * fixes minsize, adds warning for players who try to set their hair for species that have no hair * removes spaces in xaml * namespace changes/organization * whoopsie (merge conflicts) * re-enables identity from humanoid component * damagevisuals now uses the enum given to it instead of the layerstate given on that layer tied to the enum * removes commas from json * changes to visuals system so the change is consistent * chest * reptilian * visualizer system now handles body sprite setting/coloration, similar to how characterappearance did it not a big fan of this * adds a check in applybasesprites * adding/removing parts should now make them invisible on a humanoid * body part removal/adding now enumerates over sublayers instead * synchro now runs in bodycomponent startup * parts instead of slots * humanoidcompnent check * switches from rsi to actualrsi * removes all the body stuff (too slow) * cleans up resolves from humanoid visualizer system * merging sprites now checks if the base sprites have been modified or not (through things like species changes, or custom base sprite changes) * not forgetting that one again * merging now returns an actual dirty value * replaces the sequenceequal with a more accurate solution * permanent layers, layer visibility on add/remove part in body * should send all hidden layers over now * isdirty in visualizer system for base layers * isdirty checks count as well * ok, IsDirty should now set the base layers if the merged sprites are different * equals override in HumanoidSpritePrototypes.cs temporary until record prototypes :heck: * makes fields readonly, equates IDs instead * adds forced markings through marking picker * forced in humanoidsystem api, ignorespecies in markingpicker * marking bui * makes that serializable as well * ignore species/forced toggles now work * adds icon to modifier verb, interface and keys to humanoid bases * needs the actual enum value to open, no? * makes the key the actual key * actions now propagate upwards * ignore species when set now repopulates markingpicker * modifiable base layers in the markings window * oops! * layout changes * info box should now appear * adds ignorespecies for marking picker, collapsible for base layer section of appearance modification window * collapsible layout moment * if base layers have changed, all markings are now dirty (and if a base layer is missing, the marking is still 'applied' but it's now just invisible * small change to marking visibility * small changes to modifier UI * markings now match skin on zombification * zombie stuff * makes the line edit in marking modifier window more obvious * disables vox on round start * horizontal expand on the single label in base layer modifiers * humanoid profiles in prototypes * randomhumanoidappearance won't work if the humanoid has a profile already stored * removes unused code * documentation in humanoidsystem server-side * documentation in shared/client * whoops * converts accessory into marking in locale files (also adds marking loc string into single marking picker) * be gone, shared humanoid appearance system from the last upstream merge * species ignore on randomization (defaults to no ignored species) * more upstream merge parts that bypassed any errors before merge * addresses review (also just adds typeserializers in some places) * submodule moment * upstream merge issues
2022-09-22 15:19:00 -07:00
parent dd994e9ee1
commit 5a0a04bde7
184 changed files with 7667 additions and 5209 deletions
--- a/Content.Client/Humanoid/MarkingPicker.xaml.cs
+++ b/Content.Client/Humanoid/MarkingPicker.xaml.cs
@@ -0,0 +1,463 @@
+using System.Linq;
+using Content.Shared.Humanoid;
+using Content.Shared.Humanoid.Markings;
+using Content.Shared.Humanoid.Prototypes;
+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.Prototypes;
+using Robust.Shared.Utility;
+using static Robust.Client.UserInterface.Controls.BoxContainer;
+
+namespace Content.Client.Humanoid;
+
+[GenerateTypedNameReferences]
+public sealed partial class MarkingPicker : Control
+{
+    [Dependency] private readonly MarkingManager _markingManager = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
+    public Action<MarkingSet>? OnMarkingAdded;
+    public Action<MarkingSet>? OnMarkingRemoved;
+    public Action<MarkingSet>? OnMarkingColorChange;
+    public Action<MarkingSet>? OnMarkingRankChange;
+
+    private List<Color> _currentMarkingColors = new();
+
+    private ItemList.Item? _selectedMarking;
+    private ItemList.Item? _selectedUnusedMarking;
+    private MarkingCategories _selectedMarkingCategory = MarkingCategories.Chest;
+
+    private MarkingSet _currentMarkings = new();
+
+    private List<MarkingCategories> _markingCategories = Enum.GetValues<MarkingCategories>().ToList();
+
+    private string _currentSpecies = SharedHumanoidSystem.DefaultSpecies;
+    public Color CurrentSkinColor = Color.White;
+
+    private readonly HashSet<MarkingCategories> _ignoreCategories = new();
+
+    public string IgnoreCategories
+    {
+        get => string.Join(',',  _ignoreCategories);
+        set
+        {
+            _ignoreCategories.Clear();
+            var split = value.Split(',');
+            foreach (var category in split)
+            {
+                if (!Enum.TryParse(category, out MarkingCategories categoryParse))
+                {
+                    continue;
+                }
+
+                _ignoreCategories.Add(categoryParse);
+            }
+
+            SetupCategoryButtons();
+        }
+    }
+
+    public bool Forced { get; set; }
+
+    private bool _ignoreSpecies;
+
+    public bool IgnoreSpecies
+    {
+        get => _ignoreSpecies;
+        set
+        {
+            _ignoreSpecies = value;
+            Populate();
+        }
+    }
+
+    public void SetData(List<Marking> newMarkings, string species, Color skinColor)
+    {
+        var pointsProto = _prototypeManager
+            .Index<SpeciesPrototype>(species).MarkingPoints;
+        _currentMarkings = new(newMarkings, pointsProto, _markingManager);
+
+        if (!IgnoreSpecies)
+        {
+            _currentMarkings.FilterSpecies(species); // should be validated server-side but it can't hurt
+        }
+
+        _currentSpecies = species;
+        CurrentSkinColor = skinColor;
+
+        Populate();
+        PopulateUsed();
+    }
+
+    public void SetData(MarkingSet set, string species, Color skinColor)
+    {
+        _currentMarkings = set;
+
+        if (!IgnoreSpecies)
+        {
+            _currentMarkings.FilterSpecies(species); // should be validated server-side but it can't hurt
+        }
+
+        _currentSpecies = species;
+        CurrentSkinColor = skinColor;
+
+        Populate();
+        PopulateUsed();
+    }
+
+    public void SetSkinColor(Color color) => CurrentSkinColor = color;
+
+    public MarkingPicker()
+    {
+        RobustXamlLoader.Load(this);
+        IoCManager.InjectDependencies(this);
+
+        SetupCategoryButtons();
+        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 void SetupCategoryButtons()
+    {
+        CMarkingCategoryButton.Clear();
+        for (var i = 0; i < _markingCategories.Count; i++)
+        {
+            if (_ignoreCategories.Contains(_markingCategories[i]))
+            {
+                continue;
+            }
+
+            CMarkingCategoryButton.AddItem(Loc.GetString($"markings-category-{_markingCategories[i].ToString()}"), i);
+        }
+        CMarkingCategoryButton.SelectId(_markingCategories.IndexOf(_selectedMarkingCategory));
+    }
+
+    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 = IgnoreSpecies
+            ? _markingManager.MarkingsByCategory(_selectedMarkingCategory)
+            : _markingManager.MarkingsByCategoryAndSpecies(_selectedMarkingCategory, _currentSpecies);
+
+        foreach (var marking in markings.Values)
+        {
+            if (_currentMarkings.TryGetCategory(_selectedMarkingCategory, out var listing)
+                && listing.Contains(marking.AsMarking()))
+            {
+                continue;
+            }
+
+            var item = CMarkingsUnused.AddItem($"{GetMarkingName(marking)}", marking.Sprites[0].Frame0());
+            item.Metadata = marking;
+        }
+
+        CMarkingPoints.Visible = _currentMarkings.PointsLeft(_selectedMarkingCategory) != -1;
+    }
+
+    // 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;
+
+        if (!IgnoreSpecies)
+        {
+            _currentMarkings.FilterSpecies(_currentSpecies, _markingManager);
+        }
+
+        // walk backwards through the list for visual purposes
+        foreach (var marking in _currentMarkings.GetReverseEnumerator(_selectedMarkingCategory))
+        {
+            if (!_markingManager.TryGetMarking(marking, out var newMarking))
+            {
+                continue;
+            }
+
+            var text = Loc.GetString(marking.Forced ? "marking-used-forced" : "marking-used", ("marking-name", $"{GetMarkingName(newMarking)}"),
+                ("marking-category", Loc.GetString($"markings-category-{newMarking.MarkingCategory}")));
+
+            var _item = new ItemList.Item(CMarkingsUsed)
+            {
+                Text = text,
+                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(_selectedMarkingCategory, src);
+                break;
+            // i.e., we're going up in rank
+            case > 0:
+                _currentMarkings.ShiftRankUpFromEnd(_selectedMarkingCategory, 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 markingList = _currentMarkings.GetForwardEnumerator().ToList();
+
+        var speciesPrototype = _prototypeManager.Index<SpeciesPrototype>(species);
+
+        _currentMarkings = new(markingList, speciesPrototype.MarkingPoints, _markingManager, _prototypeManager);
+        _currentMarkings.FilterSpecies(species);
+
+        Populate();
+        PopulateUsed();
+    }
+
+    private void UpdatePoints()
+    {
+        var count = _currentMarkings.PointsLeft(_selectedMarkingCategory);
+        if (count > -1)
+        {
+            CMarkingPoints.Text = Loc.GetString("marking-points-remaining", ("points", count));
+        }
+    }
+
+    private void OnCategoryChange(OptionButton.ItemSelectedEventArgs category)
+    {
+        CMarkingCategoryButton.SelectId(category.Id);
+        _selectedMarkingCategory = _markingCategories[category.Id];
+        Populate();
+        PopulateUsed();
+        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 listing = _currentMarkings[_selectedMarkingCategory];
+
+            var currentColor = new Color(
+                listing[listing.Count - 1 - item.ItemIndex].MarkingColors[i].RByte,
+                listing[listing.Count - 1 - item.ItemIndex].MarkingColors[i].GByte,
+                listing[listing.Count - 1 - item.ItemIndex].MarkingColors[i].BByte
+            );
+            colorSelector.Color = currentColor;
+            _currentMarkingColors.Add(currentColor);
+            var colorIndex = _currentMarkingColors.Count - 1;
+
+            Action<Color> colorChanged = _ =>
+            {
+                _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(_selectedMarkingCategory, markingPrototype.ID);
+
+        if (markingIndex < 0) return;
+
+        _selectedMarking.IconModulate = _currentMarkingColors[colorIndex];
+
+        var marking = new Marking(_currentMarkings[_selectedMarkingCategory][markingIndex]);
+        marking.SetColor(colorIndex, _currentMarkingColors[colorIndex]);
+        _currentMarkings.Replace(_selectedMarkingCategory, markingIndex, marking);
+
+        OnMarkingColorChange?.Invoke(_currentMarkings);
+    }
+
+    private void MarkingAdd()
+    {
+        if (_selectedUnusedMarking is null) return;
+
+        if (_currentMarkings.PointsLeft(_selectedMarkingCategory) == 0 && !Forced)
+        {
+            return;
+        }
+
+        var marking = (MarkingPrototype) _selectedUnusedMarking.Metadata!;
+
+
+        var markingObject = marking.AsMarking();
+        for (var i = 0; i < markingObject.MarkingColors.Count; i++)
+        {
+            markingObject.SetColor(i, CurrentSkinColor);
+        }
+
+        markingObject.Forced = Forced;
+
+        _currentMarkings.AddBack(_selectedMarkingCategory, markingObject);
+
+        UpdatePoints();
+
+        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;
+
+        var marking = (MarkingPrototype) _selectedMarking.Metadata!;
+
+        _currentMarkings.Remove(_selectedMarkingCategory, marking.ID);
+
+        UpdatePoints();
+
+        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);
+    }
+}