.

GlamourerOld/State/ActiveDesign.Manager.cs

@@ -0,0 +1,305 @@
+using System;
+using System.Collections;
+using Glamourer.Interop;
+using Penumbra.GameData.Actors;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using FFXIVClientStructs.FFXIV.Client.Game.Object;
+using Glamourer.Api;
+using Glamourer.Customization;
+using Glamourer.Designs;
+using Glamourer.Services;
+using Penumbra.Api.Enums;
+using Penumbra.GameData.Enums;
+using Penumbra.GameData.Structs;
+using CustomizeData = Penumbra.GameData.Structs.CustomizeData;
+
+namespace Glamourer.State;
+
+public sealed partial class ActiveDesign
+{
+    [Flags]
+    public enum ChangeType
+    {
+        Default = 0x00,
+        Changed = 0x01,
+        Fixed   = 0x02,
+    }
+
+    public class Manager : IReadOnlyDictionary<ActorIdentifier, ActiveDesign>
+    {
+        private readonly ActorService           _actors;
+        private readonly ObjectManager          _objects;
+        private readonly PenumbraAttach         _penumbra;
+        private readonly ItemManager            _items;
+        private readonly VisorService           _visor;
+        private readonly ChangeCustomizeService _customize;
+        private readonly UpdateSlotService      _updateSlot;
+        private readonly WeaponService          _weaponService;
+
+        private readonly Dictionary<ActorIdentifier, ActiveDesign> _characterSaves = new();
+
+        public Manager(ActorService actors, ObjectManager objects, PenumbraAttach penumbra, ItemManager items, VisorService visor,
+            ChangeCustomizeService customize, UpdateSlotService updateSlot, WeaponService weaponService)
+        {
+            _actors        = actors;
+            _objects       = objects;
+            _penumbra      = penumbra;
+            _items         = items;
+            _visor         = visor;
+            _customize     = customize;
+            _updateSlot    = updateSlot;
+            _weaponService = weaponService;
+        }
+
+        public IEnumerator<KeyValuePair<ActorIdentifier, ActiveDesign>> GetEnumerator()
+            => _characterSaves.GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator()
+            => GetEnumerator();
+
+        public int Count
+            => _characterSaves.Count;
+
+        public bool ContainsKey(ActorIdentifier key)
+            => _characterSaves.ContainsKey(key);
+
+        public bool TryGetValue(ActorIdentifier key, [NotNullWhen(true)] out ActiveDesign? value)
+            => _characterSaves.TryGetValue(key, out value);
+
+        public ActiveDesign this[ActorIdentifier key]
+            => _characterSaves[key];
+
+        public IEnumerable<ActorIdentifier> Keys
+            => _characterSaves.Keys;
+
+        public IEnumerable<ActiveDesign> Values
+            => _characterSaves.Values;
+
+        public void DeleteSave(ActorIdentifier identifier)
+            => _characterSaves.Remove(identifier);
+
+        public unsafe ActiveDesign GetOrCreateSave(Actor actor)
+        {
+            var id = _actors.AwaitedService.FromObject((GameObject*)actor.Pointer, out _, false, false, false);
+            if (_characterSaves.TryGetValue(id, out var save))
+            {
+                save.Initialize(_items, actor);
+                return save;
+            }
+
+            id   = id.CreatePermanent();
+            save = new ActiveDesign(_items, id, actor);
+            save.Initialize(_items, actor);
+            _characterSaves.Add(id, save);
+            return save;
+        }
+
+        public void SetWetness(ActiveDesign design, bool wet, bool fromFixed)
+            => design.IsWet = wet;
+
+        public void SetHatVisible(ActiveDesign design, bool visible, bool fromFixed)
+            => design.IsHatVisible = visible;
+
+        public void SetVisor(ActiveDesign design, bool toggled, bool fromFixed)
+            => design.IsVisorToggled = toggled;
+
+        public void SetWeaponVisible(ActiveDesign design, bool visible, bool fromFixed)
+            => design.IsWeaponVisible = visible;
+
+        public unsafe void ApplyDesign(ActiveDesign to, Design from, bool fromFixed)
+        {
+            if (to.ModelId != from.ModelId)
+                return;
+
+            if (from.DoApplyEquip(EquipSlot.MainHand))
+                ChangeMainHand(to, from.MainHandId, fromFixed);
+            if (from.DoApplyStain(EquipSlot.MainHand))
+                ChangeStain(to, EquipSlot.MainHand, from.WeaponMain.Stain, fromFixed);
+
+            if (from.DoApplyEquip(EquipSlot.OffHand))
+                ChangeOffHand(to, from.OffHandId, fromFixed);
+            if (from.DoApplyStain(EquipSlot.OffHand))
+                ChangeStain(to, EquipSlot.OffHand, from.WeaponOff.Stain, fromFixed);
+
+            foreach (var slot in EquipSlotExtensions.EqdpSlots)
+            {
+                var armor = from.Armor(slot);
+                if (from.DoApplyEquip(slot))
+                    ChangeEquipment(to, slot, armor, fromFixed);
+                if (from.DoApplyStain(slot))
+                    ChangeStain(to, slot, armor.Stain, fromFixed);
+            }
+
+            ChangeCustomize(to, from.ApplyCustomize, from.ModelData.Customize.Data, fromFixed);
+
+            if (from.Wetness.Enabled)
+                SetWetness(to, from.Wetness.ForcedValue, fromFixed);
+            if (from.Hat.Enabled)
+                SetHatVisible(to, from.Hat.ForcedValue, fromFixed);
+            if (from.Visor.Enabled)
+                SetVisor(to, from.Visor.ForcedValue, fromFixed);
+            if (from.Weapon.Enabled)
+                SetWeaponVisible(to, from.Weapon.ForcedValue, fromFixed);
+        }
+
+        public void RevertDesign(ActiveDesign design)
+        {
+            RevertCustomize(design, design.ChangedCustomize);
+            foreach (var slot in EquipSlotExtensions.EqdpSlots)
+                RevertEquipment(design, slot, design.ChangedEquip.HasFlag(slot.ToFlag()), design.ChangedEquip.HasFlag(slot.ToStainFlag()));
+
+            RevertMainHand(design);
+            RevertOffHand(design);
+        }
+
+        public void ChangeMainHand(ActiveDesign design, uint itemId, bool fromFixed)
+            => design.SetMainhand(_items, itemId);
+
+        public void ChangeOffHand(ActiveDesign design, uint itemId, bool fromFixed)
+            => design.SetOffhand(_items, itemId);
+
+        public void RevertMainHand(ActiveDesign design)
+        { }
+
+        public void RevertOffHand(ActiveDesign design)
+        { }
+
+        public void RevertCustomize(ActiveDesign design, CustomizeFlag flags)
+            => ChangeCustomize(design, flags, design._initialData.Customize.Data, false);
+
+        public void ChangeCustomize(ActiveDesign design, CustomizeFlag flags, CustomizeData newValue, bool fromFixed)
+        {
+            var customize  = new Customize(newValue);
+            var anyChanges = false;
+            foreach (var option in Enum.GetValues<CustomizeIndex>())
+            {
+                var flag  = option.ToFlag();
+                var apply = flags.HasFlag(flag);
+                anyChanges |= apply && design.SetCustomize(option, customize[option]);
+                if (design.GetCustomize(option).Value != design._initialData.Customize[option].Value)
+                    design.ChangedCustomize |= flag;
+                else
+                    design.ChangedCustomize &= ~flag;
+
+                if (fromFixed)
+                    design.FixedCustomize |= flag;
+                else
+                    design.FixedCustomize &= ~flag;
+            }
+
+            if (!anyChanges)
+                return;
+
+            _objects.Update();
+            if (!_objects.TryGetValue(design.Identifier, out var data))
+                return;
+
+            var redraw = flags.RequiresRedraw();
+            foreach (var obj in data.Objects)
+            {
+                if (redraw)
+                    _penumbra.RedrawObject(obj, RedrawType.Redraw);
+                else
+                    _customize.UpdateCustomize(obj, design.ModelData.Customize.Data);
+            }
+        }
+
+        public void RevertEquipment(ActiveDesign design, EquipSlot slot, bool equip, bool stain)
+        {
+            var item = design._initialData.Armor(slot);
+            if (equip)
+            {
+                var flag = slot.ToFlag();
+                design.UpdateArmor(_items, slot, item, true);
+                design.ChangedEquip &= ~flag;
+                design.FixedEquip   &= ~flag;
+            }
+
+            if (stain)
+            {
+                var flag = slot.ToStainFlag();
+                design.SetStain(slot, item.Stain);
+                design.ChangedEquip &= ~flag;
+                design.FixedEquip   &= ~flag;
+            }
+
+            _objects.Update();
+            if (!_objects.TryGetValue(design.Identifier, out var data))
+                return;
+
+            foreach (var obj in data.Objects)
+                _updateSlot.UpdateSlot(obj.DrawObject, slot, item);
+        }
+
+        public void ChangeEquipment(ActiveDesign design, EquipSlot slot, Item item, bool fromFixed)
+        {
+            var flag = slot.ToFlag();
+            design.SetArmor(slot, item);
+            var current = design.Armor(slot);
+            var initial = design._initialData.Armor(slot);
+            if (current.ModelBase.Value != initial.Set.Value || current.Variant != initial.Variant)
+                design.ChangedEquip |= flag;
+            else
+                design.ChangedEquip &= ~flag;
+            if (fromFixed)
+                design.FixedEquip |= flag;
+            else
+                design.FixedEquip &= ~flag;
+
+            _objects.Update();
+            if (!_objects.TryGetValue(design.Identifier, out var data))
+                return;
+
+            foreach (var obj in data.Objects)
+                _updateSlot.UpdateSlot(obj.DrawObject, slot, item.Model);
+        }
+
+        public void ChangeStain(ActiveDesign design, EquipSlot slot, StainId stain, bool fromFixed)
+        {
+            var flag = slot.ToStainFlag();
+            design.SetStain(slot, stain);
+            var (current, initial, weapon) = slot switch
+            {
+                EquipSlot.MainHand => (design.WeaponMain.Stain, design._initialData.MainHand.Stain, true),
+                EquipSlot.OffHand  => (design.WeaponOff.Stain, design._initialData.OffHand.Stain, true),
+                _                  => (design.Armor(slot).Stain, design._initialData.Armor(slot).Stain, false),
+            };
+            if (current.Value != initial.Value)
+                design.ChangedEquip |= flag;
+            else
+                design.ChangedEquip &= ~flag;
+            if (fromFixed)
+                design.FixedEquip |= flag;
+            else
+                design.FixedEquip &= ~flag;
+
+            _objects.Update();
+            if (!_objects.TryGetValue(design.Identifier, out var data))
+                return;
+
+            foreach (var obj in data.Objects)
+            {
+                if (weapon)
+                    _weaponService.LoadStain(obj, EquipSlot.MainHand, stain);
+                else
+                    _updateSlot.UpdateStain(obj.DrawObject, slot, stain);
+            }
+        }
+
+        public void ChangeVisor(ActiveDesign design, bool on, bool fromFixed)
+        {
+            var current = design.IsVisorToggled;
+            if (current == on)
+                return;
+
+            design.IsVisorToggled = on;
+            _objects.Update();
+            if (!_objects.TryGetValue(design.Identifier, out var data))
+                return;
+
+            foreach (var obj in data.Objects)
+                _visor.SetVisorState(obj.DrawObject, on);
+        }
+    }
+}