dev push

Co-authored-by: azyges <aaaaaa@aaa.aaa>
Co-authored-by: cake <admin@cakeandbanana.nl>
Reviewed-on: #134
Reviewed-by: defnotken <defnotken@noreply.git.lightless-sync.org>

LightlessSync/LightlessConfiguration/Configurations/ChatConfig.cs

@@ -11,6 +11,7 @@ public sealed class ChatConfig : ILightlessConfiguration
     public bool ShowRulesOverlayOnOpen { get; set; } = true;
     public bool ShowMessageTimestamps { get; set; } = true;
     public bool ShowNotesInSyncshellChat { get; set; } = true;
+    public bool EnableAnimatedEmotes { get; set; } = true;
     public float ChatWindowOpacity { get; set; } = .97f;
     public bool FadeWhenUnfocused { get; set; } = false;
     public float UnfocusedWindowOpacity { get; set; } = 0.6f;

LightlessSync/LightlessSync.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Authors></Authors>
     <Company></Company>
-    <Version>2.0.2.69</Version>
+    <Version>2.0.2.74</Version>
     <Description></Description>
     <Copyright></Copyright>
     <PackageProjectUrl>https://github.com/Light-Public-Syncshells/LightlessClient</PackageProjectUrl>

LightlessSync/PlayerData/Factories/PlayerDataFactory.cs

@@ -1,4 +1,5 @@
-using FFXIVClientStructs.FFXIV.Client.Game.Character;
+using Dalamud.Utility;
+using FFXIVClientStructs.FFXIV.Client.Game.Character;
 using LightlessSync.API.Data.Enum;
 using LightlessSync.FileCache;
 using LightlessSync.Interop.Ipc;
@@ -11,6 +12,8 @@ using LightlessSync.Services.Mediator;
 using Microsoft.Extensions.Logging;
 using System.Collections.Concurrent;
 using System.Diagnostics;
+using System.Runtime.ExceptionServices;
+using System.Runtime.InteropServices;
 
 namespace LightlessSync.PlayerData.Factories;
 
@@ -123,22 +126,38 @@ public class PlayerDataFactory
     {
         if (playerPointer == IntPtr.Zero)
             return true;
+
+        if (!IsPointerValid(playerPointer))
+            return true;
+
+        var character = (Character*)playerPointer;
+        if (character == null)
+            return true;
+
+        var gameObject = &character->GameObject;
+        if (gameObject == null)
+            return true;
+
+        if (!IsPointerValid((IntPtr)gameObject))
+            return true;
+
+        return gameObject->DrawObject == null;
+    }
+
+    private static bool IsPointerValid(IntPtr ptr)
+    {
+        if (ptr == IntPtr.Zero)
+            return false;
+
         try
         {
-            var character = (Character*)playerPointer;
+            _ = Marshal.ReadByte(ptr);
-            if (character == null)
-                return true;
-
-            var gameObject = &character->GameObject;
-            if (gameObject == null)
-                return true;
-
-            return gameObject->DrawObject == null;
-        }
-        catch (AccessViolationException)
-        {
             return true;
         }
+        catch
+        {
+            return false;
+        }
     }
 
     private static bool IsCacheFresh(CacheEntry entry)
@@ -537,13 +556,31 @@ public class PlayerDataFactory
 
             var hash = g.Key;
 
+            var resolvedPath = g.Select(f => f.ResolvedPath).Distinct(StringComparer.OrdinalIgnoreCase);
+            var papPathSummary = string.Join(", ", resolvedPath);
+            if (papPathSummary.IsNullOrEmpty())
+                papPathSummary = "<unknown pap path>";
+
             Dictionary<string, List<ushort>>? papIndices = null;
 
             await _papParseLimiter.WaitAsync(ct).ConfigureAwait(false);
             try
             {
-                papIndices = await Task.Run(() => _modelAnalyzer.GetBoneIndicesFromPap(hash), ct)
+                try
-                    .ConfigureAwait(false);
+                {
+                    papIndices = await Task.Run(() => _modelAnalyzer.GetBoneIndicesFromPap(hash, persistToConfig: false), ct)
+                        .ConfigureAwait(false);
+                }
+                catch (SEHException ex)
+                {
+                    _logger.LogError(ex, "SEH exception while parsing PAP file (hash={hash}, path={path}). Error code: 0x{code:X}. Skipping this animation.", hash, papPathSummary, ex.ErrorCode);
+                    continue;
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Unexpected error parsing PAP file (hash={hash}, path={path}). Skipping this animation.", hash, papPathSummary);
+                    continue;
+                }
             }
             finally
             {
@@ -553,43 +590,75 @@ public class PlayerDataFactory
             if (papIndices == null || papIndices.Count == 0)
                 continue;
 
-            if (papIndices.All(k => k.Value.DefaultIfEmpty().Max() <= 105))
+            bool hasValidIndices = false;
+            try
+            {
+                hasValidIndices = papIndices.All(k => k.Value != null && k.Value.DefaultIfEmpty().Max() <= 105);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Error validating bone indices for PAP (hash={hash}, path={path}). Skipping.", hash, papPathSummary);
+                continue;
+            }
+
+            if (hasValidIndices)
                 continue;
 
             if (_logger.IsEnabled(LogLevel.Debug))
             {
-                var papBuckets = papIndices
+                try
-                    .Select(kvp => new
+                {
-                    {
+                    var papBuckets = papIndices
-                        Raw = kvp.Key,
+                        .Where(kvp => kvp.Value is { Count: > 0 })
-                        Key = XivDataAnalyzer.CanonicalizeSkeletonKey(kvp.Key),
+                        .Select(kvp => new
-                        Indices = kvp.Value
+                        {
-                    })
+                            Raw = kvp.Key,
-                    .Where(x => x.Indices is { Count: > 0 })
+                            Key = XivDataAnalyzer.CanonicalizeSkeletonKey(kvp.Key),
-                    .GroupBy(x => string.IsNullOrEmpty(x.Key) ? x.Raw : x.Key!, StringComparer.OrdinalIgnoreCase)
+                            Indices = kvp.Value
-                    .Select(grp =>
+                        })
-                    {
+                        .Where(x => x.Indices is { Count: > 0 })
-                        var all = grp.SelectMany(v => v.Indices).ToList();
+                        .GroupBy(x => string.IsNullOrEmpty(x.Key) ? x.Raw : x.Key!, StringComparer.OrdinalIgnoreCase)
-                        var min = all.Count > 0 ? all.Min() : 0;
+                        .Select(grp =>
-                        var max = all.Count > 0 ? all.Max() : 0;
+                        {
-                        var raws = string.Join(',', grp.Select(v => v.Raw).Distinct(StringComparer.OrdinalIgnoreCase));
+                            var all = grp.SelectMany(v => v.Indices).ToList();
-                        return $"{grp.Key}(min={min},max={max},raw=[{raws}])";
+                            var min = all.Count > 0 ? all.Min() : 0;
-                    })
+                            var max = all.Count > 0 ? all.Max() : 0;
-                    .ToList();
+                            var raws = string.Join(',', grp.Select(v => v.Raw).Distinct(StringComparer.OrdinalIgnoreCase));
+                            return $"{grp.Key}(min={min},max={max},raw=[{raws}])";
+                        })
+                        .ToList();
 
-                _logger.LogDebug("SEND pap buckets for hash={hash}: {b}",
+                    _logger.LogDebug("SEND pap buckets for hash={hash}: {b}",
-                    hash,
+                        hash,
-                    string.Join(" | ", papBuckets));
+                        string.Join(" | ", papBuckets));
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogDebug(ex, "Error logging PAP bucket details for hash={hash}", hash);
+                }
             }
 
-            if (XivDataAnalyzer.IsPapCompatible(localBoneSets, papIndices, mode, allowBasedShift, allownNightIndex, out var reason))
+            bool isCompatible = false;
+            string reason = string.Empty;
+            try
+            {
+                isCompatible = XivDataAnalyzer.IsPapCompatible(localBoneSets, papIndices, mode, allowBasedShift, allownNightIndex, out reason);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Error checking PAP compatibility for hash={hash}, path={path}. Treating as incompatible.", hash, papPathSummary);
+                reason = $"Exception during compatibility check: {ex.Message}";
+                isCompatible = false;
+            }
+
+            if (isCompatible)
                 continue;
 
             noValidationFailed++;
 
             _logger.LogWarning(
-                "Animation PAP hash {hash} is not compatible with local skeletons; dropping all mappings for this hash. Reason: {reason}",
+                "Animation PAP is not compatible with local skeletons; dropping mappings for {papPath}. Reason: {reason}",
-                hash,
+                papPathSummary,
                 reason);
 
             var removedGamePaths = fragment.FileReplacements
@@ -669,7 +738,7 @@ public class PlayerDataFactory
                         list.Add(forwardPaths[i].ToLowerInvariant());
                     else
                     {
-                        resolvedPaths[filePath] = [forwardPaths[i].ToLowerInvariant()];
+                        resolvedPaths[filePath] = [forwardPathsLower[i]];
                     }
                 }
 

LightlessSync/PlayerData/Handlers/GameObjectHandler.cs

@@ -78,7 +78,6 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
             if (msg.Address == Address)
             {
                 _haltProcessing = false;
-                Refresh();
             }
         });
 
@@ -114,16 +113,16 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
     public async Task ActOnFrameworkAfterEnsureNoDrawAsync(Action<Dalamud.Game.ClientState.Objects.Types.ICharacter> act, CancellationToken token)
     {
         while (await _dalamudUtil.RunOnFrameworkThread(() =>
-               {
+        {
-                   EnsureLatestObjectState();
+            EnsureLatestObjectState();
-                   if (CurrentDrawCondition != DrawCondition.None) return true;
+            if (CurrentDrawCondition != DrawCondition.None) return true;
-                   var gameObj = _dalamudUtil.CreateGameObject(Address);
+            var gameObj = _dalamudUtil.CreateGameObject(Address);
-                   if (gameObj is Dalamud.Game.ClientState.Objects.Types.ICharacter chara)
+            if (gameObj is Dalamud.Game.ClientState.Objects.Types.ICharacter chara)
-                   {
+            {
-                       act.Invoke(chara);
+                act.Invoke(chara);
-                   }
+            }
-                   return false;
+            return false;
-               }).ConfigureAwait(false))
+        }).ConfigureAwait(false))
         {
             await Task.Delay(250, token).ConfigureAwait(false);
         }
@@ -170,19 +169,13 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
         return $"{owned}/{ObjectKind}:{Name} ({Address:X},{DrawObjectAddress:X})";
     }
 
-    protected override void Dispose(bool disposing)
-    {
-        base.Dispose(disposing);
-
-        Mediator.Publish(new GameObjectHandlerDestroyedMessage(this, _isOwnedObject));
-    }
-
     private void CheckAndUpdateObject() => CheckAndUpdateObject(allowPublish: true);
 
