Indicate nodes not supported by current event

TombEditor/Controls/TriggerManager.cs

@@ -24,6 +24,13 @@ public TriggerManager()
             InitializeComponent();
         }
 
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+        public EventType EventType
+        {
+            get { return nodeEditor.CurrentEventType; }
+            set { nodeEditor.CurrentEventType = value; }
+        }
+
         [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
         public Event Event
         {

TombEditor/Forms/FormEventSetEditor.cs

@@ -429,6 +429,7 @@ private void LoadEventSetIntoUI(EventSet newEventSet)
             }
 
             cbEvents.SelectedItem = newEventSet.LastUsedEvent;
+            triggerManager.EventType = newEventSet.LastUsedEvent;
             triggerManager.Event = newEventSet.Events[newEventSet.LastUsedEvent];
 
             tbName.Text = newEventSet.Name;
@@ -646,6 +647,7 @@ private void cbEvents_SelectedIndexChanged(object sender, EventArgs e)
             if (!_lockUI)
             {
                 SelectedSet.LastUsedEvent = (EventType)cbEvents.SelectedItem;
+                triggerManager.EventType = SelectedSet.LastUsedEvent;
                 triggerManager.Event = SelectedSet.Events[SelectedSet.LastUsedEvent];
             }
         }

TombLib/TombLib.Forms/Controls/VisualScripting/NodeEditor.cs

