Merge remote-tracking branch 'upstream/main'

Author: d87

.github/workflows/release.yml

@@ -37,7 +37,7 @@ jobs:
       - name: Archive
         run: Compress-Archive -Path CustomizePlus/bin/Release/* -DestinationPath CustomizePlus.zip
       - name: Upload a Build Artifact
-        uses: actions/upload-artifact@v2.2.1
+        uses: actions/upload-artifact@v4
         with:
           path: |
             ./CustomizePlus/bin/Release/*

.github/workflows/test_release.yml

@@ -37,7 +37,7 @@ jobs:
       - name: Archive
         run: Compress-Archive -Path CustomizePlus/bin/Release/* -DestinationPath CustomizePlus.zip
       - name: Upload a Build Artifact
-        uses: actions/upload-artifact@v2.2.1
+        uses: actions/upload-artifact@v4
         with:
           path: |
             ./CustomizePlus/bin/Release/*

CustomizePlus.GameData/CustomizePlus.GameData.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>net8.0-windows</TargetFramework>

CustomizePlus.GameData/Data/ReverseNameDicts.cs

@@ -0,0 +1,65 @@
+using CustomizePlus.GameData.ReverseSearchDictionaries;
+using Dalamud.Game.ClientState.Objects.Enums;
+using OtterGui.Services;
+using Penumbra.GameData.DataContainers;
+using Penumbra.GameData.Structs;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CustomizePlus.GameData.Data;
+
+/// <summary> A collection service for all the name dictionaries required for reverse name search. </summary>
+/// note: this is mvp for profile upgrading purposes, not intended to be used for anything else.
+public sealed class ReverseNameDicts(
+    ReverseSearchDictMount _mounts,
+    ReverseSearchDictCompanion _companions,
+    ReverseSearchDictBNpc _bNpcs,
+    ReverseSearchDictENpc _eNpcs)
+    : IAsyncService
+{
+    /// <summary> Valid Mount ids by name in title case. </summary>
+    public readonly ReverseSearchDictMount Mounts = _mounts;
+
+    /// <summary> Valid Companion ids by name in title case. </summary>
+    public readonly ReverseSearchDictCompanion Companions = _companions;
+
+    /// <summary> Valid BNPC ids by name in title case. </summary>
+    public readonly ReverseSearchDictBNpc BNpcs = _bNpcs;
+
+    /// <summary> Valid ENPC ids by name in title case. </summary>
+    public readonly ReverseSearchDictENpc ENpcs = _eNpcs;
+   
+    /// <summary> Finished when all name dictionaries are finished. </summary>
+    public Task Awaiter { get; } =
+        Task.WhenAll(_mounts.Awaiter, _companions.Awaiter, _bNpcs.Awaiter, _eNpcs.Awaiter);
+
+    /// <inheritdoc/>
+    public bool Finished
+        => Awaiter.IsCompletedSuccessfully;
+
+    /// <summary> Convert a given name for a certain ObjectKind to an ID. </summary>
+    /// <returns> default or a valid id. </returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public uint ToID(ObjectKind kind, string name)
+        => TryGetID(kind, name, out var ret) ? ret : default;
+
+    /// <summary> Convert a given ID for a certain ObjectKind to a name. </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public bool TryGetID(ObjectKind kind, string name, [NotNullWhen(true)] out uint npcId)
+    {
+        npcId = default;
+        return kind switch
+        {
+            ObjectKind.MountType => Mounts.TryGetValue(name, out npcId),
+            ObjectKind.Companion => Companions.TryGetValue(name, out npcId),
+            ObjectKind.BattleNpc => BNpcs.TryGetValue(name, out npcId),
+             ObjectKind.EventNpc => ENpcs.TryGetValue(name, out npcId),
+            _ => false,
+        };
+    }
+}

CustomizePlus.GameData/Extensions/ActorIdentifierExtensions.cs

@@ -28,6 +28,40 @@ public static string ToNameWithoutOwnerName(this ActorIdentifier identifier)
         return PenumbraExtensions.Manager.Data.ToName(identifier.Kind, identifier.DataId);
     }
 
+    /// <summary>
+    /// Matches() method but ignoring ownership for owned objects or if one of identifiers is NPC while the other one is Owned.
+    /// </summary>
+    public static bool MatchesIgnoringOwnership(this ActorIdentifier identifier, ActorIdentifier other)
+    {
+        //carbuncles and other battle minions
+        if ((identifier.Type == IdentifierType.Npc && other.Type == IdentifierType.Owned) ||
+            (identifier.Type == IdentifierType.Owned && other.Type == IdentifierType.Npc))
+            return PenumbraExtensions.Manager.DataIdEquals(identifier, other);
+
+        if (identifier.Type != other.Type)
+            return false;
+
+        return identifier.Type switch
+        {
+            IdentifierType.Owned => PenumbraExtensions.Manager.DataIdEquals(identifier, other),
+            _ => identifier.Matches(other)
+        };
+    }
+
+    /// <summary>
+    /// Check if owned actor is owned by local player. Will return false if Type is not Owned.
+    /// </summary>
+    public static bool IsOwnedByLocalPlayer(this ActorIdentifier identifier)
+    {
+        if (identifier.Type != IdentifierType.Owned)
+            return false;
+
+        if (PenumbraExtensions.Manager == null)
+            return false;
+
+        return identifier.PlayerName == PenumbraExtensions.Manager.GetCurrentPlayer().PlayerName;
+    }
+
     /// <summary>
     /// Wrapper around Incognito which returns non-incognito name in debug builds
     /// </summary>
@@ -56,6 +90,23 @@ public static string IncognitoDebug(this ActorIdentifier identifier)
         }
     }
 
+    public static string TypeToString(this ActorIdentifier identifier)
+    {
+        return identifier.Type switch
+        {
+            IdentifierType.Player => $" ({PenumbraExtensions.Manager?.Data.ToWorldName(identifier.HomeWorld) ?? "Unknown"})",
+            IdentifierType.Retainer => $"{identifier.Retainer switch
+            {
+                ActorIdentifier.RetainerType.Bell => " (Bell)",
+                ActorIdentifier.RetainerType.Mannequin => " (Mannequin)",
+                _ => " (Retainer)",
+            }}",
+            IdentifierType.Owned => " (Companion/Mount)",
+            IdentifierType.Npc => " (NPC)",
+            _ => "",
+        };
+    }
+
     /// <summary>
     /// For now used to determine if root scaling should be allowed or not
     /// </summary>

CustomizePlus.GameData/ReverseSearchDictionaries/Bases/ReverseNameDictionary.cs

@@ -0,0 +1,83 @@
+using Dalamud.Plugin.Services;
+using Dalamud.Plugin;
+using FFXIVClientStructs.FFXIV.Common.Lua;
+using OtterGui.Log;
+using Penumbra.GameData.Data;
+using Penumbra.GameData.DataContainers.Bases;
+using Penumbra.GameData.Structs;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CustomizePlus.GameData.ReverseSearchDictionaries.Bases;
+
+/// <summary> A base class for dictionaries from NPC names to their IDs. </summary>
+/// <param name="pluginInterface"> The plugin interface. </param>
+/// <param name="log"> A logger. </param>
+/// <param name="gameData"> The data manger to fetch the data from. </param>
+/// <param name="name"> The name of the data share. </param>
+/// <param name="version"> The version of the data share. </param>
+/// <param name="factory"> The factory function to create the data from. </param>
+public abstract class ReverseNameDictionary(
+    IDalamudPluginInterface pluginInterface,
+    Logger log,
+    IDataManager gameData,
+    string name,
+    int version,
+    Func<IReadOnlyDictionary<string, uint>> factory)
+    : DataSharer<IReadOnlyDictionary<string, uint>>(pluginInterface, log, name, gameData.Language, version, factory),
+        IReadOnlyDictionary<string, NpcId>
+{
+    /// <inheritdoc/>
+    public IEnumerator<KeyValuePair<string, NpcId>> GetEnumerator()
+        => Value.Select(kvp => new KeyValuePair<string, NpcId>(kvp.Key, new NpcId(kvp.Value))).GetEnumerator();
+
+    /// <inheritdoc/>
+    IEnumerator IEnumerable.GetEnumerator()
+        => GetEnumerator();
+
+    /// <inheritdoc/>
+    public int Count
+        => Value.Count;
+
+    /// <inheritdoc/>
+    public bool ContainsKey(string key)
+        => Value.ContainsKey(key);
+
+    /// <inheritdoc/>
+    public bool TryGetValue(string key, [NotNullWhen(true)] out NpcId value)
+    {
+        if (!Value.TryGetValue(key, out var uintVal))
+        {
+            value = default;
+            return false;
+        }
+
+        value = new NpcId(uintVal);
+        return true;
+    }
+
+    /// <inheritdoc/>
+    public NpcId this[string key]
+        => new NpcId(Value[key]);
+
+    /// <inheritdoc/>
+    public IEnumerable<string> Keys
+        => Value.Keys;
+
+    /// <inheritdoc/>
+    public IEnumerable<NpcId> Values
+        => Value.Values.Select(k => new NpcId(k));
+
+    /// <inheritdoc/>
+    protected override long ComputeMemory()
+        => DataUtility.DictionaryMemory(16, Count) + Keys.Sum(v => v.Length * 2); //this seems to be only used by diagnostics stuff so I don't particularly care for this to be correct.
+
+    /// <inheritdoc/>
+    protected override int ComputeTotalCount()
+        => Count;
+}

CustomizePlus.GameData/ReverseSearchDictionaries/ReverseSearchDictBNpc.cs

@@ -0,0 +1,33 @@
+using Dalamud.Plugin.Services;
+using Dalamud.Plugin;
+using OtterGui.Log;
+using Penumbra.GameData.Data;
+using System.Collections.Frozen;
+using System.Diagnostics.CodeAnalysis;
+using Lumina.Excel.GeneratedSheets;
+using CustomizePlus.GameData.ReverseSearchDictionaries.Bases;
+
+namespace CustomizePlus.GameData.ReverseSearchDictionaries;
+
+/// <summary> A dictionary that matches names to battle npc ids. </summary>
+public sealed class ReverseSearchDictBNpc(IDalamudPluginInterface pluginInterface, Logger log, IDataManager gameData)
+    : ReverseNameDictionary(pluginInterface, log, gameData, "ReverseSearchBNpcs", 7, () => CreateBNpcData(gameData))
+{
+    /// <summary> Create the data. </summary>
+    private static IReadOnlyDictionary<string, uint> CreateBNpcData(IDataManager gameData)
+    {
+        var sheet = gameData.GetExcelSheet<BNpcName>(gameData.Language)!;
+        var dict = new Dictionary<string, uint>((int)sheet.RowCount);
+        foreach (var n in sheet.Where(n => n.Singular.RawData.Length > 0))
+            dict.TryAdd(DataUtility.ToTitleCaseExtended(n.Singular, n.Article), n.RowId);
+        return dict.ToFrozenDictionary();
+    }
+
+    /// <inheritdoc cref="ReverseNameDictionary.TryGetValue"/>
+    public bool TryGetValue(string key, [NotNullWhen(true)] out uint value)
+        => Value.TryGetValue(key, out value);
+
+    /// <inheritdoc cref="ReverseNameDictionary.this"/>
+    public uint this[string key]
+        => Value[key];
+}

CustomizePlus.GameData/ReverseSearchDictionaries/ReverseSearchDictCompanion.cs

@@ -0,0 +1,33 @@
+using Dalamud.Plugin.Services;
+using Dalamud.Plugin;
+using OtterGui.Log;
+using Penumbra.GameData.Data;
+using System.Collections.Frozen;
+using System.Diagnostics.CodeAnalysis;
+using Lumina.Excel.GeneratedSheets;
+using CustomizePlus.GameData.ReverseSearchDictionaries.Bases;
+
+namespace CustomizePlus.GameData.ReverseSearchDictionaries;
+
+/// <summary> A dictionary that matches companion names to their ids. </summary>
+public sealed class ReverseSearchDictCompanion(IDalamudPluginInterface pluginInterface, Logger log, IDataManager gameData)
+    : ReverseNameDictionary(pluginInterface, log, gameData, "ReverseSearchCompanions", 7, () => CreateCompanionData(gameData))
+{
+    /// <summary> Create the data. </summary>
+    private static IReadOnlyDictionary<string, uint> CreateCompanionData(IDataManager gameData)
+    {
+        var sheet = gameData.GetExcelSheet<Companion>(gameData.Language)!;
+        var dict = new Dictionary<string, uint>((int)sheet.RowCount);
+        foreach (var c in sheet.Where(c => c.Singular.RawData.Length > 0 && c.Order < ushort.MaxValue))
+            dict.TryAdd(DataUtility.ToTitleCaseExtended(c.Singular, c.Article), c.RowId);
+        return dict.ToFrozenDictionary();
+    }
+
+    /// <inheritdoc cref="ReverseNameDictionary.TryGetValue"/>
+    public bool TryGetValue(string key, [NotNullWhen(true)] out uint value)
+        => Value.TryGetValue(key, out value);
+
+    /// <inheritdoc cref="ReverseNameDictionary.this"/>
+    public uint this[string key]
+        => Value[key];
+}

CustomizePlus.GameData/ReverseSearchDictionaries/ReverseSearchDictENpc.cs

@@ -0,0 +1,33 @@
+using Dalamud.Plugin.Services;
+using Dalamud.Plugin;
+using OtterGui.Log;
+using Penumbra.GameData.Data;
+using System.Collections.Frozen;
+using System.Diagnostics.CodeAnalysis;
+using Lumina.Excel.GeneratedSheets;
+using CustomizePlus.GameData.ReverseSearchDictionaries.Bases;
+
+namespace CustomizePlus.GameData.ReverseSearchDictionaries;
+
+/// <summary> A dictionary that matches names to event npc ids. </summary>
+public sealed class ReverseSearchDictENpc(IDalamudPluginInterface pluginInterface, Logger log, IDataManager gameData)
+    : ReverseNameDictionary(pluginInterface, log, gameData, "ReverseSearchENpcs", 7, () => CreateENpcData(gameData))
+{
+    /// <summary> Create the data. </summary>
+    private static IReadOnlyDictionary<string, uint> CreateENpcData(IDataManager gameData)
+    {
+        var sheet = gameData.GetExcelSheet<ENpcResident>(gameData.Language)!;
+        var dict = new Dictionary<string, uint>((int)sheet.RowCount);
+        foreach (var n in sheet.Where(e => e.Singular.RawData.Length > 0))
+            dict.TryAdd(DataUtility.ToTitleCaseExtended(n.Singular, n.Article), n.RowId);
+        return dict.ToFrozenDictionary();
+    }
+
+    /// <inheritdoc cref="ReverseNameDictionary.TryGetValue"/>
+    public bool TryGetValue(string key, [NotNullWhen(true)] out uint value)
+        => Value.TryGetValue(key, out value);
+
+    /// <inheritdoc cref="ReverseNameDictionary.this"/>
+    public uint this[string key]
+        => Value[key];
+}