-    private unsafe void CheckAndUpdateObject(bool allowPublish = true)
+    private unsafe void CheckAndUpdateObject(bool allowPublish)
     {
         var prevAddr = Address;
         var prevDrawObj = DrawObjectAddress;
+        string? nameString = null;
 
         Address = _getAddress();
 
@@ -193,10 +186,9 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
             EntityId = gameObject->EntityId;
 
             var chara = (Character*)Address;
-            var newName = chara->GameObject.NameString;
+            nameString = chara->GameObject.NameString;
-
+            if (!string.IsNullOrEmpty(nameString) && !string.Equals(nameString, Name, StringComparison.Ordinal))
-            if (!string.IsNullOrEmpty(newName) && !string.Equals(newName, Name, StringComparison.Ordinal))
+                Name = nameString;
-                Name = newName;
         }
         else
         {
@@ -214,16 +206,18 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
         if (Address != IntPtr.Zero && DrawObjectAddress != IntPtr.Zero)
         {
             var chara = (Character*)Address;
-            var name = chara->GameObject.NameString;
+            var drawObj = (DrawObject*)DrawObjectAddress;
-            bool nameChange = !string.Equals(name, Name, StringComparison.Ordinal);
+            var objType = drawObj->Object.GetObjectType();
-            if (nameChange)
+            var isHuman = objType == ObjectType.CharacterBase
-            {
+                          && ((CharacterBase*)drawObj)->GetModelType() == CharacterBase.ModelType.Human;
-                Name = name;
+
-            }
+            nameString ??= ((Character*)Address)->GameObject.NameString;
+            var nameChange = !string.Equals(nameString, Name, StringComparison.Ordinal);
+            if (nameChange) Name = nameString;
+
             bool equipDiff = false;
 
-            if (((DrawObject*)DrawObjectAddress)->Object.GetObjectType() == ObjectType.CharacterBase
+            if (isHuman)
-                && ((CharacterBase*)DrawObjectAddress)->GetModelType() == CharacterBase.ModelType.Human)
             {
                 var classJob = chara->CharacterData.ClassJob;
                 if (classJob != _classJob)
@@ -233,7 +227,7 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
                     Mediator.Publish(new ClassJobChangedMessage(this));
                 }
 
-                equipDiff = CompareAndUpdateEquipByteData((byte*)&((Human*)DrawObjectAddress)->Head);
+                equipDiff = CompareAndUpdateEquipByteData((byte*)&((Human*)drawObj)->Head);
 
                 ref var mh = ref chara->DrawData.Weapon(WeaponSlot.MainHand);
                 ref var oh = ref chara->DrawData.Weapon(WeaponSlot.OffHand);
@@ -258,12 +252,11 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
 
             bool customizeDiff = false;
 
-            if (((DrawObject*)DrawObjectAddress)->Object.GetObjectType() == ObjectType.CharacterBase
+            if (isHuman)
-                && ((CharacterBase*)DrawObjectAddress)->GetModelType() == CharacterBase.ModelType.Human)
             {
-                var gender = ((Human*)DrawObjectAddress)->Customize.Sex;
+                var gender = ((Human*)drawObj)->Customize.Sex;
-                var raceId = ((Human*)DrawObjectAddress)->Customize.Race;
+                var raceId = ((Human*)drawObj)->Customize.Race;
-                var tribeId = ((Human*)DrawObjectAddress)->Customize.Tribe;
+                var tribeId = ((Human*)drawObj)->Customize.Tribe;
 
                 if (_isOwnedObject && ObjectKind == ObjectKind.Player
                     && (gender != Gender || raceId != RaceId || tribeId != TribeId))
@@ -274,7 +267,7 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
                     TribeId = tribeId;
                 }
 
-                customizeDiff = CompareAndUpdateCustomizeData(((Human*)DrawObjectAddress)->Customize.Data);
+                customizeDiff = CompareAndUpdateCustomizeData(((Human*)drawObj)->Customize.Data);
                 if (customizeDiff)
                     Logger.LogTrace("Checking [{this}] customize data as human from draw obj, result: {diff}", this, customizeDiff);
             }

LightlessSync/Services/Chat/ChatEmoteService.cs

@@ -1,29 +1,41 @@
 using Dalamud.Interface.Textures.TextureWraps;
+using LightlessSync.LightlessConfiguration;
 using LightlessSync.UI;
 using Microsoft.Extensions.Logging;
 using System.Collections.Concurrent;
+using System.Diagnostics;
 using System.Text.Json;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Formats.Gif;
+using SixLabors.ImageSharp.Formats.Webp;
+using SixLabors.ImageSharp.Metadata;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
 
 namespace LightlessSync.Services.Chat;
 
 public sealed class ChatEmoteService : IDisposable
 {
     private const string GlobalEmoteSetUrl = "https://7tv.io/v3/emote-sets/global";
+    private const int DefaultFrameDelayMs = 100;
+    private const int MinFrameDelayMs = 20;
 
     private readonly ILogger<ChatEmoteService> _logger;
     private readonly HttpClient _httpClient;
     private readonly UiSharedService _uiSharedService;
+    private readonly ChatConfigService _chatConfigService;
     private readonly ConcurrentDictionary<string, EmoteEntry> _emotes = new(StringComparer.Ordinal);
     private readonly SemaphoreSlim _downloadGate = new(3, 3);
 
     private readonly object _loadLock = new();
     private Task? _loadTask;
 
-    public ChatEmoteService(ILogger<ChatEmoteService> logger, HttpClient httpClient, UiSharedService uiSharedService)
+    public ChatEmoteService(ILogger<ChatEmoteService> logger, HttpClient httpClient, UiSharedService uiSharedService, ChatConfigService chatConfigService)
     {
         _logger = logger;
         _httpClient = httpClient;
         _uiSharedService = uiSharedService;
+        _chatConfigService = chatConfigService;
     }
 
     public void EnsureGlobalEmotesLoaded()
@@ -62,13 +74,17 @@ public sealed class ChatEmoteService : IDisposable
             return false;
         }
 
-        if (entry.Texture is not null)
+        var allowAnimation = _chatConfigService.Current.EnableAnimatedEmotes;
+        if (entry.TryGetTexture(allowAnimation, out texture))
         {
-            texture = entry.Texture;
+            if (allowAnimation && entry.NeedsAnimationLoad && !entry.HasAttemptedAnimation)
+            {
+                entry.EnsureLoading(allowAnimation, QueueEmoteDownload, allowWhenStaticLoaded: true);
+            }
             return true;
         }
 
-        entry.EnsureLoading(QueueEmoteDownload);
+        entry.EnsureLoading(allowAnimation, QueueEmoteDownload);
         return true;
     }
 
@@ -76,7 +92,7 @@ public sealed class ChatEmoteService : IDisposable
     {
         foreach (var entry in _emotes.Values)
         {
-            entry.Texture?.Dispose();
+            entry.Dispose();
         }
 
         _downloadGate.Dispose();
@@ -108,13 +124,13 @@ public sealed class ChatEmoteService : IDisposable
                     continue;
                 }
 
-                var url = TryBuildEmoteUrl(emoteElement);
+                var source = TryBuildEmoteSource(emoteElement);
-                if (string.IsNullOrWhiteSpace(url))
+                if (source is null || (!source.Value.HasStatic && !source.Value.HasAnimation))
                 {
                     continue;
                 }
 
-                _emotes.TryAdd(name, new EmoteEntry(url));
+                _emotes.TryAdd(name, new EmoteEntry(name, source.Value));
             }
         }
         catch (Exception ex)
@@ -123,7 +139,7 @@ public sealed class ChatEmoteService : IDisposable
         }
     }
 
-    private static string? TryBuildEmoteUrl(JsonElement emoteElement)
+    private static EmoteSource? TryBuildEmoteSource(JsonElement emoteElement)
     {
         if (!emoteElement.TryGetProperty("data", out var dataElement))
         {
@@ -156,29 +172,38 @@ public sealed class ChatEmoteService : IDisposable
             return null;
         }
 
-        var fileName = PickBestStaticFile(filesElement);
+        var files = ReadEmoteFiles(filesElement);
-        if (string.IsNullOrWhiteSpace(fileName))
+        if (files.Count == 0)
         {
             return null;
         }
 
-        return baseUrl.TrimEnd('/') + "/" + fileName;
+        var animatedFile = PickBestAnimatedFile(files);
+        var animatedUrl = animatedFile is null ? null : BuildEmoteUrl(baseUrl, animatedFile.Value.Name);
+
+        var staticName = animatedFile?.StaticName;
+        if (string.IsNullOrWhiteSpace(staticName))
+        {
+            staticName = PickBestStaticFileName(files);
+        }
+
+        var staticUrl = string.IsNullOrWhiteSpace(staticName) ? null : BuildEmoteUrl(baseUrl, staticName);
+        if (string.IsNullOrWhiteSpace(animatedUrl) && string.IsNullOrWhiteSpace(staticUrl))
+        {
+            return null;
+        }
+
+        return new EmoteSource(staticUrl, animatedUrl);
     }
 
