Implement XML-driven custom property system for TombEngine moveables and statics

TombEditor/Command.cs

@@ -1210,7 +1210,7 @@ static CommandHandler()
                     return;
                 }
 
-                args.Editor.Action = new EditorActionPlace(false, (r, l) => ItemInstance.FromItemType(currentItem.Value));
+                args.Editor.Action = new EditorActionPlace(false, (level, room) => ItemInstance.FromItemType(level, currentItem.Value));
             });
 
             AddCommand("LocateItem", "Locate item", CommandType.Objects, delegate (CommandArgs args)
@@ -2379,6 +2379,16 @@ static CommandHandler()
                 args.Editor.HighlightedSplit = 9;
             });
 
+            AddCommand("ReloadAllPropertiesFromWad", "Reload all properties from WAD", CommandType.Objects, delegate (CommandArgs args)
+            {
+                EditorActions.ReloadAllPropertiesFromWad(args.Editor, args.Window);
+            });
+
+            AddCommand("ResetAllProperties", "Reset all properties", CommandType.Objects, delegate (CommandArgs args)
+            {
+                EditorActions.ResetAllProperties(args.Editor, args.Window);
+            });
+
             _commands = _commands.OrderBy(o => o.Type).ToList();
         }
     }

TombEditor/Controls/ContextMenus/MaterialObjectContextMenu.cs

