onchatmessage filters

Jaksuhn · Jaksuhn · commit 73d8abb60841 · 2026-01-18T15:20:07.000Z
diff --git a/SomethingNeedDoing/Core/MacroMetadata.cs b/SomethingNeedDoing/Core/MacroMetadata.cs
@@ -1,4 +1,5 @@
 ﻿using Dalamud.Game.Addon.Lifecycle;
+using Dalamud.Game.Text;
 using SomethingNeedDoing.Core.Interfaces;
 
 namespace SomethingNeedDoing.Core;
@@ -73,6 +74,17 @@ public class MacroMetadata
     /// Gets or sets the macro dependencies.
     /// </summary>
     public List<IMacroDependency> Dependencies { get; set; } = [];
+
+    /// <summary>
+    /// Gets or sets the chat message filter configuration for macro-level OnChatMessage triggers.
+    /// </summary>
+    public ChatMessageFilterConfig? ChatMessageFilter { get; set; }
+
+    /// <summary>
+    /// Gets or sets chat message filter configurations for function-level triggers.
+    /// Key is the function name (e.g., "OnChatMessage"), value is the filter configuration.
+    /// </summary>
+    public Dictionary<string, ChatMessageFilterConfig> FunctionChatFilters { get; set; } = [];
 }
 
 /// <summary>
@@ -90,3 +102,29 @@ public class AddonEventConfig
     /// </summary>
     public AddonEvent EventType { get; set; } = AddonEvent.PostSetup;
 }
+
+/// <summary>
+/// Configuration for filtering chat messages.
+/// </summary>
+public class ChatMessageFilterConfig
+{
+    /// <summary>
+    /// Gets or sets the chat channels to filter by. If null or empty, all channels are allowed.
+    /// </summary>
+    public List<XivChatType>? Channels { get; set; }
+
+    /// <summary>
+    /// Gets or sets a string that the message must contain. If null or empty, no message content filter is applied.
+    /// </summary>
+    public string? MessageContains { get; set; }
+
+    /// <summary>
+    /// Gets or sets a string that the sender must contain. If null or empty, no sender filter is applied.
+    /// </summary>
+    public string? SenderContains { get; set; }
+
+    /// <summary>
+    /// Gets or sets a regex pattern that the message must match. If null or empty, no regex filter is applied.
+    /// </summary>
+    public string? MessageRegex { get; set; }
+}
diff --git a/SomethingNeedDoing/Core/MetadataParser.cs b/SomethingNeedDoing/Core/MetadataParser.cs
@@ -1,4 +1,5 @@
 using Dalamud.Game.Addon.Lifecycle;
+using Dalamud.Game.Text;
 using SomethingNeedDoing.Core.Interfaces;
 using System.Text.RegularExpressions;
 using YamlDotNet.Serialization;
@@ -92,6 +93,21 @@ public MacroMetadata ParseMetadata(string content, MacroMetadata? previousMetada
                         metadata.AddonEventConfig.EventType = parsedEventType;
             }
 
+            if (yaml.TryGetValue("chat_message_filter", out var chatFilter) && chatFilter is Dictionary<object, object> chatFilterDict)
+                metadata.ChatMessageFilter = ParseChatMessageFilter(chatFilterDict);
+
+            if (yaml.TryGetValue("function_chat_filters", out var functionChatFilters) && functionChatFilters is Dictionary<object, object> functionFiltersDict)
+            {
+                foreach (var kvp in functionFiltersDict)
+                {
+                    var functionName = kvp.Key?.ToString();
+                    if (string.IsNullOrEmpty(functionName)) continue;
+
+                    if (kvp.Value is Dictionary<object, object> filterDict)
+                        metadata.FunctionChatFilters[functionName] = ParseChatMessageFilter(filterDict);
+                }
+            }
+
             if (yaml.TryGetValue("dependencies", out var dependencies))
                 metadata.Dependencies = ParseDependencies(dependencies);
 
@@ -156,6 +172,17 @@ public bool WriteMetadata(ConfigMacro macro, Action? onContentUpdated = null)
             };
         }
 