-    private static string? PickBestStaticFile(JsonElement filesElement)
+    private static string BuildEmoteUrl(string baseUrl, string fileName)
-    {
+        => baseUrl.TrimEnd('/') + "/" + fileName;
-        string? png1x = null;
-        string? webp1x = null;
-        string? pngFallback = null;
-        string? webpFallback = null;
 
+    private static List<EmoteFile> ReadEmoteFiles(JsonElement filesElement)
+    {
+        var files = new List<EmoteFile>();
         foreach (var file in filesElement.EnumerateArray())
         {
-            if (file.TryGetProperty("static", out var staticElement) && staticElement.ValueKind == JsonValueKind.False)
-            {
-                continue;
-            }
-
             if (!file.TryGetProperty("name", out var nameElement))
             {
                 continue;
@@ -190,6 +215,88 @@ public sealed class ChatEmoteService : IDisposable
                 continue;
             }
 
+            string? staticName = null;
+            if (file.TryGetProperty("static_name", out var staticNameElement) && staticNameElement.ValueKind == JsonValueKind.String)
+            {
+                staticName = staticNameElement.GetString();
+            }
+
+            var frameCount = 1;
+            if (file.TryGetProperty("frame_count", out var frameCountElement) && frameCountElement.ValueKind == JsonValueKind.Number)
+            {
+                frameCountElement.TryGetInt32(out frameCount);
+                frameCount = Math.Max(frameCount, 1);
+            }
+
+            string? format = null;
+            if (file.TryGetProperty("format", out var formatElement) && formatElement.ValueKind == JsonValueKind.String)
+            {
+                format = formatElement.GetString();
+            }
+
+            files.Add(new EmoteFile(name, staticName, frameCount, format));
+        }
+
+        return files;
+    }
+
+    private static EmoteFile? PickBestAnimatedFile(IReadOnlyList<EmoteFile> files)
+    {
+        EmoteFile? webp1x = null;
+        EmoteFile? gif1x = null;
+        EmoteFile? webpFallback = null;
+        EmoteFile? gifFallback = null;
+
+        foreach (var file in files)
+        {
+            if (file.FrameCount <= 1 || !IsAnimatedFormatSupported(file))
+            {
+                continue;
+            }
+
+            if (file.Name.Equals("1x.webp", StringComparison.OrdinalIgnoreCase))
+            {
+                webp1x = file;
+            }
+            else if (file.Name.Equals("1x.gif", StringComparison.OrdinalIgnoreCase))
+            {
+                gif1x = file;
+            }
+            else if (file.Name.EndsWith(".webp", StringComparison.OrdinalIgnoreCase) && webpFallback is null)
+            {
+                webpFallback = file;
+            }
+            else if (file.Name.EndsWith(".gif", StringComparison.OrdinalIgnoreCase) && gifFallback is null)
+            {
+                gifFallback = file;
+            }
+        }
+
+        return webp1x ?? gif1x ?? webpFallback ?? gifFallback;
+    }
+
+    private static string? PickBestStaticFileName(IReadOnlyList<EmoteFile> files)
+    {
+        string? png1x = null;
+        string? webp1x = null;
+        string? gif1x = null;
+        string? pngFallback = null;
+        string? webpFallback = null;
+        string? gifFallback = null;
+
+        foreach (var file in files)
+        {
+            if (file.FrameCount > 1)
+            {
+                continue;
+            }
+
+            var name = file.StaticName ?? file.Name;
+            if (string.IsNullOrWhiteSpace(name))
+            {
+                continue;
+            }
+
             if (name.Equals("1x.png", StringComparison.OrdinalIgnoreCase))
             {
                 png1x = name;
@@ -198,6 +305,10 @@ public sealed class ChatEmoteService : IDisposable
             {
                 webp1x = name;
             }
+            else if (name.Equals("1x.gif", StringComparison.OrdinalIgnoreCase))
+            {
+                gif1x = name;
+            }
             else if (name.EndsWith(".png", StringComparison.OrdinalIgnoreCase) && pngFallback is null)
             {
                 pngFallback = name;
@@ -206,25 +317,80 @@ public sealed class ChatEmoteService : IDisposable
             {
                 webpFallback = name;
             }
+            else if (name.EndsWith(".gif", StringComparison.OrdinalIgnoreCase) && gifFallback is null)
+            {
+                gifFallback = name;
+            }
         }
 
-        return png1x ?? webp1x ?? pngFallback ?? webpFallback;
+        return png1x ?? webp1x ?? gif1x ?? pngFallback ?? webpFallback ?? gifFallback;
     }
 
-    private void QueueEmoteDownload(EmoteEntry entry)
+    private static bool IsAnimatedFormatSupported(EmoteFile file)
+    {
+        if (!string.IsNullOrWhiteSpace(file.Format))
+        {
+            return file.Format.Equals("WEBP", StringComparison.OrdinalIgnoreCase)
+                || file.Format.Equals("GIF", StringComparison.OrdinalIgnoreCase);
+        }
+
+        return file.Name.EndsWith(".webp", StringComparison.OrdinalIgnoreCase)
+            || file.Name.EndsWith(".gif", StringComparison.OrdinalIgnoreCase);
+    }
+
+    private readonly record struct EmoteSource(string? StaticUrl, string? AnimatedUrl)
+    {
+        public bool HasStatic => !string.IsNullOrWhiteSpace(StaticUrl);
+        public bool HasAnimation => !string.IsNullOrWhiteSpace(AnimatedUrl);
+    }
+
+    private readonly record struct EmoteFile(string Name, string? StaticName, int FrameCount, string? Format);
+
+    private void QueueEmoteDownload(EmoteEntry entry, bool allowAnimation)
     {
         _ = Task.Run(async () =>
         {
             await _downloadGate.WaitAsync().ConfigureAwait(false);
             try
             {
-                var data = await _httpClient.GetByteArrayAsync(entry.Url).ConfigureAwait(false);
+                if (allowAnimation)
-                var texture = _uiSharedService.LoadImage(data);
+                {
-                entry.SetTexture(texture);
+                    if (entry.HasAnimatedSource)
+                    {
+                        entry.MarkAnimationAttempted();
+                        if (await TryLoadAnimatedEmoteAsync(entry).ConfigureAwait(false))
+                        {
+                            return;
+                        }
+                    }
+
+                    if (entry.HasStaticSource && !entry.HasStaticTexture && await TryLoadStaticEmoteAsync(entry).ConfigureAwait(false))
+                    {
+                        return;
+                    }
+                }
+                else
+                {
+                    if (entry.HasStaticSource && await TryLoadStaticEmoteAsync(entry).ConfigureAwait(false))
+                    {
+                        return;
+                    }
+
+                    if (entry.HasAnimatedSource)
+                    {
+                        entry.MarkAnimationAttempted();
+                        if (await TryLoadAnimatedEmoteAsync(entry).ConfigureAwait(false))
+                        {
+                            return;
+                        }
+                    }
+                }
+
+                entry.MarkFailed();
             }
             catch (Exception ex)
             {
-                _logger.LogDebug(ex, "Failed to load 7TV emote {Url}", entry.Url);
+                _logger.LogDebug(ex, "Failed to load 7TV emote {Emote}", entry.Code);
                 entry.MarkFailed();
             }
             finally
@@ -234,21 +400,334 @@ public sealed class ChatEmoteService : IDisposable
         });
     }
 
-    private sealed class EmoteEntry
+    private async Task<bool> TryLoadAnimatedEmoteAsync(EmoteEntry entry)
     {
-        private int _loadingState;
+        if (string.IsNullOrWhiteSpace(entry.AnimatedUrl))
-
-        public EmoteEntry(string url)
         {
-            Url = url;
+            return false;
         }
 
-        public string Url { get; }
+        try
-        public IDalamudTextureWrap? Texture { get; private set; }
-
-        public void EnsureLoading(Action<EmoteEntry> queueDownload)
         {
-            if (Texture is not null)
+            var data = await _httpClient.GetByteArrayAsync(entry.AnimatedUrl).ConfigureAwait(false);
+            var isWebp = entry.AnimatedUrl.EndsWith(".webp", StringComparison.OrdinalIgnoreCase);
+            if (!TryDecodeAnimation(data, isWebp, out var animation))
+            {
+                return false;
+            }
+
+            entry.SetAnimation(animation);
+            return true;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "Failed to decode animated 7TV emote {Emote}", entry.Code);
+            return false;
+        }
+    }
+
+    private async Task<bool> TryLoadStaticEmoteAsync(EmoteEntry entry)
+    {
+        if (string.IsNullOrWhiteSpace(entry.StaticUrl))
+        {
+            return false;
+        }
+
+        try
+        {
+            var data = await _httpClient.GetByteArrayAsync(entry.StaticUrl).ConfigureAwait(false);
+            var texture = _uiSharedService.LoadImage(data);
+            entry.SetStaticTexture(texture);
+            return true;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "Failed to decode static 7TV emote {Emote}", entry.Code);
+            return false;
+        }
+    }
+
+    private bool TryDecodeAnimation(byte[] data, bool isWebp, out EmoteAnimation? animation)
+    {
+        animation = null;
+        List<EmoteFrame>? frames = null;
+
+        try
+        {
+            Image<Rgba32> image;
+            if (isWebp)
+            {
+                using var stream = new MemoryStream(data);
+                image = WebpDecoder.Instance.Decode<Rgba32>(
+                    new WebpDecoderOptions { BackgroundColorHandling = BackgroundColorHandling.Ignore },
+                    stream);
+            }
+            else
+            {
+                image = Image.Load<Rgba32>(data);
+            }
+
+            using (image)
+            {
+                if (image.Frames.Count <= 1)
+                {
+                    return false;
+                }
+
+                using var composite = new Image<Rgba32>(image.Width, image.Height, Color.Transparent);
+                Image<Rgba32>? restoreCanvas = null;
+                GifDisposalMethod? pendingGifDisposal = null;
+                WebpDisposalMethod? pendingWebpDisposal = null;
+
+                frames = new List<EmoteFrame>(image.Frames.Count);
+                for (var i = 0; i < image.Frames.Count; i++)
+                {
+                    var frameMetadata = image.Frames[i].Metadata;
+                    var delayMs = GetFrameDelayMs(frameMetadata);
+
+                    ApplyDisposal(composite, ref restoreCanvas, pendingGifDisposal, pendingWebpDisposal);
+
+                    GifDisposalMethod? currentGifDisposal = null;
+                    WebpDisposalMethod? currentWebpDisposal = null;
+                    var blendMethod = WebpBlendMethod.Over;
+
+                    if (isWebp)
+                    {
+                        if (frameMetadata.TryGetWebpFrameMetadata(out var webpMetadata))
+                        {
+                            currentWebpDisposal = webpMetadata.DisposalMethod;
+                            blendMethod = webpMetadata.BlendMethod;
+                        }
+                    }
+                    else if (frameMetadata.TryGetGifMetadata(out var gifMetadata))
+                    {
+                        currentGifDisposal = gifMetadata.DisposalMethod;
+                    }
+
+                    if (currentGifDisposal == GifDisposalMethod.RestoreToPrevious)
+                    {
+                        restoreCanvas?.Dispose();
+                        restoreCanvas = composite.Clone();
+                    }
+
+                    using var frameImage = image.Frames.CloneFrame(i);
+                    var alphaMode = blendMethod == WebpBlendMethod.Source
+                        ? PixelAlphaCompositionMode.Src
+                        : PixelAlphaCompositionMode.SrcOver;
+                    composite.Mutate(ctx => ctx.DrawImage(frameImage, PixelColorBlendingMode.Normal, alphaMode, 1f));
+
+                    using var renderedFrame = composite.Clone();
+                    using var ms = new MemoryStream();
+                    renderedFrame.SaveAsPng(ms);
+
+                    var texture = _uiSharedService.LoadImage(ms.ToArray());
+                    frames.Add(new EmoteFrame(texture, delayMs));
+
+                    pendingGifDisposal = currentGifDisposal;
+                    pendingWebpDisposal = currentWebpDisposal;
+                }
+
+                restoreCanvas?.Dispose();
+
+                animation = new EmoteAnimation(frames);
+                return true;
+            }
+        }
+        catch
+        {
+            if (frames is not null)
+            {
+                foreach (var frame in frames)
+                {
+                    frame.Texture.Dispose();
+                }
+            }
+
+            return false;
+        }
+    }
+
+    private static int GetFrameDelayMs(ImageFrameMetadata metadata)
+    {
+        if (metadata.TryGetGifMetadata(out var gifMetadata))
+        {
+            var delayMs = (long)gifMetadata.FrameDelay * 10L;
+            return NormalizeFrameDelayMs(delayMs);
+        }
+
+        if (metadata.TryGetWebpFrameMetadata(out var webpMetadata))
+        {
+            return NormalizeFrameDelayMs(webpMetadata.FrameDelay);
+        }
+
+        return DefaultFrameDelayMs;
+    }
+
+    private static int NormalizeFrameDelayMs(long delayMs)
+    {
+        if (delayMs <= 0)
+        {
+            return DefaultFrameDelayMs;
+        }
+
+        var clamped = delayMs > int.MaxValue ? int.MaxValue : (int)delayMs;
+        return Math.Max(clamped, MinFrameDelayMs);
+    }
+
+    private static void ApplyDisposal(
+        Image<Rgba32> composite,
+        ref Image<Rgba32>? restoreCanvas,
+        GifDisposalMethod? gifDisposal,
+        WebpDisposalMethod? webpDisposal)
+    {
+        if (gifDisposal is not null)
+        {
+            switch (gifDisposal)
+            {
+                case GifDisposalMethod.RestoreToBackground:
+                    composite.Mutate(ctx => ctx.BackgroundColor(Color.Transparent));
+                    break;
+                case GifDisposalMethod.RestoreToPrevious:
+                    if (restoreCanvas is not null)
+                    {
+                        composite.Mutate(ctx => ctx.BackgroundColor(Color.Transparent));
+                        var restoreSnapshot = restoreCanvas;
+                        composite.Mutate(ctx => ctx.DrawImage(restoreSnapshot, PixelColorBlendingMode.Normal, PixelAlphaCompositionMode.Src, 1f));
+                        restoreCanvas.Dispose();
+                        restoreCanvas = null;
+                    }
+                    break;
+            }
+        }
+        else if (webpDisposal == WebpDisposalMethod.RestoreToBackground)
+        {
+            composite.Mutate(ctx => ctx.BackgroundColor(Color.Transparent));
+        }
+    }
+
+    private sealed class EmoteAnimation : IDisposable
+    {
+        private readonly EmoteFrame[] _frames;
+        private readonly int _durationMs;
+        private readonly long _startTimestamp;
+
+        public EmoteAnimation(IReadOnlyList<EmoteFrame> frames)
+        {
+            _frames = frames.ToArray();
+            _durationMs = Math.Max(1, frames.Sum(frame => frame.DurationMs));
+            _startTimestamp = Stopwatch.GetTimestamp();
+        }
+
+        public IDalamudTextureWrap? GetCurrentFrame()
+        {
+            if (_frames.Length == 0)
+            {
+                return null;
+            }
+
+            if (_frames.Length == 1)
+            {
+                return _frames[0].Texture;
+            }
+
+            var elapsedTicks = Stopwatch.GetTimestamp() - _startTimestamp;
+            var elapsedMs = (elapsedTicks * 1000L) / Stopwatch.Frequency;
+            var targetMs = (int)(elapsedMs % _durationMs);
+            var accumulated = 0;
+
+            foreach (var frame in _frames)
+            {
+                accumulated += frame.DurationMs;
+                if (targetMs < accumulated)
+                {
+                    return frame.Texture;
+                }
+            }
+
+            return _frames[^1].Texture;
+        }
+
+        public IDalamudTextureWrap? GetStaticFrame()
+        {
+            if (_frames.Length == 0)
+            {
+                return null;
+            }
+
+            return _frames[0].Texture;
+        }
+
+        public void Dispose()
+        {
+            foreach (var frame in _frames)
+            {
+                frame.Texture.Dispose();
+            }
+        }
+    }
+
+    private readonly record struct EmoteFrame(IDalamudTextureWrap Texture, int DurationMs);
+
+    private sealed class EmoteEntry : IDisposable
+    {
+        private int _loadingState;
+        private int _animationAttempted;
+        private IDalamudTextureWrap? _staticTexture;
+        private EmoteAnimation? _animation;
+
+        public EmoteEntry(string code, EmoteSource source)
+        {
+            Code = code;
+            StaticUrl = source.StaticUrl;
+            AnimatedUrl = source.AnimatedUrl;
+        }
+
+        public string Code { get; }
+        public string? StaticUrl { get; }
+        public string? AnimatedUrl { get; }
+        public bool HasStaticSource => !string.IsNullOrWhiteSpace(StaticUrl);
+        public bool HasAnimatedSource => !string.IsNullOrWhiteSpace(AnimatedUrl);
+        public bool HasStaticTexture => _staticTexture is not null;
+        public bool HasAttemptedAnimation => Interlocked.CompareExchange(ref _animationAttempted, 0, 0) != 0;
+        public bool NeedsAnimationLoad => _animation is null && HasAnimatedSource;
+
+        public void MarkAnimationAttempted()
+        {
+            Interlocked.Exchange(ref _animationAttempted, 1);
+        }
+
+        public bool TryGetTexture(bool allowAnimation, out IDalamudTextureWrap? texture)
+        {
+            if (allowAnimation && _animation is not null)
+            {
+                texture = _animation.GetCurrentFrame();
+                return true;
+            }
+
+            if (_staticTexture is not null)
+            {
+                texture = _staticTexture;
+                return true;
+            }
+
+            if (!allowAnimation && _animation is not null)
+            {
+                texture = _animation.GetStaticFrame();
+                return true;
+            }
+
+            texture = null;
+            return false;
+        }
+
+        public void EnsureLoading(bool allowAnimation, Action<EmoteEntry, bool> queueDownload, bool allowWhenStaticLoaded = false)
+        {
+            if (_animation is not null)
+            {
+                return;
+            }
+
+            if (!allowWhenStaticLoaded && _staticTexture is not null)
             {
                 return;
             }
@@ -258,12 +737,22 @@ public sealed class ChatEmoteService : IDisposable
                 return;
             }
 
-            queueDownload(this);
+            queueDownload(this, allowAnimation);
         }
 
-        public void SetTexture(IDalamudTextureWrap texture)
+        public void SetAnimation(EmoteAnimation animation)
         {
-            Texture = texture;
+            _staticTexture?.Dispose();
+            _staticTexture = null;
+            _animation?.Dispose();
+            _animation = animation;
+            Interlocked.Exchange(ref _loadingState, 0);
+        }
+
+        public void SetStaticTexture(IDalamudTextureWrap texture)
+        {
+            _staticTexture?.Dispose();
+            _staticTexture = texture;
             Interlocked.Exchange(ref _loadingState, 0);
         }
 
@@ -271,5 +760,11 @@ public sealed class ChatEmoteService : IDisposable
         {
             Interlocked.Exchange(ref _loadingState, 0);
         }
+
+        public void Dispose()
+        {
+            _animation?.Dispose();
+            _staticTexture?.Dispose();
+        }
     }
 }

