mage-engine 3.24.1 → 3.24.2

package/dist/mage.js

@@ -55052,14 +55052,36 @@ var Config$1 = new Config();let Universe = /*#__PURE__*/function () {
   }, {
     key: "find",
     value: function find(element) {
-      if (!element) return;
-      let found;
+      if (!element) return; // Traverse up the THREE.js parent chain to find the closest Mage entity.
+      // This ensures that when clicking on a child mesh that's nested inside
+      // a parent entity's body, we find the child entity (not the parent).
+
+      let current = element;
+
+      while (current) {
+        // Check if any entity's body IS this object directly
+        let found;
+        this.forEach(el => {
+          if (!found && el.hasBody() && el.getBody() === current) {
+            found = el;
+          }
+        });
+
+        if (found) {
+          return found;
+        }
+
+        current = current.parent;
+      } // Fallback: use the original has() check for edge cases
+
+
+      let fallback;
       this.forEach(el => {
-        if (el.has(element) && !found) {
-          found = el;
+        if (el.has(element) && !fallback) {
+          fallback = el;
         }
       });
-      return found;
+      return fallback;
     }
   }, {
     key: "getByTag",
@@ -58219,7 +58241,7 @@ function applyMiddleware() {
 
 var thunk = createThunkMiddleware();
 thunk.withExtraArgument = createThunkMiddleware;var name = "mage-engine";
-var version$1 = "3.24.1";
+var version$1 = "3.24.2";
 var description = "A WebGL Javascript Game Engine, built on top of THREE.js and many other libraries.";
 var main = "dist/mage.js";
 var author$1 = {
@@ -61085,6 +61107,67 @@ const tweenTo = function (origin, target) {
     value: function hasChildren() {
       return this.children.length > 0;
     }
+    /**
+     * Checks if the given ancestor is in this entity's parent chain.
+     * Used to prevent circular references when reparenting.
+     * @param {Entity} ancestor - The potential ancestor entity
+     * @returns {boolean} True if ancestor is in the parent chain
+     */
+
+  }, {
+    key: "isDescendantOf",
+    value: function isDescendantOf(ancestor) {
+      if (!ancestor) return false;
+      let current = this.getParent();
+
+      while (current) {
+        if (current === ancestor || current.uuid && ancestor.uuid && current.uuid() === ancestor.uuid()) {
+          return true;
+        }
+
+        current = current.getParent ? current.getParent() : null;
+      }
+
+      return false;
+    }
+    /**
+     * Reparents this entity to a new parent while preserving world position.
+     * Uses THREE.js attach() to maintain the entity's world transform.
+     * @param {Entity|null} newParent - The new parent entity, or null to move to scene root
+     * @returns {Entity} This entity for chaining
+     */
+
+  }, {
+    key: "reparent",
+    value: function reparent(newParent) {
+      if (!this.hasBody()) return this;
+      const oldParent = this.getParent(); // Detach from old parent's Entity children array
+
+      if (oldParent && oldParent.children) {
+        const index = oldParent.children.findIndex(c => c === this || c.uuid && this.uuid && c.uuid() === this.uuid());
+        if (index !== -1) oldParent.children.splice(index, 1);
+      } // Detach from old THREE.js parent
+
+
+      const body = this.getBody();
+
+      if (body.parent) {
+        body.parent.remove(body);
+      }
+
+      if (newParent && newParent.hasBody()) {
+        // Attach to new parent (preserves world position)
+        newParent.children.push(this);
+        this.setParent(newParent);
+        newParent.getBody().attach(body);
+      } else {
+        // Move to scene root
+        this.setParent(false);
+        Scene$1.getScene().attach(body);
+      }
+
+      return this;
+    }
   }, {
     key: "getHierarchy",
     value: function getHierarchy() {
@@ -95434,7 +95517,7 @@ let Sky = /*#__PURE__*/function (_Element) {
         } catch (error) {
           console.error(IMPORTER_ERROR_ELEMENT_CREATION, elementData.name, elementData.entitySubType, error);
         }
-      } // adding children to elements
+      } // adding children to elements (legacy children array format)
 
 
       for (const elementData of elements) {
@@ -95452,6 +95535,21 @@ let Sky = /*#__PURE__*/function (_Element) {
             }
           }
         }
+      } // Handle parentUUID relationships (new format from database parentId)
+      // Use parent.add(child) instead of child.reparent(parent) to preserve
+      // the saved local position. reparent() uses attach() which preserves
+      // world position, but for import we want to keep the saved local position.
+
+
+      for (const elementData of elements) {
+        if (elementData.parentUUID) {
+          const child = Universe$1.getByUUID(elementData.uuid);
+          const parent = Universe$1.getByUUID(elementData.parentUUID);
+
+          if (child && parent && parent.add) {
+            await parent.add(child);
+          }
+        }
       }
 
       lights.forEach(data => {
@@ -95530,7 +95628,54 @@ let Sky = /*#__PURE__*/function (_Element) {
         } catch (error) {
           console.error(IMPORTER_ERROR_PARTICLE_CREATION, data.name, data.preset, error.stack);
         }
-      });
+      }); // Handle parentUUID for lights
+
+      for (const lightData of lights) {
+        if (lightData.parentUUID) {
+          const child = Universe$1.getByUUID(lightData.uuid);
+          const parent = Universe$1.getByUUID(lightData.parentUUID);
+
+          if (child && parent && parent.add) {
+            await parent.add(child);
+          }
+        }
+      } // Handle parentUUID for sounds
+
+
+      for (const soundData of allSounds) {
+        if (soundData.parentUUID) {
+          const child = Universe$1.getByUUID(soundData.uuid);
+          const parent = Universe$1.getByUUID(soundData.parentUUID);
+
+          if (child && parent && parent.add) {
+            await parent.add(child);
+          }
+        }
+      } // Handle parentUUID for particles
+
+
+      for (const particleData of particles) {
+        if (particleData.parentUUID) {
+          const child = Universe$1.getByUUID(particleData.uuid);
+          const parent = Universe$1.getByUUID(particleData.parentUUID);
+
+          if (child && parent && parent.add) {
+            await parent.add(child);
+          }
+        }
+      } // Handle parentUUID for cameras
+
+
+      for (const cameraData of cameras) {
+        if (cameraData.parentUUID) {
+          const child = Universe$1.getByUUID(cameraData.uuid);
+          const parent = Universe$1.getByUUID(cameraData.parentUUID);
+
+          if (child && parent && parent.add) {
+            await parent.add(child);
+          }
+        }
+      }
     }
   }]);
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mage-engine",
-    "version": "3.24.1",
+    "version": "3.24.2",
     "description": "A WebGL Javascript Game Engine, built on top of THREE.js and many other libraries.",
     "main": "dist/mage.js",
     "author": {