+        if (macro.Metadata.ChatMessageFilter != null)
+            metadataDict["chat_message_filter"] = SerializeChatMessageFilter(macro.Metadata.ChatMessageFilter);
+
+        if (macro.Metadata.FunctionChatFilters.Any())
+        {
+            metadataDict["function_chat_filters"] = macro.Metadata.FunctionChatFilters.ToDictionary(
+                kvp => kvp.Key,
+                kvp => SerializeChatMessageFilter(kvp.Value)
+            );
+        }
+
         if (macro.Metadata.Dependencies.Any())
         {
             metadataDict["dependencies"] = macro.Metadata.Dependencies.Select(dep => new Dictionary<string, object>
@@ -389,4 +416,50 @@ private static Type InferTypeFromValue(object? value)
 
         return typeof(string);
     }
+
+    private static ChatMessageFilterConfig ParseChatMessageFilter(Dictionary<object, object> filterDict)
+    {
+        var filter = new ChatMessageFilterConfig();
+
+        if (filterDict.TryGetValue("channels", out var channels))
+        {
+            if (channels is List<object> channelList)
+            {
+                filter.Channels = [];
+                foreach (var channel in channelList)
+                    if (Enum.TryParse<XivChatType>(channel?.ToString(), true, out var chatType))
+                        filter.Channels.Add(chatType);
+            }
+        }
+
+        if (filterDict.TryGetValue("message_contains", out var messageContains))
+            filter.MessageContains = messageContains?.ToString();
+
+        if (filterDict.TryGetValue("sender_contains", out var senderContains))
+            filter.SenderContains = senderContains?.ToString();
+
+        if (filterDict.TryGetValue("message_regex", out var messageRegex))
+            filter.MessageRegex = messageRegex?.ToString();
+
+        return filter;
+    }
+
+    private static Dictionary<string, object> SerializeChatMessageFilter(ChatMessageFilterConfig filter)
+    {
+        var dict = new Dictionary<string, object>();
+
+        if (filter.Channels != null && filter.Channels.Count > 0)
+            dict["channels"] = filter.Channels.Select(c => c.ToString().ToLower()).ToList();
+
+        if (!string.IsNullOrEmpty(filter.MessageContains))
+            dict["message_contains"] = filter.MessageContains;
+
+        if (!string.IsNullOrEmpty(filter.SenderContains))
+            dict["sender_contains"] = filter.SenderContains;
+
+        if (!string.IsNullOrEmpty(filter.MessageRegex))
+            dict["message_regex"] = filter.MessageRegex;
+
+        return dict;
+    }
 }
diff --git a/SomethingNeedDoing/External/AllaganTools.cs b/SomethingNeedDoing/External/AllaganTools.cs
@@ -1,5 +1,4 @@
 ﻿using ECommons.EzIpcManager;
-using FFXIVClientStructs.FFXIV.Client.Game;
 using SomethingNeedDoing.Core.Interfaces;
 
 namespace SomethingNeedDoing.External;
diff --git a/SomethingNeedDoing/Globals.cs b/SomethingNeedDoing/Globals.cs
@@ -2,7 +2,6 @@
 global using Dalamud.Game.ClientState.Conditions;
 global using ECommons.DalamudServices;
 global using ECommons.GameFunctions;
-global using ECommons.GameHelpers;
 global using SomethingNeedDoing.Attributes;
 global using SomethingNeedDoing.Core;
 global using SomethingNeedDoing.Core.Exceptions;
diff --git a/SomethingNeedDoing/Gui/ChangelogWindow.cs b/SomethingNeedDoing/Gui/ChangelogWindow.cs
@@ -82,6 +82,7 @@ private void AddGeneralChangelogs()
         Add("13.41", "Fixed how some lists were handled in the configs, as well as string representations of other types");
         Add("13.51", "Fixed ipc enums not being registered");
         Add("13.59", "Added option to auto show status window on script start. Also fixed the carets not showing in the help menu for Axis fonts.");
+        Add("14.02", "Added OnChatMessage metadata filters so it's actually usable. See the wiki for usage.");
     }
 
     private void Add(string version, string description)
diff --git a/SomethingNeedDoing/LuaMacro/NLuaMacroEngine.cs b/SomethingNeedDoing/LuaMacro/NLuaMacroEngine.cs
@@ -4,7 +4,6 @@
 using SomethingNeedDoing.LuaMacro.Modules;
 using SomethingNeedDoing.LuaMacro.Modules.Engines;
 using SomethingNeedDoing.Managers;
-using SomethingNeedDoing.NativeMacro;
 using System.Collections.Concurrent;
 using System.Text;
 using System.Threading;
diff --git a/SomethingNeedDoing/Managers/MacroScheduler.cs b/SomethingNeedDoing/Managers/MacroScheduler.cs
@@ -39,6 +39,7 @@ public class MacroScheduler : IMacroScheduler, IDisposable
     private readonly TriggerEventManager _triggerEventManager;
     private readonly MacroHierarchyManager _hierarchyManager;
     private readonly WindowSystem _windowSystem;
+    private readonly Core.MetadataParser _metadataParser;
 
     private readonly HashSet<string> _functionTriggersRegistered = [];
 