LightlessSync/Services/DalamudUtilService.cs

@@ -666,7 +666,7 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
 
         var location = new LocationInfo();
         location.ServerId = _playerState.CurrentWorld.RowId;
-        location.InstanceId = UIState.Instance()->PublicInstance.InstanceId; 
+        location.InstanceId = UIState.Instance()->PublicInstance.InstanceId;
         location.TerritoryId = _clientState.TerritoryType;
         location.MapId = _clientState.MapId;
         if (houseMan != null)
@@ -699,13 +699,13 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
         }
         return location;
     }
-    
+
     public string LocationToString(LocationInfo location)
     {
         if (location.ServerId is 0 || location.TerritoryId is 0) return String.Empty;
         var str = WorldData.Value[(ushort)location.ServerId];
 
-        if (ContentFinderData.Value.TryGetValue(location.TerritoryId , out var dutyName))
+        if (ContentFinderData.Value.TryGetValue(location.TerritoryId, out var dutyName))
         {
             str += $" - [In Duty]{dutyName}";
         }
@@ -856,7 +856,7 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
 
         var token = ct ?? CancellationToken.None;
 
-        const int tick = 250; 
+        const int tick = 250;
         const int initialSettle = 50;
 
         var sw = Stopwatch.StartNew();
@@ -881,7 +881,7 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
         {
             // ignore
         }
-        catch (AccessViolationException ex)
+        catch (Exception ex)
         {
             logger.LogWarning(ex, "Error accessing {handler}, object does not exist anymore?", handler);
         }
@@ -922,11 +922,11 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
     public string? GetWorldNameFromPlayerAddress(nint address)
     {
         if (address == nint.Zero) return null;
-        
+
         EnsureIsOnFramework();
         var playerCharacter = _objectTable.OfType<IPlayerCharacter>().FirstOrDefault(p => p.Address == address);
         if (playerCharacter == null) return null;
-        
+
         var worldId = (ushort)playerCharacter.HomeWorld.RowId;
         return WorldData.Value.TryGetValue(worldId, out var worldName) ? worldName : null;
     }
@@ -953,37 +953,87 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
         });
     }
 
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern bool IsBadReadPtr(IntPtr ptr, UIntPtr size);
+
+    private static bool IsValidPointer(nint ptr, int size = 8)
+    {
+        if (ptr == nint.Zero)
+            return false;
+
+        try
+        {
+            if (!Util.IsWine())
+            {
+                return !IsBadReadPtr(ptr, (UIntPtr)size);
+            }
+            return ptr != nint.Zero && (ptr % IntPtr.Size) == 0;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
     private unsafe void CheckCharacterForDrawing(nint address, string characterName)
     {
+        if (address == nint.Zero)
+            return;
+
+        if (!IsValidPointer(address))
+        {
+            _logger.LogDebug("Invalid pointer for character {name} at {addr}", characterName, address.ToString("X"));
+            return;
+        }
+
         var gameObj = (GameObject*)address;
+
+        if (gameObj == null)
+            return;
+
+        if (!_objectTable.Any(o => o?.Address == address))
+        {
+            _logger.LogDebug("Character {name} at {addr} no longer in object table", characterName, address.ToString("X"));
+            return;
+        }
+
+        if (gameObj->ObjectKind == 0)
+            return;
+
         var drawObj = gameObj->DrawObject;
         bool isDrawing = false;
         bool isDrawingChanged = false;
-        if ((nint)drawObj != IntPtr.Zero)
+
+        if ((nint)drawObj != IntPtr.Zero && IsValidPointer((nint)drawObj))
         {
             isDrawing = gameObj->RenderFlags == (VisibilityFlags)0b100000000000;
+
             if (!isDrawing)
             {
-                isDrawing = ((CharacterBase*)drawObj)->HasModelInSlotLoaded != 0;
+                var charBase = (CharacterBase*)drawObj;
-                if (!isDrawing)
+                if (charBase != null && IsValidPointer((nint)charBase))
                 {
-                    isDrawing = ((CharacterBase*)drawObj)->HasModelFilesInSlotLoaded != 0;
+                    isDrawing = charBase->HasModelInSlotLoaded != 0;
-                    if (isDrawing && !string.Equals(_lastGlobalBlockPlayer, characterName, StringComparison.Ordinal)
+                    if (!isDrawing)
-                        && !string.Equals(_lastGlobalBlockReason, "HasModelFilesInSlotLoaded", StringComparison.Ordinal))
                     {
-                        _lastGlobalBlockPlayer = characterName;
+                        isDrawing = charBase->HasModelFilesInSlotLoaded != 0;
-                        _lastGlobalBlockReason = "HasModelFilesInSlotLoaded";
+                        if (isDrawing && !string.Equals(_lastGlobalBlockPlayer, characterName, StringComparison.Ordinal)
-                        isDrawingChanged = true;
+                            && !string.Equals(_lastGlobalBlockReason, "HasModelFilesInSlotLoaded", StringComparison.Ordinal))
+                        {
+                            _lastGlobalBlockPlayer = characterName;
+                            _lastGlobalBlockReason = "HasModelFilesInSlotLoaded";
+                            isDrawingChanged = true;
+                        }
                     }
-                }
+                    else
-                else
-                {
-                    if (!string.Equals(_lastGlobalBlockPlayer, characterName, StringComparison.Ordinal)
-                        && !string.Equals(_lastGlobalBlockReason, "HasModelInSlotLoaded", StringComparison.Ordinal))
                     {
-                        _lastGlobalBlockPlayer = characterName;
+                        if (!string.Equals(_lastGlobalBlockPlayer, characterName, StringComparison.Ordinal)
-                        _lastGlobalBlockReason = "HasModelInSlotLoaded";
+                            && !string.Equals(_lastGlobalBlockReason, "HasModelInSlotLoaded", StringComparison.Ordinal))
-                        isDrawingChanged = true;
+                        {
+                            _lastGlobalBlockPlayer = characterName;
+                            _lastGlobalBlockReason = "HasModelInSlotLoaded";
+                            isDrawingChanged = true;
+                        }
                     }
                 }
             }
@@ -1014,6 +1064,11 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
 
     private unsafe void FrameworkOnUpdateInternal()
     {
+        if (!_clientState.IsLoggedIn || _objectTable.LocalPlayer == null)
+        {
+            return;
+        }
+
         if ((_objectTable.LocalPlayer?.IsDead ?? false) && _condition[ConditionFlag.BoundByDuty])
         {
             return;
@@ -1033,12 +1088,17 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
                     }
 
                     var playerDescriptors = _actorObjectService.PlayerDescriptors;
-                    for (var i = 0; i < playerDescriptors.Count; i++)
+                    var descriptorCount = playerDescriptors.Count;
+
+                    for (var i = 0; i < descriptorCount; i++)
                     {
+                        if (i >= playerDescriptors.Count)
+                            break;
+
                         var actor = playerDescriptors[i];
 
                         var playerAddress = actor.Address;
-                        if (playerAddress == nint.Zero)
+                        if (playerAddress == nint.Zero || !IsValidPointer(playerAddress))
                             continue;
 
                         if (actor.ObjectIndex >= 200)
@@ -1052,17 +1112,16 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
 
                         if (!IsAnythingDrawing)
                         {
-                            var gameObj = (GameObject*)playerAddress;
+                            if (!_objectTable.Any(o => o?.Address == playerAddress))
-                            var currentName = gameObj != null ? gameObj->NameString ?? string.Empty : string.Empty;
+                            {
-                            var charaName = string.IsNullOrEmpty(currentName) ? actor.Name : currentName;
+                                continue;
-                            CheckCharacterForDrawing(playerAddress, charaName);
+                            }
+
+                            CheckCharacterForDrawing(playerAddress, actor.Name);
+
                             if (IsAnythingDrawing)
                                 break;
                         }
-                        else
-                        {
-                            break;
-                        }
                     }
                 });
 
@@ -1131,7 +1190,7 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
                 });
 
             // Cutscene
-            HandleStateTransition(() => IsInCutscene,v => IsInCutscene = v, shouldBeInCutscene, "Cutscene",
+            HandleStateTransition(() => IsInCutscene, v => IsInCutscene = v, shouldBeInCutscene, "Cutscene",
                 onEnter: () =>
                 {
                     Mediator.Publish(new CutsceneStartMessage());
@@ -1174,7 +1233,7 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
                 Mediator.Publish(new ZoneSwitchEndMessage());
                 Mediator.Publish(new ResumeScanMessage(nameof(ConditionFlag.BetweenAreas)));
             }
-            
+
             //Map
             if (!_sentBetweenAreas)
             {
@@ -1185,7 +1244,7 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
                     Mediator.Publish(new MapChangedMessage(mapid));
                 }
             }
-            
+
 
             var localPlayer = _objectTable.LocalPlayer;
             if (localPlayer != null)
@@ -1271,4 +1330,4 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
             onExit();
         }
     }