@@ -25,6 +25,10 @@ public enum ConnectionMode
 
     public partial class NodeEditor : UserControl
     {
+        [Browsable(false)]
+        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+        public EventType CurrentEventType { get; set; }
+
         [Browsable(false)]
         [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
         public Vector2 ViewPosition { get; set; } = new Vector2(60.0f, 60.0f);
@@ -885,20 +889,50 @@ private void DrawShadow(PaintEventArgs e, VisibleNodeBase node)
             e.Graphics.DrawImage(Properties.Resources.misc_Shadow, rect);
         }
 
+        private bool IsNodeUnsupported(TriggerNode node)
+        {
+            if (string.IsNullOrEmpty(node.Function))
+                return false;
+
+            var func = NodeFunctions.FirstOrDefault(f => f.Signature == node.Function);
+            if (func == null)
+                return false;
+
+            return func.IsUnsupported(CurrentEventType);
+        }
+
         private void DrawHeader(PaintEventArgs e, VisibleNodeBase node)
         {
             if (!node.Visible)
                 return;
 
-            var size = TextRenderer.MeasureText(node.Node.Name, Font);
+            const float LabelOpacity = 0.5f;
+
+            bool unsupported = IsNodeUnsupported(node.Node);
+            var headerText = unsupported ? "Not supported for this event type" : node.Node.Name;
+            int iconOffset = 0;
+            var size = TextRenderer.MeasureText(headerText, Font);
 
             var rect = node.ClientRectangle;
             rect.Height = size.Height;
             rect.Offset(node.Location);
             rect.Offset(0, -(int)(size.Height * 1.2f));
 
-            using (var b = new SolidBrush(Colors.LightText.ToFloat3Color().ToWinFormsColor(0.5f)))
-                e.Graphics.DrawString(node.Node.Name, Font, b, rect,
+            if (unsupported)
+            {
+                var matrix = new System.Drawing.Imaging.ColorMatrix { Matrix33 = LabelOpacity, Matrix22 = 0.0f };
+                var attributes = new System.Drawing.Imaging.ImageAttributes();
+                attributes.SetColorMatrix(matrix, System.Drawing.Imaging.ColorMatrixFlag.Default, System.Drawing.Imaging.ColorAdjustType.Bitmap);
+
+                var icon = Properties.Resources.general_Warning_16;
+                var iconRect = new Rectangle(rect.X, rect.Y + (rect.Height - icon.Height), icon.Width, icon.Height);
+                e.Graphics.DrawImage(icon, iconRect, 0, 0, icon.Width, icon.Height, GraphicsUnit.Pixel, attributes);
+                iconOffset = icon.Width + 2;
+            }
+
+            var textRect = new Rectangle(rect.X + iconOffset, rect.Y, rect.Width - iconOffset, rect.Height);
+            using (var b = new SolidBrush(Colors.LightText.ToFloat3Color().ToWinFormsColor(LabelOpacity)))
+                e.Graphics.DrawString(headerText, Font, b, textRect,
                         new StringFormat { Alignment = StringAlignment.Near, LineAlignment = StringAlignment.Center });
 
             var condNode = node as VisibleNodeCondition;

TombLib/TombLib/Catalogs/TEN Node Catalogs/Readme.md

@@ -40,6 +40,14 @@ Comment metadata entry reference (metadata block is indicated by a keyword which
    new line.
 
  - **!Section "SECTION"** - this will define where the node will be found inside Tomb Editor.
+
+ - **!Supported "TYPE" "TYPE" "..." - defines supported event types for a given node. Each event type should be
+   enclosed in quotes. If event is not supported by a node, it will display a warning message when misplaced.
+   Possible event types are: **OnVolumeEnter, OnVolumeInside, OnVolumeLeave, OnLoop, OnLoadGame, OnSaveGame, 
+   OnLevelStart, OnLevelEnd, OnUseItem, OnFreeze**.
+
+ - **!Unsupported "TYPE" "TYPE" "..." - defines unsupported event types for a given node. Acts in an opposite way
+   to `!Supported`. Possible event types are equal to `!Supported`.
 
  - **!Arguments "ARGDESC1" "ARGDESC2" "ARGDESC..."** - infinite amount of args, with **ARGDESC** parameters
    separated by commas as follows:

TombLib/TombLib/LevelData/VisualScripting/TriggerNodeEnumerations.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using TombLib.LevelData;
 
 namespace TombLib.LevelData.VisualScripting
 {
@@ -78,6 +79,19 @@ public class NodeFunction
         public bool Conditional { get; set; }
         public string Signature { get; set; }
         public List<ArgumentLayout> Arguments { get; private set; } = new List<ArgumentLayout>();
+        public List<EventType> SupportedEvents { get; private set; } = new List<EventType>();
+        public List<EventType> UnsupportedEvents { get; private set; } = new List<EventType>();
+
+        public bool IsUnsupported(EventType eventType)
+        {
+            if (SupportedEvents.Count > 0 && !SupportedEvents.Contains(eventType))
+                return true;
+
+            if (UnsupportedEvents.Count > 0 && UnsupportedEvents.Contains(eventType))
+                return true;
+
+            return false;
+        }
 
         public override string ToString() => Name;
         public override int GetHashCode() => (Name + Conditional.ToString() + Description + Signature + Arguments.Count.ToString()).GetHashCode();

TombLib/TombLib/Utils/ScriptingUtils.cs

@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using TombLib.LevelData;
 using TombLib.LevelData.VisualScripting;
 
 namespace TombLib.Utils
@@ -59,6 +60,8 @@ public static class ScriptingUtils
         private const string _nodeTypeId = _metadataPrefix + "condition";
         private const string _nodeArgumentId = _metadataPrefix + "arguments";
         private const string _nodeDescriptionId = _metadataPrefix + "description";
+        private const string _nodeSupportedId = _metadataPrefix + "supported";
+        private const string _nodeUnsupportedId = _metadataPrefix + "unsupported";
         private const string _nodeLayoutNewLine = "newline";
 
         public static string GameNodeScriptPath = Path.Combine("Scripts", "Engine", "NodeCatalogs");
@@ -156,6 +159,16 @@ private static List<NodeFunction> GetAllNodeFunctions(string path, List<NodeFunc
                             }
                             continue;
                         }
+                        else if (comment.StartsWith(_nodeSupportedId, StringComparison.InvariantCultureIgnoreCase))
+                        {
+                            ParseEventTypeList(comment, _nodeSupportedId, nodeFunction.SupportedEvents);
+                            continue;
+                        }
+                        else if (comment.StartsWith(_nodeUnsupportedId, StringComparison.InvariantCultureIgnoreCase))
+                        {
+                            ParseEventTypeList(comment, _nodeUnsupportedId, nodeFunction.UnsupportedEvents);
+                            continue;
+                        }
                     }
 
                     if (cPoint > 0)
@@ -257,6 +270,16 @@ private static List<NodeFunction> GetAllNodeFunctions(string path, List<NodeFunc
             return result.OrderBy(n => n.Section).ToList();
         }
 
+        private static void ParseEventTypeList(string comment, string tagId, List<EventType> targetList)
+        {
+            var values = TextExtensions.ExtractValues(comment.Substring(tagId.Length, comment.Length - tagId.Length));
+            foreach (var v in values)
+            {
+                if (Enum.TryParse(v.Trim(), out EventType eventType))
+                    targetList.Add(eventType);
+            }
+        }
+
         public static List<string> GetAllFunctionNames(string path, List<string> list = null, int depth = 0)
         {
             var result = list == null ? new List<string>() : list;