@@ -37,7 +37,12 @@ public MaterialObjectContextMenu(Editor editor, IWin32Window owner, ObjectInstan
             { 
                 Items.Add(new ToolStripMenuItem("Edit object", Properties.Resources.general_edit_16, (o, e) =>
                 {
-                    EditorActions.EditObject(targetObject, owner);
+                    // If the target object is part of an ObjectGroup selection, edit the whole group
+                    var objectToEdit = targetObject;
+                    if (_editor.SelectedObject is ObjectGroup group && group.Contains(targetObject as PositionBasedObjectInstance))
+                        objectToEdit = group;
+
+                    EditorActions.EditObject(objectToEdit, owner);
                 }));
             }
 

TombEditor/EditorActions.cs

@@ -32,6 +32,7 @@
 using TombLib.Wad;
 using TombLib.Wad.Catalog;
 using TombLib.WPF;
+using TombEditor.Windows;
 
 namespace TombEditor
 {
@@ -1013,7 +1014,21 @@ public static void RebuildLightsForObject(ObjectInstance instance)
                 instance.Room.RebuildLighting(_editor.Configuration.Rendering3D_HighQualityLightPreview);
         }
 
-        public static DarkForm GetObjectSetupWindow(params object[] args)
+        // Overload for non-TombEngine levels (TR4, NG, etc.) - only needs instance
+        public static DarkForm GetObjectSetupWindow(object instance)
+        {
+            return GetObjectSetupWindow(instance, null);
+        }
+
+        // Specific overload for TriggerInstance with actions
+        public static DarkForm GetObjectSetupWindow(TriggerInstance trigger, Level level, 
+            Action<ObjectInstance> selectObject, Action<Room> selectRoom)
+        {
+            return new FormTrigger(trigger, level, selectObject, selectRoom);
+        }
+
+        // Full implementation with optional Level parameter
+        public static DarkForm GetObjectSetupWindow(object instance, Level level)
         {
             // This function decides on which window version to use based on game version.
             // Right now it is primarily future-proof setup for TEN objects which will feature
@@ -1025,11 +1040,11 @@ public static DarkForm GetObjectSetupWindow(params object[] args)
             // 3. If game version is NOT TEN, always use "TombEditor.Forms" namespace
             // 4. If no window was found in either namespace, throw an exception, since there's no setup window for such object.
 
-            if (!args.Any() || !(args[0] is ObjectInstance))
-                throw new ArgumentException("Object instance was not provided as first argument for this function.");
+            if (!(instance is ObjectInstance))
+                throw new ArgumentException("Object instance was not provided for this function.");
 
             var triedAlternateNamespace = false;
-            var objectName = (args[0] as ObjectInstance).GetType().Name.Replace("Instance", string.Empty);
+            var objectName = (instance as ObjectInstance).GetType().Name.Replace("Instance", string.Empty);
 
             // Additional filter for volume types
             if (objectName.Contains("Volume")) objectName = "Volume";
@@ -1040,10 +1055,24 @@ public static DarkForm GetObjectSetupWindow(params object[] args)
 
             while (true)
             {
-                var formType = Type.GetType("TombEditor.Forms" + (_editor.Level.IsTombEngine && !triedAlternateNamespace ? ".TombEngine" : "") + ".Form" + objectName);
+                var isTombEngine = level != null && level.IsTombEngine;
+                var formType = Type.GetType("TombEditor.Forms" + (isTombEngine && !triedAlternateNamespace ? ".TombEngine" : "") + ".Form" + objectName);
 
                 if (formType != null)
                 {
+                    // Create args array based on whether this is a TombEngine form or non-TombEngine form
+                    object[] args;
+                    if (isTombEngine && !triedAlternateNamespace)
+                    {
+                        // TombEngine forms expect (instance, level)
+                        args = new object[] { instance, level };
+                    }
+                    else
+                    {
+                        // Non-TombEngine forms expect (instance) only
+                        args = new object[] { instance };
+                    }
+
                     var form = Activator.CreateInstance(formType, args);
                     if (form is DarkForm) return (DarkForm)form;
                 }
@@ -1091,13 +1120,45 @@ public static void RenameObject(ObjectInstance instance, IWin32Window owner)
 
         public static void EditObject(ObjectInstance instance, IWin32Window owner)
         {
+            // Handle batch editing for ObjectGroup containing moveables or statics
+            if (instance is ObjectGroup group && _editor.Level.IsTombEngine)
+            {
+                var moveables = group.OfType<MoveableInstance>().ToList();
+                var statics = group.OfType<StaticInstance>().ToList();
+
+                if (moveables.Any() && !statics.Any())
+                {
+                    // Batch edit moveables using unified PropertyEditorWindow
+                    var window = new TombEditor.Windows.PropertyEditorWindow(moveables.Cast<ItemInstance>().ToList(), true, PropertyEditorContext.TombEditor, null, _editor.Level);
+                    if (window.ShowDialog() == true)
+                    {
+                        foreach (var obj in moveables)
+                            _editor.ObjectChange(obj, ObjectChangeType.Change);
+                    }
+                    return;
+                }
+                else if (statics.Any() && !moveables.Any())
+                {
+                    // Batch edit statics using unified PropertyEditorWindow
+                    var window = new TombEditor.Windows.PropertyEditorWindow(statics.Cast<ItemInstance>().ToList(), true, PropertyEditorContext.TombEditor, null, _editor.Level);
+                    if (window.ShowDialog() == true)
+                    {
+                        foreach (var obj in statics)
+                            _editor.ObjectChange(obj, ObjectChangeType.Change);
+                    }
+                    return;
+                }
+            }
+
             if (instance is MoveableInstance)
             {
                 if (instance.CanBeColored() && Control.ModifierKeys.HasFlag(Keys.Control))
                     EditColor(owner, (MoveableInstance)instance);
                 else
                 {
-                    using (var formMoveable = GetObjectSetupWindow((MoveableInstance)instance))
+                    using (var formMoveable = _editor.Level.IsTombEngine
+                        ? GetObjectSetupWindow((MoveableInstance)instance, _editor.Level)
+                        : GetObjectSetupWindow((MoveableInstance)instance))
                         if (formMoveable.ShowDialog(owner) != DialogResult.OK)
                             return;
                 }
@@ -1106,14 +1167,16 @@ public static void EditObject(ObjectInstance instance, IWin32Window owner)
             }
             else if (instance is StaticInstance)
             {
-                // Use static editing dialog only for NG levels for now (bypass it if Ctrl/Alt key is pressed)
-                if (instance.CanBeColored() && (!_editor.Level.IsNG || Control.ModifierKeys.HasFlag(Keys.Control)))
+                // Use static editing dialog for NG and TombEngine levels (bypass it if Ctrl key is pressed)
+                if (instance.CanBeColored() && ((!_editor.Level.IsNG && !_editor.Level.IsTombEngine) || Control.ModifierKeys.HasFlag(Keys.Control)))
                 {
                     EditColor(owner, (StaticInstance)instance);
                 }
-                else if (_editor.Level.IsNG)
+                else if (_editor.Level.IsNG || _editor.Level.IsTombEngine)
                 {
-                    using (var formStaticMesh = GetObjectSetupWindow((StaticInstance)instance))
+                    using (var formStaticMesh = _editor.Level.IsTombEngine
+                        ? GetObjectSetupWindow((StaticInstance)instance, _editor.Level)
+                        : GetObjectSetupWindow((StaticInstance)instance))
                         if (formStaticMesh.ShowDialog(owner) != DialogResult.OK)
                             return;
                 }
@@ -5942,5 +6005,126 @@ public static void ConvertAreaToQuads(Room room, RectangleInt2 area, SectorVerti
             if (success)
                 SmartBuildGeometry(room, area);
         }
+
+        public static void ReloadAllPropertiesFromWad(Editor editor, IWin32Window owner)
+        {
+            if (editor?.Level == null || !editor.Level.IsTombEngine)
+            {
+                editor.SendMessage("This feature is only available for Tomb Engine levels.", PopupType.Warning);
+                return;
+            }
+
+            int updatedCount = 0;
+            var level = editor.Level;
+
+            // Reload properties for all moveables
+            foreach (var room in level.Rooms.Where(r => r != null))
+            {
+                foreach (var obj in room.Objects.OfType<MoveableInstance>())
+                {
+                    var wadMoveable = level.Settings?.WadTryGetMoveable(obj.WadObjectId);
+                    if (wadMoveable?.CustomProperties != null && wadMoveable.CustomProperties.GetAll().Count > 0)
+                    {
+                        // Clear existing properties
+                        obj.CustomProperties = new TombLib.LevelData.Properties.PropertyCollection();
+
+                        // Copy from WAD
+                        foreach (var kvp in wadMoveable.CustomProperties.GetAll())
+                        {
+                            obj.CustomProperties.SetProperty(kvp.Key, kvp.Value);
+                        }
+
+                        updatedCount++;
+                        editor.ObjectChange(obj, ObjectChangeType.Change);
+                    }
+                }
+
+                // Reload properties for all statics
+                foreach (var obj in room.Objects.OfType<StaticInstance>())
+                {
+                    var wadStatic = level.Settings?.WadTryGetStatic(obj.WadObjectId);
+                    if (wadStatic?.CustomProperties != null && wadStatic.CustomProperties.GetAll().Count > 0)
+                    {
+                        // Clear existing properties
+                        obj.CustomProperties = new TombLib.LevelData.Properties.PropertyCollection();
+
+                        // Copy from WAD
+                        foreach (var kvp in wadStatic.CustomProperties.GetAll())
+                        {
+                            obj.CustomProperties.SetProperty(kvp.Key, kvp.Value);
+                        }
+
+                        updatedCount++;
+                        editor.ObjectChange(obj, ObjectChangeType.Change);
+                    }
+                }
+            }
+
+            if (updatedCount > 0)
+            {
+                editor.SendMessage($"Reloaded properties from WAD for {updatedCount} objects.", PopupType.Info);
+            }
+            else
+            {
+                editor.SendMessage("No objects with WAD properties found to reload.", PopupType.Info);
+            }
+        }
+
+        public static void ResetAllProperties(Editor editor, IWin32Window owner)
+        {
+            if (editor?.Level == null || !editor.Level.IsTombEngine)
+            {
+                editor.SendMessage("This feature is only available for Tomb Engine levels.", PopupType.Warning);
+                return;
+            }
+
+            if (DarkMessageBox.Show(owner, 
+                "This will clear all custom properties from all objects in the level.\n\n" +
+                "Objects will revert to default properties from XML files or WAD.\n\n" +
+                "This action cannot be undone. Continue?",
+                "Reset All Properties",
+                MessageBoxButtons.YesNo,
+                MessageBoxIcon.Warning) != DialogResult.Yes)
+            {
+                return;
+            }
+
+            int clearedCount = 0;
+            var level = editor.Level;
+
+            // Clear properties for all moveables
+            foreach (var room in level.Rooms.Where(r => r != null))
+            {
+                foreach (var obj in room.Objects.OfType<MoveableInstance>())
+                {
+                    if (obj.CustomProperties.GetAll().Count > 0)
+                    {
+                        obj.CustomProperties = new TombLib.LevelData.Properties.PropertyCollection();
+                        clearedCount++;
+                        editor.ObjectChange(obj, ObjectChangeType.Change);
+                    }
+                }
+
+                // Clear properties for all statics
+                foreach (var obj in room.Objects.OfType<StaticInstance>())
+                {
+                    if (obj.CustomProperties.GetAll().Count > 0)
+                    {
+                        obj.CustomProperties = new TombLib.LevelData.Properties.PropertyCollection();
+                        clearedCount++;
+                        editor.ObjectChange(obj, ObjectChangeType.Change);
+                    }
+                }
+            }
+
+            if (clearedCount > 0)
+            {
+                editor.SendMessage($"Cleared properties for {clearedCount} objects.", PopupType.Info);
+            }
+            else
+            {
+                editor.SendMessage("No objects with custom properties found.", PopupType.Info);
+            }
+        }
     }
 }