-}
+}

LightlessSync/Services/LightFinder/LightFinderScannerService.cs

@@ -83,12 +83,12 @@ public class LightFinderScannerService : DisposableMediatorSubscriberBase
 
         var now = DateTime.UtcNow;
 
-        foreach (var address in _actorTracker.PlayerAddresses)
+        foreach (var descriptor in _actorTracker.PlayerDescriptors)
         {
-            if (address == nint.Zero)
+            if (string.IsNullOrEmpty(descriptor.HashedContentId))
                 continue;
 
-            var cid = DalamudUtilService.GetHashedCIDFromPlayerPointer(address);
+            var cid = descriptor.HashedContentId;
             var isStale = !_broadcastCache.TryGetValue(cid, out var entry) || entry.ExpiryTime <= now;
 
             if (isStale && _lookupQueuedCids.Add(cid) && _lookupQueue.Count < _maxQueueSize)

LightlessSync/Services/XivDataAnalyzer.cs

@@ -1,5 +1,6 @@
 using FFXIVClientStructs.FFXIV.Client.Game.Character;
 using FFXIVClientStructs.FFXIV.Client.Graphics.Scene;
+using FFXIVClientStructs.Havok.Common.Serialize.Resource;
 using FFXIVClientStructs.Havok.Animation;
 using FFXIVClientStructs.Havok.Common.Base.Types;
 using FFXIVClientStructs.Havok.Common.Serialize.Util;
@@ -145,156 +146,297 @@ public sealed partial class XivDataAnalyzer
         using var reader = new BinaryReader(fs);
 
         // PAP header (mostly from vfxeditor)
-        _ = reader.ReadInt32(); // ignore
-        _ = reader.ReadInt32(); // ignore
-        _ = reader.ReadInt16(); // num animations
-        _ = reader.ReadInt16(); // modelid
-
-        var type = reader.ReadByte(); // type
-        if (type != 0)
-            return null; // not human
-
-        _ = reader.ReadByte();  // variant
-        _ = reader.ReadInt32(); // ignore
-
-        var havokPosition = reader.ReadInt32();
-        var footerPosition = reader.ReadInt32();
-
-        // sanity checks
-        if (havokPosition <= 0 || footerPosition <= havokPosition || footerPosition > fs.Length)
-            return null;
-
-        var havokDataSizeLong = (long)footerPosition - havokPosition;
-        if (havokDataSizeLong <= 8 || havokDataSizeLong > int.MaxValue)
-            return null;
-
-        var havokDataSize = (int)havokDataSizeLong;
-
-        reader.BaseStream.Position = havokPosition;
-        var havokData = reader.ReadBytes(havokDataSize);
-        if (havokData.Length <= 8)
-            return null;
-
-        var tempSets = new Dictionary<string, HashSet<ushort>>(StringComparer.OrdinalIgnoreCase);
-
-        var tempHavokDataPath = Path.Combine(Path.GetTempPath(), $"lightless_{Guid.NewGuid():N}.hkx");
-        IntPtr tempHavokDataPathAnsi = IntPtr.Zero;
-
         try
         {
-            File.WriteAllBytes(tempHavokDataPath, havokData);
+            _ = reader.ReadInt32(); // ignore
+            _ = reader.ReadInt32(); // ignore
+            var numAnimations = reader.ReadInt16(); // num animations
+            var modelId = reader.ReadInt16(); // modelid
 
-            if (!File.Exists(tempHavokDataPath))
+            if (numAnimations < 0 || numAnimations > 1000)
             {
-                _logger.LogTrace("Temporary havok file did not exist when attempting to load: {path}", tempHavokDataPath);
+                _logger.LogWarning("PAP file {hash} has invalid animation count {count}, skipping", hash, numAnimations);
                 return null;
             }
 
-            tempHavokDataPathAnsi = Marshal.StringToHGlobalAnsi(tempHavokDataPath);
+            var type = reader.ReadByte(); // type
+            if (type != 0)
+                return null; // not human
 
-            var loadoptions = stackalloc hkSerializeUtil.LoadOptions[1];
+            _ = reader.ReadByte();  // variant
-            loadoptions->TypeInfoRegistry = hkBuiltinTypeRegistry.Instance()->GetTypeInfoRegistry();
+            _ = reader.ReadInt32(); // ignore
-            loadoptions->ClassNameRegistry = hkBuiltinTypeRegistry.Instance()->GetClassNameRegistry();
-            loadoptions->Flags = new hkFlags<hkSerializeUtil.LoadOptionBits, int>
-            {
-                Storage = (int)hkSerializeUtil.LoadOptionBits.Default
-            };
 
-            var resource = hkSerializeUtil.LoadFromFile((byte*)tempHavokDataPathAnsi, null, loadoptions);
+            var havokPosition = reader.ReadInt32();
-            if (resource == null)
+            var footerPosition = reader.ReadInt32();
+
+            if (havokPosition <= 0 || footerPosition <= havokPosition ||
+                footerPosition > fs.Length || havokPosition >= fs.Length)
             {
-                _logger.LogWarning("Havok resource was null after loading from {path}", tempHavokDataPath);
+                _logger.LogWarning("PAP file {hash} has invalid offsets (havok={havok}, footer={footer}, length={length})",
+                    hash, havokPosition, footerPosition, fs.Length);
                 return null;
             }
 
-            var rootLevelName = @"hkRootLevelContainer"u8;
+            var havokDataSizeLong = (long)footerPosition - havokPosition;
-            fixed (byte* n1 = rootLevelName)
+            if (havokDataSizeLong <= 8 || havokDataSizeLong > int.MaxValue) 
             {
-                var container = (hkRootLevelContainer*)resource->GetContentsPointer(n1, hkBuiltinTypeRegistry.Instance()->GetTypeInfoRegistry());
+                _logger.LogWarning("PAP file {hash} has invalid Havok data size {size}", hash, havokDataSizeLong);
-                if (container == null)
+                return null;
-                    return null;
+            }
 
-                var animationName = @"hkaAnimationContainer"u8;
+            var havokDataSize = (int)havokDataSizeLong;
-                fixed (byte* n2 = animationName)
+
+            reader.BaseStream.Position = havokPosition;
+
+            var havokData = new byte[havokDataSize];
+            var bytesRead = reader.Read(havokData, 0, havokDataSize);
+            if (bytesRead != havokDataSize)
+            {
+                _logger.LogWarning("PAP file {hash}: Expected to read {expected} bytes but got {actual}",
+                    hash, havokDataSize, bytesRead);
+                return null;
+            }
+
+            if (havokData.Length < 8)
+                return null;
+
+            var tempSets = new Dictionary<string, HashSet<ushort>>(StringComparer.OrdinalIgnoreCase);
+
+            var tempFileName = $"lightless_pap_{Guid.NewGuid():N}_{hash.Substring(0, Math.Min(8, hash.Length))}.hkx";
+            var tempHavokDataPath = Path.Combine(Path.GetTempPath(), tempFileName);
+            IntPtr tempHavokDataPathAnsi = IntPtr.Zero;
+
+            try
+            {
+                var tempDir = Path.GetDirectoryName(tempHavokDataPath);
+                if (!Directory.Exists(tempDir))
                 {
-                    var animContainer = (hkaAnimationContainer*)container->findObjectByName(n2, null);
+                    _logger.LogWarning("Temp directory {dir} doesn't exist", tempDir);
-                    if (animContainer == null)
+                    return null;
-                        return null;
+                }
 
-                    for (int i = 0; i < animContainer->Bindings.Length; i++)
+                File.WriteAllBytes(tempHavokDataPath, havokData);
+
+                if (!File.Exists(tempHavokDataPath))
+                {
+                    _logger.LogWarning("Temporary havok file was not created at {path}", tempHavokDataPath);
+                    return null;
+                }
+
+                var writtenFileInfo = new FileInfo(tempHavokDataPath);
+                if (writtenFileInfo.Length != havokData.Length)
+                {
+                    _logger.LogWarning("Written temp file size mismatch: expected {expected}, got {actual}",
+                        havokData.Length, writtenFileInfo.Length);
+                    File.Delete(tempHavokDataPath);
+                    return null;
+                }
+
+                tempHavokDataPathAnsi = Marshal.StringToHGlobalAnsi(tempHavokDataPath);
+
+                var loadoptions = stackalloc hkSerializeUtil.LoadOptions[1];
+                loadoptions->TypeInfoRegistry = hkBuiltinTypeRegistry.Instance()->GetTypeInfoRegistry();
+                loadoptions->ClassNameRegistry = hkBuiltinTypeRegistry.Instance()->GetClassNameRegistry();
+                loadoptions->Flags = new hkFlags<hkSerializeUtil.LoadOptionBits, int>
+                {
+                    Storage = (int)hkSerializeUtil.LoadOptionBits.Default
+                };
+
+                hkResource* resource = null;
+                try
+                {
+                    resource = hkSerializeUtil.LoadFromFile((byte*)tempHavokDataPathAnsi, null, loadoptions);
+                }
+                catch (SEHException ex)
+                {
+                    _logger.LogError(ex, "SEH exception loading Havok file from {path} (hash={hash}). Native error code: 0x{code:X}",
+                        tempHavokDataPath, hash, ex.ErrorCode);
+                    return null;
+                }
+
+                if (resource == null)
+                {
+                    _logger.LogDebug("Havok resource was null after loading from {path} (hash={hash})", tempHavokDataPath, hash);
+                    return null;
+                }
+
+                if ((nint)resource == nint.Zero || !IsValidPointer((IntPtr)resource))
+                {
+                    _logger.LogDebug("Havok resource pointer is invalid (hash={hash})", hash);
+                    return null;
+                }
+
+                var rootLevelName = @"hkRootLevelContainer"u8;
+                fixed (byte* n1 = rootLevelName)
+                {
+                    var container = (hkRootLevelContainer*)resource->GetContentsPointer(n1, hkBuiltinTypeRegistry.Instance()->GetTypeInfoRegistry());
+                    if (container == null)
                     {
-                        var binding = animContainer->Bindings[i].ptr;
+                        _logger.LogDebug("hkRootLevelContainer is null (hash={hash})", hash);
-                        if (binding == null)
+                        return null;
-                            continue;
+                    }
 
-                        var rawSkel = binding->OriginalSkeletonName.String;
+                    if ((nint)container == nint.Zero || !IsValidPointer((IntPtr)container))
-                        var skeletonKey = CanonicalizeSkeletonKey(rawSkel);
+                    {
-                        if (string.IsNullOrEmpty(skeletonKey))
+                        _logger.LogDebug("hkRootLevelContainer pointer is invalid (hash={hash})", hash);
-                            continue;
+                        return null;
+                    }
 
-                        var boneTransform = binding->TransformTrackToBoneIndices;
+                    var animationName = @"hkaAnimationContainer"u8;
-                        if (boneTransform.Length <= 0)
+                    fixed (byte* n2 = animationName)
-                            continue;
+                    {
-
+                        var animContainer = (hkaAnimationContainer*)container->findObjectByName(n2, null);
-                        if (!tempSets.TryGetValue(skeletonKey, out var set))
+                        if (animContainer == null)
                         {
-                            set = [];
+                            _logger.LogDebug("hkaAnimationContainer is null (hash={hash})", hash);
-                            tempSets[skeletonKey] = set;
+                            return null;
                         }
 
-                        for (int boneIdx = 0; boneIdx < boneTransform.Length; boneIdx++)
+                        if ((nint)animContainer == nint.Zero || !IsValidPointer((IntPtr)animContainer))
                         {
-                            var v = boneTransform[boneIdx];
+                            _logger.LogDebug("hkaAnimationContainer pointer is invalid (hash={hash})", hash);
-                            if (v < 0) continue;
+                            return null;
-                            set.Add((ushort)v);
+                        }
+
+                        if (animContainer->Bindings.Length < 0 || animContainer->Bindings.Length > 10000)
+                        {
+                            _logger.LogDebug("Invalid bindings count {count} (hash={hash})", animContainer->Bindings.Length, hash);
+                            return null;
+                        }
+
+                        for (int i = 0; i < animContainer->Bindings.Length; i++)
+                        {
+                            var binding = animContainer->Bindings[i].ptr;
+                            if (binding == null)
+                                continue;
+
+                            if ((nint)binding == nint.Zero || !IsValidPointer((IntPtr)binding))
+                            {
+                                _logger.LogDebug("Skipping invalid binding at index {index} (hash={hash})", i, hash);
+                                continue;
+                            }
+
+                            var rawSkel = binding->OriginalSkeletonName.String;
+                            var skeletonKey = CanonicalizeSkeletonKey(rawSkel);
+                            if (string.IsNullOrEmpty(skeletonKey))
+                                continue;
+
+                            var boneTransform = binding->TransformTrackToBoneIndices;
+                            if (boneTransform.Length <= 0 || boneTransform.Length > 10000)
+                            {
+                                _logger.LogDebug("Invalid bone transform length {length} for skeleton {skel} (hash={hash})",
+                                    boneTransform.Length, skeletonKey, hash);
+                                continue;
+                            }
+
+                            if (!tempSets.TryGetValue(skeletonKey, out var set))
+                            {
+                                set = [];
+                                tempSets[skeletonKey] = set;
+                            }
+
+                            for (int boneIdx = 0; boneIdx < boneTransform.Length; boneIdx++)
+                            {
+                                var v = boneTransform[boneIdx];
+                                if (v < 0 || v > ushort.MaxValue)
+                                    continue;
+                                set.Add((ushort)v);
+                            }
                         }
                     }
                 }
             }
-        }
+            catch (SEHException ex)
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Could not load havok file in {path}", tempHavokDataPath);
-            return null;
-        }
-        finally
-        {
-            if (tempHavokDataPathAnsi != IntPtr.Zero)
-                Marshal.FreeHGlobal(tempHavokDataPathAnsi);
-
-            try
             {
-                if (File.Exists(tempHavokDataPath))
+                _logger.LogError(ex, "SEH exception processing PAP file {hash} from {path}. Error code: 0x{code:X}",
-                    File.Delete(tempHavokDataPath);
+                    hash, tempHavokDataPath, ex.ErrorCode);
+                return null;
             }
             catch (Exception ex)
             {
-                _logger.LogTrace(ex, "Could not delete temporary havok file: {path}", tempHavokDataPath);
+                _logger.LogError(ex, "Managed exception loading havok file {hash} from {path}", hash, tempHavokDataPath);
+                return null;
             }
+            finally
+            {
+                if (tempHavokDataPathAnsi != IntPtr.Zero)
+                    Marshal.FreeHGlobal(tempHavokDataPathAnsi);
+
+                int retryCount = 3;
+                while (retryCount > 0 && File.Exists(tempHavokDataPath))
+                {
+                    try
+                    {
+                        File.Delete(tempHavokDataPath);
+                        break;
+                    }
+                    catch (IOException ex)
+                    {
+                        retryCount--;
+                        if (retryCount == 0)
+                        {
+                            _logger.LogDebug(ex, "Failed to delete temporary havok file after retries: {path}", tempHavokDataPath);
+                        }
+                        else
+                        {
+                            Thread.Sleep(50);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogDebug(ex, "Unexpected error deleting temporary havok file: {path}", tempHavokDataPath);
+                        break;
+                    }
+                }
+            }
+
+            if (tempSets.Count == 0)
+            {
+                _logger.LogDebug("No bone sets found in PAP file (hash={hash})", hash);
+                return null;
+            }
+
+            var output = new Dictionary<string, List<ushort>>(tempSets.Count, StringComparer.OrdinalIgnoreCase);
+            foreach (var (key, set) in tempSets)
+            {
+                if (set.Count == 0) continue;
+
+                var list = set.ToList();
+                list.Sort();
+                output[key] = list;
+            }
+
+            if (output.Count == 0)
+                return null;
+
+            _configService.Current.BonesDictionary[hash] = output;
+
+            if (persistToConfig)
+                _configService.Save();
+
+            return output;
         }
-
+        catch (Exception ex)
-        if (tempSets.Count == 0)
-            return null;
-
-        var output = new Dictionary<string, List<ushort>>(tempSets.Count, StringComparer.OrdinalIgnoreCase);
-        foreach (var (key, set) in tempSets)
         {
-            if (set.Count == 0) continue;
+            _logger.LogError(ex, "Outer exception reading PAP file (hash={hash})", hash);
-
-            var list = set.ToList();
-            list.Sort();
-            output[key] = list;
-        }
-
-        if (output.Count == 0)
             return null;
+        }
+    }
 