@@ -54,7 +55,7 @@ public class MacroScheduler : IMacroScheduler, IDisposable
     [Signature("48 89 5C 24 ?? 48 89 6C 24 ?? 48 89 74 24 ?? 48 89 7C 24 ?? 41 56 48 83 EC 30 4C 8B 74 24 ?? 48 8B D9", DetourName = nameof(OnEmoteFuncDetour))]
     private readonly Hook<OnEmoteFuncDelegate> OnEmoteFuncHook = null!;
 
-    public MacroScheduler(NativeMacroEngine nativeEngine, NLuaMacroEngine luaEngine, TriggerEventManager triggerEventManager, MacroHierarchyManager hierarchyManager, WindowSystem windowSystem, IEnumerable<IDisableable> disableablePlugins)
+    public MacroScheduler(NativeMacroEngine nativeEngine, NLuaMacroEngine luaEngine, TriggerEventManager triggerEventManager, MacroHierarchyManager hierarchyManager, WindowSystem windowSystem, Core.MetadataParser metadataParser, IEnumerable<IDisableable> disableablePlugins)
     {
         Svc.Hook.InitializeFromAttributes(this);
         OnEmoteFuncHook?.Enable();
@@ -64,6 +65,7 @@ public MacroScheduler(NativeMacroEngine nativeEngine, NLuaMacroEngine luaEngine,
         _triggerEventManager = triggerEventManager;
         _hierarchyManager = hierarchyManager;
         _windowSystem = windowSystem;
+        _metadataParser = metadataParser;
 
         _nativeEngine.MacroError += OnEngineError;
         _luaEngine.MacroError += OnEngineError;
@@ -690,6 +692,13 @@ private void SubscribeToTriggerEvents()
     {
         foreach (var macro in C.Macros)
         {
+            // Parse metadata from content to ensure filters and triggers are loaded
+            if (macro is ConfigMacro configMacro)
+            {
+                var parsedMetadata = _metadataParser.ParseMetadata(configMacro.Content, configMacro.Metadata);
+                configMacro.Metadata = parsedMetadata;
+            }
+
             foreach (var triggerEvent in macro.Metadata.TriggerEvents)
                 SubscribeToTriggerEvent(macro, triggerEvent);
 
diff --git a/SomethingNeedDoing/Managers/TriggerEventManager.cs b/SomethingNeedDoing/Managers/TriggerEventManager.cs
@@ -1,5 +1,7 @@
+using Dalamud.Game.Text;
 using SomethingNeedDoing.Core.Events;
 using SomethingNeedDoing.Core.Interfaces;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 
 namespace SomethingNeedDoing.Managers;
@@ -13,7 +15,8 @@ namespace SomethingNeedDoing.Managers;
 /// <param name="macro">The macro containing the function.</param>
 /// <param name="functionName">The name of the function.</param>
 /// <param name="eventType">The trigger event this function handles.</param>
-public class TriggerFunction(IMacro macro, string functionName, TriggerEvent eventType)
+/// <param name="chatMessageFilter">Optional chat message filter configuration.</param>
+public class TriggerFunction(IMacro macro, string functionName, TriggerEvent eventType, ChatMessageFilterConfig? chatMessageFilter = null)
 {
     /// <summary>
     /// Gets the macro containing this function.
@@ -44,6 +47,11 @@ public class TriggerFunction(IMacro macro, string functionName, TriggerEvent eve
         ? functionName.Split('_')[2]
         : null;
 
+    /// <summary>
+    /// Gets the chat message filter configuration for OnChatMessage triggers.
+    /// </summary>
+    public ChatMessageFilterConfig? ChatMessageFilter { get; } = chatMessageFilter;
+
     /// <inheritdoc/>
     public override bool Equals(object? obj)
         => obj is TriggerFunction other && Macro.Id == other.Macro.Id && FunctionName == other.FunctionName;
@@ -79,7 +87,11 @@ public void RegisterTrigger(IMacro macro, TriggerEvent eventType)
         if (!EventHandlers.ContainsKey(eventType))
             EventHandlers[eventType] = [];
 
-        var triggerFunction = new TriggerFunction(macro, string.Empty, eventType);
+        ChatMessageFilterConfig? chatFilter = null;
+        if (eventType == TriggerEvent.OnChatMessage && macro.Metadata.ChatMessageFilter != null)
+            chatFilter = macro.Metadata.ChatMessageFilter;
+
+        var triggerFunction = new TriggerFunction(macro, string.Empty, eventType, chatFilter);
         if (!EventHandlers[eventType].Contains(triggerFunction))
             EventHandlers[eventType].Add(triggerFunction);
     }
@@ -122,7 +134,11 @@ public void RegisterFunctionTrigger(IMacro macro, string functionName)
                 if (!EventHandlers.ContainsKey(eventType))
                     EventHandlers[eventType] = [];
 
-                var triggerFunction = new TriggerFunction(macro, functionName, eventType);
+                ChatMessageFilterConfig? chatFilter = null;
+                if (eventType == TriggerEvent.OnChatMessage && macro.Metadata.FunctionChatFilters.TryGetValue(functionName, out var filter))
+                    chatFilter = filter;
+
+                var triggerFunction = new TriggerFunction(macro, functionName, eventType, chatFilter);
                 if (EventHandlers[eventType].Contains(triggerFunction))
                 {
                     FrameworkLogger.Debug($"Function trigger already registered for macro {macro.Name} function {functionName} event {eventType}");
@@ -222,6 +238,11 @@ public async Task RaiseTriggerEvent(TriggerEvent eventType, object? data = null)
                         continue;
                 }
 
+                // For OnChatMessage, check if the message matches the filter
+                if (eventType == TriggerEvent.OnChatMessage && data is Dictionary<string, object> chatData)
+                    if (!MatchesChatMessageFilter(chatData, triggerFunction.ChatMessageFilter))
+                        continue;
+
                 if (string.IsNullOrEmpty(triggerFunction.FunctionName))
                 {
                     // Macro-level trigger: raise the event for the entire macro
@@ -248,6 +269,72 @@ public async Task RaiseTriggerEvent(TriggerEvent eventType, object? data = null)
         }
     }
 
+    /// <summary>
+    /// Checks if a chat message matches the given filter configuration.
+    /// </summary>
+    /// <param name="chatData">The chat message data dictionary.</param>
+    /// <param name="filter">The filter configuration to check against.</param>
+    /// <returns>True if the message matches the filter (or if no filter is specified), false otherwise.</returns>
+    private static bool MatchesChatMessageFilter(Dictionary<string, object> chatData, ChatMessageFilterConfig? filter)
+    {
+        if (filter == null)
+            return true;
+
+        if (filter.Channels != null && filter.Channels.Count > 0)
+        {
+            if (chatData.TryGetValue("type", out var typeObj) && typeObj is XivChatType chatType)
+            {
+                if (!filter.Channels.Contains(chatType))
+                    return false;
+            }
+            else
+                return false;
+        }
+
+        if (!string.IsNullOrEmpty(filter.MessageContains))
+        {
+            if (chatData.TryGetValue("message", out var messageObj) && messageObj is string message)
+            {
+                if (!message.Contains(filter.MessageContains, StringComparison.OrdinalIgnoreCase))
+                    return false;
+            }
+            else
+                return false;
+        }
+
+        if (!string.IsNullOrEmpty(filter.SenderContains))
+        {
+            if (chatData.TryGetValue("sender", out var senderObj) && senderObj is string sender)
+            {
+                if (!sender.Contains(filter.SenderContains, StringComparison.OrdinalIgnoreCase))
+                    return false;
+            }
+            else
+                return false;
+        }
+
+        if (!string.IsNullOrEmpty(filter.MessageRegex))
+        {
+            if (chatData.TryGetValue("message", out var messageObj) && messageObj is string message)
+            {
+                try
+                {
+                    if (!Regex.IsMatch(message, filter.MessageRegex, RegexOptions.IgnoreCase))
+                        return false;
+                }
+                catch (ArgumentException)
+                {
+                    FrameworkLogger.Warning($"Invalid regex pattern in chat message filter: {filter.MessageRegex}");
+                    return false;
+                }
+            }
+            else
+                return false;
+        }
+
+        return true;
+    }
+
     /// <summary>
     /// Disposes of the trigger event manager.
     /// </summary>

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`	`1`	`using ECommons.EzIpcManager;`
`2`		`-using FFXIVClientStructs.FFXIV.Client.Game;`
`3`	`2`	`using SomethingNeedDoing.Core.Interfaces;`
`4`	`3`
`5`	`4`	`namespace SomethingNeedDoing.External;`
Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,7 @@ private void AddGeneralChangelogs()`
`82`	`82`	`Add("13.41", "Fixed how some lists were handled in the configs, as well as string representations of other types");`
`83`	`83`	`Add("13.51", "Fixed ipc enums not being registered");`
`84`	`84`	`Add("13.59", "Added option to auto show status window on script start. Also fixed the carets not showing in the help menu for Axis fonts.");`
	`85`	`+ Add("14.02", "Added OnChatMessage metadata filters so it's actually usable. See the wiki for usage.");`
`85`	`86`	`}`
`86`	`87`
`87`	`88`	`private void Add(string version, string description)`