baseline: OpenMU upstream b5a0961 (fresh source)

src/GameServer/RemoteView/AppearanceSerializer095.cs

@@ -0,0 +1,244 @@
+// <copyright file="AppearanceSerializer095.cs" company="MUnique">
+// Licensed under the MIT License. See LICENSE file in the project root for full license information.
+// </copyright>
+
+namespace MUnique.OpenMU.GameServer.RemoteView;
+
+using System.Collections.Concurrent;
+using System.Runtime.InteropServices;
+using MUnique.OpenMU.DataModel;
+using MUnique.OpenMU.DataModel.Configuration.Items;
+using MUnique.OpenMU.DataModel.Entities;
+using MUnique.OpenMU.Network.PlugIns;
+using MUnique.OpenMU.PlugIns;
+
+/// <summary>
+/// Serializer for the appearance of a player, compatible with the client of version 0.95.
+/// </summary>
+[Guid("99616318-38BC-4C0A-A818-29D821B78DE2")]
+[PlugIn]
+[Display(Name = nameof(PlugInResources.AppearanceSerializer095_Name), Description = nameof(PlugInResources.AppearanceSerializer095_Description), ResourceType = typeof(PlugInResources))]
+[MinimumClient(0, 95, ClientLanguage.Invariant)]
+public class AppearanceSerializer095 : IAppearanceSerializer
+{
+    /// <summary>
+    /// A cache which holds the results of the serializer.
+    /// </summary>
+    private static readonly ConcurrentDictionary<IAppearanceData, byte[]> Cache = new();
+
+    private enum Pets
+    {
+        Angel = 0,
+        Imp = 1,
+        Unicorn = 2,
+        Dinorant = 3,
+    }
+
+    private enum WingIndex
+    {
+        WingsOfElf = 0,
+        WingsOfHeaven = 1,
+        WingsOfSatan = 2,
+        None = 3,
+    }
+
+    /// <inheritdoc/>
+    public int NeededSpace => 11;
+
+    /// <inheritdoc/>
+    public void InvalidateCache(IAppearanceData appearance)
+    {
+        Cache.TryRemove(appearance, out _);
+        appearance.AppearanceChanged -= this.OnAppearanceOfAppearanceChanged;
+    }
+
+    /// <inheritdoc/>
+    public void WriteAppearanceData(Span<byte> target, IAppearanceData appearance, bool useCache)
+    {
+        if (target.Length < this.NeededSpace)
+        {
+            throw new ArgumentException($"Target span too small. Actual size: {target.Length}; Required: {this.NeededSpace}.", nameof(target));
+        }
+
+        if (useCache && Cache.TryGetValue(appearance, out var cached))
+        {
+            cached.CopyTo(target);
+        }
+        else
+        {
+            this.WritePreviewCharSet(target, appearance);
+            if (useCache)
+            {
+                var cacheEntry = target.Slice(0, this.NeededSpace).ToArray();
+                if (Cache.TryAdd(appearance, cacheEntry))
+                {
+                    appearance.AppearanceChanged += this.OnAppearanceOfAppearanceChanged;
+                }
+            }
+        }
+    }
+
+    private void OnAppearanceOfAppearanceChanged(object? sender, EventArgs args) => this.InvalidateCache(sender as IAppearanceData ?? throw new ArgumentException($"sender must be of type {nameof(IAppearanceData)}"));
+
+    /// <summary>
+    /// Writes the preview character set.
+    /// </summary>
+    /// <param name="target">The target.</param>
+    /// <param name="appearanceData">The appearance data.</param>
+    private void WritePreviewCharSet(Span<byte> target, IAppearanceData appearanceData)
+    {
+        ItemAppearance?[] itemArray = new ItemAppearance[InventoryConstants.EquippableSlotsCount];
+        for (byte i = 0; i < itemArray.Length; i++)
+        {
+            itemArray[i] = appearanceData.EquippedItems.FirstOrDefault(item => item.ItemSlot == i && item.Definition?.Number < 16);
+        }
+
+        if (appearanceData.CharacterClass is not null)
+        {
+            target[0] = (byte)(appearanceData.CharacterClass.Number << 3);
+            /*  00 Dark Wizard
+                10 Soul Master
+                20 Dark Knight
+                30 Blade Knight
+                40 Elf
+                50 Muse Elf
+                60 Magic Gladiator*/
+        }
+
+        target[0] |= (byte)appearanceData.Pose;
+        this.SetHand(target, itemArray[InventoryConstants.LeftHandSlot], 1);
+
+        this.SetHand(target, itemArray[InventoryConstants.RightHandSlot], 2);
+
+        this.SetArmorPiece(target, itemArray[InventoryConstants.HelmSlot], 3, true, 0x80);
+
+        this.SetArmorPiece(target, itemArray[InventoryConstants.ArmorSlot], 3, false, 0x40);
+
+        this.SetArmorPiece(target, itemArray[InventoryConstants.PantsSlot], 4, true, 0x20);
+
+        this.SetArmorPiece(target, itemArray[InventoryConstants.GlovesSlot], 4, false, 0x10);
+
+        this.SetArmorPiece(target, itemArray[InventoryConstants.BootsSlot], 5, true, 0x08);
+
+        target[5] |= (byte)((itemArray[InventoryConstants.WingsSlot]?.Definition?.Number & 0x03) << 2 ?? 0b1100);
+        this.SetPet(target, itemArray[InventoryConstants.PetSlot]);
+
+        // index9: upper 5 bits are the equipped flags of SetArmorPiece
+        this.SetItemLevels(target, itemArray);
+    }
+
+    private void SetPet(Span<byte> preview, ItemAppearance? item)
+    {
+        var pet = (Pets?)item?.Definition?.Number;
+        switch (pet)
+        {
+            case Pets.Angel:
+            case Pets.Imp:
+            case Pets.Unicorn:
+                preview[5] |= (byte)pet;
+                break;
+            case Pets.Dinorant:
+                preview[5] |= 0b11;
+                preview[9] |= 0b100;
+                break;
+            default:
+                preview[5] |= 0b11;
+                break;
+        }
+    }
+
+    private void SetHand(Span<byte> preview, ItemAppearance? item, int index)
+    {
+        if (item?.Definition is null)
+        {
+            preview[index] = 0xFF;
+        }
+        else
+        {
+            preview[index] = (byte)item.Definition.Number;
+            preview[index] |= (byte)(item.Definition.Group << 5);
+        }
+    }
+
+    private byte GetOrMaskForHighNibble(int value)
+    {
+        return (byte)((value << 4) & 0xF0);
+    }
+
+    private byte GetOrMaskForLowNibble(int value)
+    {
+        return (byte)(value & 0x0F);
+    }
+
+    private void SetArmorPiece(Span<byte> preview, ItemAppearance? item, int firstIndex, bool firstIndexHigh, byte secondIndexMask)
+    {
+        if (item?.Definition is null)
+        {
+            this.SetEmptyArmor(preview, firstIndex, firstIndexHigh, secondIndexMask);
+        }
+        else
+        {
+            // item id
+            this.SetArmorItemIndex(preview, item, firstIndex, firstIndexHigh, secondIndexMask);
+
+            // exc bit
+            if (this.IsExcellent(item))
+            {
+                preview[10] |= secondIndexMask;
+            }
+        }
+    }
+
+    private void SetEmptyArmor(Span<byte> preview, int firstIndex, bool firstIndexHigh, byte secondIndexMask)
+    {
+        // if the item is not equipped every index bit is set to 1
+        preview[firstIndex] |= firstIndexHigh ? this.GetOrMaskForHighNibble(0x0F) : this.GetOrMaskForLowNibble(0x0F);
+        preview[9] |= secondIndexMask;
+    }
+
+    private void SetArmorItemIndex(Span<byte> preview, ItemAppearance item, int firstIndex, bool firstIndexHigh, byte secondIndexMask)
+    {
+        preview[firstIndex] |= firstIndexHigh ? this.GetOrMaskForHighNibble(item.Definition!.Number) : this.GetOrMaskForLowNibble(item.Definition!.Number);
+        byte multi = (byte)(item.Definition.Number / 16);
+        if (multi > 0)
+        {
+            byte bit1 = (byte)(multi % 2);
+            if (bit1 == 1)
+            {
+                preview[9] |= secondIndexMask;
+            }
+        }
+    }
+
+    private bool IsExcellent(ItemAppearance item)
+    {
+        return item.VisibleOptions.Contains(ItemOptionTypes.Excellent);
+    }
+
+    private void SetItemLevels(Span<byte> preview, ItemAppearance?[] itemArray)
+    {
+        int levelIndex = 0;
+        for (int i = 0; i < 7; i++)
+        {
+            if (itemArray[i] is not null)
+            {
+                levelIndex |= itemArray[i]!.GetGlowLevel() << (i * 3);
+            }
+        }
+
+        preview[6] = (byte)((levelIndex >> 16) & 255);
+        preview[7] = (byte)((levelIndex >> 8) & 255);
+        preview[8] = (byte)(levelIndex & 255);
+    }
+
+    private void AddWing(Span<byte> preview, ItemAppearance? wing)
+    {
+        if (wing?.Definition is null)
+        {
+            preview[5] |= 0x0C;
+            return;
+        }
+
+        preview[5] |= (byte)((wing?.Definition?.Number & 0x03) << 2 ?? 0b1100);
+    }
+}