-        _configService.Current.BonesDictionary[hash] = output;
+    private static bool IsValidPointer(IntPtr ptr)
+    {
+        if (ptr == IntPtr.Zero)
+            return false;
 
-        if (persistToConfig)
+        try
-            _configService.Save();
+        {
-
+            _ = Marshal.ReadByte(ptr);
-        return output;
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
     }
 
 

LightlessSync/UI/ZoneChatUi.cs

@@ -22,7 +22,6 @@ using LightlessSync.UI.Services;
 using LightlessSync.UI.Style;
 using LightlessSync.Utils;
 using Dalamud.Interface.Textures.TextureWraps;
-using OtterGui.Text;
 using LightlessSync.WebAPI;
 using LightlessSync.WebAPI.SignalR.Utils;
 using Microsoft.Extensions.Logging;
@@ -429,150 +428,182 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
         }
         else
         {
-            var itemHeight = ImGui.GetTextLineHeightWithSpacing();
+            var messageCount = channel.Messages.Count;
-            using var clipper = ImUtf8.ListClipper(channel.Messages.Count, itemHeight);
+            var contentMaxX = ImGui.GetWindowContentRegionMax().X;
-            while (clipper.Step())
+            var cursorStartX = ImGui.GetCursorPosX();
+            var lineHeightWithSpacing = ImGui.GetTextLineHeightWithSpacing();
+            var prefix = new float[messageCount + 1];
+            var totalHeight = 0f;
+
+            for (var i = 0; i < messageCount; i++)
             {
-                for (var i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)
+                var messageHeight = MeasureMessageHeight(channel, channel.Messages[i], showTimestamps, cursorStartX, contentMaxX, itemSpacing, ref pairSnapshot);
+                if (messageHeight <= 0f)
                 {
-                    var message = channel.Messages[i];
+                    messageHeight = lineHeightWithSpacing;
-                    ImGui.PushID(i);
+                }
 
-                    if (message.IsSystem)
+                totalHeight += messageHeight;
+                prefix[i + 1] = totalHeight;
+            }
+
+            var scrollY = ImGui.GetScrollY();
+            var windowHeight = ImGui.GetWindowHeight();
+            var startIndex = Math.Max(0, UpperBound(prefix, scrollY) - 1);
+            var endIndex = Math.Min(messageCount, LowerBound(prefix, scrollY + windowHeight));
+            startIndex = Math.Max(0, startIndex - 2);
+            endIndex = Math.Min(messageCount, endIndex + 2);
+
+            if (startIndex > 0)
+            {
+                ImGui.Dummy(new Vector2(1f, prefix[startIndex]));
+            }
+
+            for (var i = startIndex; i < endIndex; i++)
+            {
+                var message = channel.Messages[i];
+                ImGui.PushID(i);
+
+                if (message.IsSystem)
+                {
+                    DrawSystemEntry(message);
+                    ImGui.PopID();
+                    continue;
+                }
+
+                if (message.Payload is not { } payload)
+                {
+                    ImGui.PopID();
+                    continue;
+                }
+
+                var timestampText = string.Empty;
+                if (showTimestamps)
+                {
+                    timestampText = $"[{message.ReceivedAtUtc.ToLocalTime().ToString("HH:mm", CultureInfo.InvariantCulture)}] ";
+                }
+                var color = message.FromSelf ? UIColors.Get("LightlessBlue") : ImGuiColors.DalamudWhite;
+                var showRoleIcons = false;
+                var isOwner = false;
+                var isModerator = false;
+                var isPinned = false;
+
+                if (channel.Type == ChatChannelType.Group
+                    && payload.Sender.Kind == ChatSenderKind.IdentifiedUser
+                    && payload.Sender.User is not null)
+                {
+                    pairSnapshot ??= _pairUiService.GetSnapshot();
+                    var groupId = channel.Descriptor.CustomKey;
+                    if (!string.IsNullOrWhiteSpace(groupId)
+                        && pairSnapshot.GroupsByGid.TryGetValue(groupId, out var groupInfo))
                     {
-                        DrawSystemEntry(message);
+                        var senderUid = payload.Sender.User.UID;
-                        ImGui.PopID();
+                        isOwner = string.Equals(senderUid, groupInfo.OwnerUID, StringComparison.Ordinal);
-                        continue;
+                        if (groupInfo.GroupPairUserInfos.TryGetValue(senderUid, out var info))
+                        {
+                            isModerator = info.IsModerator();
+                            isPinned = info.IsPinned();
+                        }
                     }
 
-                    if (message.Payload is not { } payload)
+                    showRoleIcons = isOwner || isModerator || isPinned;
+                }
+
+                ImGui.BeginGroup();
+                ImGui.PushStyleColor(ImGuiCol.Text, color);
+                if (showRoleIcons)
+                {
+                    if (!string.IsNullOrEmpty(timestampText))
                     {
-                        ImGui.PopID();
+                        ImGui.TextUnformatted(timestampText);
-                        continue;
+                        ImGui.SameLine(0f, 0f);
                     }
 
-                    var timestampText = string.Empty;
+                    var hasIcon = false;
-                    if (showTimestamps)
+                    if (isModerator)
                     {
-                        timestampText = $"[{message.ReceivedAtUtc.ToLocalTime().ToString("HH:mm", CultureInfo.InvariantCulture)}] ";
+                        _uiSharedService.IconText(FontAwesomeIcon.UserShield, UIColors.Get("LightlessPurple"));
-                    }
+                        UiSharedService.AttachToolTip("Moderator");
-                    var color = message.FromSelf ? UIColors.Get("LightlessBlue") : ImGuiColors.DalamudWhite;
+                        hasIcon = true;
-                    var showRoleIcons = false;
-                    var isOwner = false;
-                    var isModerator = false;
-                    var isPinned = false;
-
-                    if (channel.Type == ChatChannelType.Group
-                        && payload.Sender.Kind == ChatSenderKind.IdentifiedUser
-                        && payload.Sender.User is not null)
-                    {
-                        pairSnapshot ??= _pairUiService.GetSnapshot();
-                        var groupId = channel.Descriptor.CustomKey;
-                        if (!string.IsNullOrWhiteSpace(groupId)
-                            && pairSnapshot.GroupsByGid.TryGetValue(groupId, out var groupInfo))
-                        {
-                            var senderUid = payload.Sender.User.UID;
-                            isOwner = string.Equals(senderUid, groupInfo.OwnerUID, StringComparison.Ordinal);
-                            if (groupInfo.GroupPairUserInfos.TryGetValue(senderUid, out var info))
-                            {
-                                isModerator = info.IsModerator();
-                                isPinned = info.IsPinned();
-                            }
-                        }
-
-                        showRoleIcons = isOwner || isModerator || isPinned;
                     }
 
-                    ImGui.BeginGroup();
+                    if (isOwner)
-                    ImGui.PushStyleColor(ImGuiCol.Text, color);
-                    if (showRoleIcons)
                     {
-                        if (!string.IsNullOrEmpty(timestampText))
-                        {
-                            ImGui.TextUnformatted(timestampText);
-                            ImGui.SameLine(0f, 0f);
-                        }
-
-                        var hasIcon = false;
-                        if (isModerator)
-                        {
-                            _uiSharedService.IconText(FontAwesomeIcon.UserShield, UIColors.Get("LightlessPurple"));
-                            UiSharedService.AttachToolTip("Moderator");
-                            hasIcon = true;
-                        }
-
-                        if (isOwner)
-                        {
-                            if (hasIcon)
-                            {
-                                ImGui.SameLine(0f, itemSpacing);
-                            }
-
-                            _uiSharedService.IconText(FontAwesomeIcon.Crown, UIColors.Get("LightlessYellow"));
-                            UiSharedService.AttachToolTip("Owner");
-                            hasIcon = true;
-                        }
-
-                        if (isPinned)
-                        {
-                            if (hasIcon)
-                            {
-                                ImGui.SameLine(0f, itemSpacing);
-                            }
-
-                            _uiSharedService.IconText(FontAwesomeIcon.Thumbtack, UIColors.Get("LightlessBlue"));
-                            UiSharedService.AttachToolTip("Pinned");
-                            hasIcon = true;
-                        }
-
                         if (hasIcon)
                         {
                             ImGui.SameLine(0f, itemSpacing);
                         }
 
-                        var messageStartX = ImGui.GetCursorPosX();
+                        _uiSharedService.IconText(FontAwesomeIcon.Crown, UIColors.Get("LightlessYellow"));
-                        DrawChatMessageWithEmotes($"{message.DisplayName}: ", payload.Message, messageStartX);
+                        UiSharedService.AttachToolTip("Owner");
+                        hasIcon = true;
                     }
-                    else
-                    {
-                        var messageStartX = ImGui.GetCursorPosX();
-                        DrawChatMessageWithEmotes($"{timestampText}{message.DisplayName}: ", payload.Message, messageStartX);
-                    }
-                    ImGui.PopStyleColor();
-                    ImGui.EndGroup();
 
-                    ImGui.SetNextWindowSizeConstraints(
+                    if (isPinned)
-                        new Vector2(190f * ImGuiHelpers.GlobalScale, 0f),
-                        new Vector2(float.MaxValue, float.MaxValue));
-                    if (ImGui.BeginPopupContextItem($"chat_msg_ctx##{channel.Key}_{i}"))
                     {
-                        var contextLocalTimestamp = payload.SentAtUtc.ToLocalTime();
+                        if (hasIcon)
-                        var contextTimestampText = contextLocalTimestamp.ToString("yyyy-MM-dd HH:mm:ss 'UTC'z", CultureInfo.InvariantCulture);
-                        ImGui.TextDisabled(contextTimestampText);
-                        if (channel.Type == ChatChannelType.Group
-                            && payload.Sender.Kind == ChatSenderKind.IdentifiedUser
-                            && payload.Sender.User is not null)
                         {
-                            var aliasOrUid = payload.Sender.User.AliasOrUID;
+                            ImGui.SameLine(0f, itemSpacing);
-                            if (!string.IsNullOrWhiteSpace(aliasOrUid)
-                                && !string.Equals(message.DisplayName, aliasOrUid, StringComparison.Ordinal))
-                            {
-                                ImGui.TextDisabled(aliasOrUid);
-                            }
-                        }
-                        ImGui.Separator();
-
-                        var actionIndex = 0;
-                        foreach (var action in GetContextMenuActions(channel, message))
-                        {
-                            DrawContextMenuAction(action, actionIndex++);
                         }
 
-                        ImGui.EndPopup();
+                        _uiSharedService.IconText(FontAwesomeIcon.Thumbtack, UIColors.Get("LightlessBlue"));
+                        UiSharedService.AttachToolTip("Pinned");
+                        hasIcon = true;
                     }
 
-                    ImGui.PopID();
+                    if (hasIcon)
+                    {
+                        ImGui.SameLine(0f, itemSpacing);
+                    }
+
+                    var messageStartX = ImGui.GetCursorPosX();
+                    DrawChatMessageWithEmotes($"{message.DisplayName}: ", payload.Message, messageStartX);
                 }
+                else
+                {
+                    var messageStartX = ImGui.GetCursorPosX();
+                    DrawChatMessageWithEmotes($"{timestampText}{message.DisplayName}: ", payload.Message, messageStartX);
+                }
+                ImGui.PopStyleColor();
+                ImGui.EndGroup();
+
+                ImGui.SetNextWindowSizeConstraints(
+                    new Vector2(190f * ImGuiHelpers.GlobalScale, 0f),
+                    new Vector2(float.MaxValue, float.MaxValue));
+                if (ImGui.BeginPopupContextItem($"chat_msg_ctx##{channel.Key}_{i}"))
+                {
+                    var contextLocalTimestamp = payload.SentAtUtc.ToLocalTime();
+                    var contextTimestampText = contextLocalTimestamp.ToString("yyyy-MM-dd HH:mm:ss 'UTC'z", CultureInfo.InvariantCulture);
+                    ImGui.TextDisabled(contextTimestampText);
+                    if (channel.Type == ChatChannelType.Group
+                        && payload.Sender.Kind == ChatSenderKind.IdentifiedUser
+                        && payload.Sender.User is not null)
+                    {
+                        var aliasOrUid = payload.Sender.User.AliasOrUID;
+                        if (!string.IsNullOrWhiteSpace(aliasOrUid)
+                            && !string.Equals(message.DisplayName, aliasOrUid, StringComparison.Ordinal))
+                        {
+                            ImGui.TextDisabled(aliasOrUid);
+                        }
+                    }
+                    ImGui.Separator();
+
+                    var actionIndex = 0;
+                    foreach (var action in GetContextMenuActions(channel, message))
+                    {
+                        DrawContextMenuAction(action, actionIndex++);
+                    }
+
+                    ImGui.EndPopup();
+                }
+
+                ImGui.PopID();
+            }
+
+            var remainingHeight = totalHeight - prefix[endIndex];
+            if (remainingHeight > 0f)
+            {
+                ImGui.Dummy(new Vector2(1f, remainingHeight));
             }
         }
 
@@ -708,7 +739,20 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
                     var clicked = false;
                     if (texture is not null)
                     {
-                        clicked = ImGui.ImageButton(texture.Handle, new Vector2(emoteSize));
+                        var buttonSize = new Vector2(itemWidth, itemHeight);
+                        clicked = ImGui.InvisibleButton("##emote_button", buttonSize);
+                        var drawList = ImGui.GetWindowDrawList();
+                        var itemMin = ImGui.GetItemRectMin();
+                        var itemMax = ImGui.GetItemRectMax();
+                        var bgColor = ImGui.IsItemActive()
+                            ? ImGui.GetColorU32(ImGuiCol.ButtonActive)
+                            : ImGui.IsItemHovered()
+                                ? ImGui.GetColorU32(ImGuiCol.ButtonHovered)
+                                : ImGui.GetColorU32(ImGuiCol.Button);
+                        drawList.AddRectFilled(itemMin, itemMax, bgColor, style.FrameRounding);
+                        var imageMin = itemMin + style.FramePadding;
+                        var imageMax = imageMin + new Vector2(emoteSize);
+                        drawList.AddImage(texture.Handle, imageMin, imageMax);
                     }
                     else
                     {
@@ -878,7 +922,232 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
 
     private static bool IsEmoteChar(char value)
     {
-        return char.IsLetterOrDigit(value) || value == '_' || value == '-' || value == '!';
+        return char.IsLetterOrDigit(value) || value == '_' || value == '-' || value == '!' || value == '(' || value == ')';
+    }
+
+    private float MeasureMessageHeight(
+        ChatChannelSnapshot channel,
+        ChatMessageEntry message,
+        bool showTimestamps,
+        float cursorStartX,
+        float contentMaxX,
+        float itemSpacing,
+        ref PairUiSnapshot? pairSnapshot)
+    {
+        if (message.IsSystem)
+        {
+            return MeasureSystemEntryHeight(message);
+        }
+
+        if (message.Payload is not { } payload)
+        {
+            return 0f;
+        }
+
+        var timestampText = string.Empty;
+        if (showTimestamps)
+        {
+            timestampText = $"[{message.ReceivedAtUtc.ToLocalTime().ToString("HH:mm", CultureInfo.InvariantCulture)}] ";
+        }
+
+        var showRoleIcons = false;
+        var isOwner = false;
+        var isModerator = false;
+        var isPinned = false;
+
+        if (channel.Type == ChatChannelType.Group
+            && payload.Sender.Kind == ChatSenderKind.IdentifiedUser
+            && payload.Sender.User is not null)
+        {
+            pairSnapshot ??= _pairUiService.GetSnapshot();
+            var groupId = channel.Descriptor.CustomKey;
+            if (!string.IsNullOrWhiteSpace(groupId)
+                && pairSnapshot.GroupsByGid.TryGetValue(groupId, out var groupInfo))
+            {
+                var senderUid = payload.Sender.User.UID;
+                isOwner = string.Equals(senderUid, groupInfo.OwnerUID, StringComparison.Ordinal);
+                if (groupInfo.GroupPairUserInfos.TryGetValue(senderUid, out var info))
+                {
+                    isModerator = info.IsModerator();
+                    isPinned = info.IsPinned();
+                }
+            }
+
+            showRoleIcons = isOwner || isModerator || isPinned;
+        }
+
+        var lineStartX = cursorStartX;
+        string prefix;
+        if (showRoleIcons)
+        {
+            lineStartX += MeasureRolePrefixWidth(timestampText, isOwner, isModerator, isPinned, itemSpacing);
+            prefix = $"{message.DisplayName}: ";
+        }
+        else
+        {
+            prefix = $"{timestampText}{message.DisplayName}: ";
+        }
+
+        var lines = MeasureChatMessageLines(prefix, payload.Message, lineStartX, contentMaxX);
+        return Math.Max(1, lines) * ImGui.GetTextLineHeightWithSpacing();
+    }
+
+    private int MeasureChatMessageLines(string prefix, string message, float lineStartX, float contentMaxX)
+    {
+        var segments = BuildChatSegments(prefix, message);
+        if (segments.Count == 0)
+        {
+            return 1;
+        }
+
+        var emoteWidth = ImGui.GetTextLineHeight();
+        var availableWidth = Math.Max(1f, contentMaxX - lineStartX);
+        var remainingWidth = availableWidth;
+        var firstOnLine = true;
+        var lines = 1;
+
+        foreach (var segment in segments)
+        {
+            if (segment.IsLineBreak)
+            {
+                lines++;
+                firstOnLine = true;
+                remainingWidth = availableWidth;
+                continue;
+            }
+
+            if (segment.IsWhitespace && firstOnLine)
+            {
+                continue;
+            }
+
+            var segmentWidth = segment.IsEmote ? emoteWidth : ImGui.CalcTextSize(segment.Text).X;
+            if (!firstOnLine)
+            {
+                if (segmentWidth > remainingWidth)
+                {
+                    lines++;
+                    firstOnLine = true;
+                    remainingWidth = availableWidth;
+                    if (segment.IsWhitespace)
+                    {
+                        continue;
+                    }
+                }
+            }
+
+            remainingWidth -= segmentWidth;
+            firstOnLine = false;
+        }
+
+        return lines;
+    }
+
+    private float MeasureRolePrefixWidth(string timestampText, bool isOwner, bool isModerator, bool isPinned, float itemSpacing)
+    {
+        var width = 0f;
+
+        if (!string.IsNullOrEmpty(timestampText))
+        {
+            width += ImGui.CalcTextSize(timestampText).X;
+        }
+
+        var hasIcon = false;
+        if (isModerator)
+        {
+            width += MeasureIconWidth(FontAwesomeIcon.UserShield);
+            hasIcon = true;
+        }
+
+        if (isOwner)
+        {
+            if (hasIcon)
+            {
+                width += itemSpacing;
+            }
+
+            width += MeasureIconWidth(FontAwesomeIcon.Crown);
+            hasIcon = true;
+        }
+
+        if (isPinned)
+        {
+            if (hasIcon)
+            {
+                width += itemSpacing;
+            }
+
+            width += MeasureIconWidth(FontAwesomeIcon.Thumbtack);
+            hasIcon = true;
+        }
+
+        if (hasIcon)
+        {
+            width += itemSpacing;
+        }
+
+        return width;
+    }
+
+    private float MeasureIconWidth(FontAwesomeIcon icon)
+    {
+        using var font = _uiSharedService.IconFont.Push();
+        return ImGui.CalcTextSize(icon.ToIconString()).X;
+    }
+
+    private float MeasureSystemEntryHeight(ChatMessageEntry entry)
+    {
+        _ = entry;
+        var spacing = ImGui.GetStyle().ItemSpacing.Y;
+        var lineHeightWithSpacing = ImGui.GetTextLineHeightWithSpacing();
+        var separatorHeight = Math.Max(1f, ImGuiHelpers.GlobalScale);
+
+        var height = spacing;
+        height += lineHeightWithSpacing;
+        height += spacing * 0.35f;
+        height += separatorHeight;
+        height += spacing;
+        return height;
+    }
+
+    private static int LowerBound(float[] values, float target)
+    {
+        var low = 0;
+        var high = values.Length;
+        while (low < high)
+        {
+            var mid = (low + high) / 2;
+            if (values[mid] < target)
+            {
+                low = mid + 1;
+            }
+            else
+            {
+                high = mid;
+            }
+        }
+
+        return low;
+    }
+
+    private static int UpperBound(float[] values, float target)
+    {
+        var low = 0;
+        var high = values.Length;
+        while (low < high)
+        {
+            var mid = (low + high) / 2;
+            if (values[mid] <= target)
+            {
+                low = mid + 1;
+            }
+            else
+            {
+                high = mid;
+            }
+        }
+
+        return low;
     }
 
     private void DrawEmoteTooltip(string name, IDalamudTextureWrap? texture)
@@ -2092,6 +2361,17 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
             ImGui.SetTooltip("When enabled, your notes replace user names in syncshell chat.");
         }
 
+        var enableAnimatedEmotes = chatConfig.EnableAnimatedEmotes;
+        if (ImGui.Checkbox("Enable animated emotes", ref enableAnimatedEmotes))
+        {
+            chatConfig.EnableAnimatedEmotes = enableAnimatedEmotes;
+            _chatConfigService.Save();
+        }
+        if (ImGui.IsItemHovered())
+        {
+            ImGui.SetTooltip("When disabled, emotes render as static images.");
+        }
+
         ImGui.Separator();
         ImGui.TextUnformatted("Chat Visibility");