WIP

js/entity/BlueprintEntity.js

@@ -6,6 +6,7 @@ export default class BlueprintEntity extends ObjectEntity {
 
     /** @type {Map<String, Number>} */
     #objectEntitiesNameCounter = new Map()
+    #variableNames = new Set()
 
     /** @type {ObjectEntity[]}" */
     #objectEntities = []
@@ -13,6 +14,11 @@ export default class BlueprintEntity extends ObjectEntity {
         return this.#objectEntities
     }
 
+    static attributes = {
+        ...super.attributes,
+        ScriptVariables: super.attributes.ScriptVariables.asUniqueClass(true).withDefault(),
+    }
+
     /** @param {ObjectEntity} entity */
     getHomonymObjectEntity(entity) {
         const name = entity.getObjectName()
@@ -54,35 +60,90 @@ export default class BlueprintEntity extends ObjectEntity {
         return false
     }
 
+    /**
+     * @param {ObjectReferenceEntity} variable
+     * @param {IEntity} entity
+     */
+    renameScriptVariable(variable, entity) {
+        const name = variable.getName()
+        const newName = this.takeFreeName(name)
+        {
+            [true, false].forEach(v => {
+                /** @type {ObjectEntity} */
+                let object = this[Configuration.subObjectAttributeNameFromReference(variable, v)]
+                object.Name.value = newName
+                object.Name = object.Name
+            })
+        }
+        variable.path.replace(name, newName)
+    }
+
     /** @param {ObjectEntity} entity */
     mergeWith(entity) {
-        if (!entity.ScriptVariables || entity.ScriptVariables.length === 0) {
+        if ((entity.ScriptVariables?.length ?? 0) === 0) {
+            // The entity does not add new variables
             return this
         }
-        if (!this.ScriptVariables || this.ScriptVariables.length === 0) {
-            this.ScriptVariables = entity.ScriptVariables
-        }
         let scriptVariables = Utility.mergeArrays(
             this.ScriptVariables.valueOf(),
             entity.ScriptVariables.valueOf(),
-            (l, r) => l.OriginalChangeId.value == r.OriginalChangeId.value
+            (l, r) => l.OriginalChangeId.value == r.OriginalChangeId.value,
+            added => {
+                const name = added.ScriptVariable.getName()
+                if (this.#variableNames.has(name)) {
+                    this.renameScriptVariable(added.ScriptVariable, entity)
+                }
+            }
         )
         if (scriptVariables.length === this.ScriptVariables.length) {
+            // The entity does not add new variables
             return this
         }
+        scriptVariables.reverse()
         const entries = scriptVariables.concat(scriptVariables).map((v, i) => {
-            const name = Configuration.subObjectAttributeNameFromReference(v.ScriptVariable, i >= scriptVariables.length)
-            return [
-                name,
-                this[name] ?? entity[name]
-            ]
-        })
+            const name = Configuration.subObjectAttributeNameFromReference(
+                v.ScriptVariable,
+                i >= scriptVariables.length // First take all the small objects then all name only
+            )
+            const object = this[name] ?? entity[name]
+            return object ? [name, object] : null
+        }).filter(v => v)
         entries.push(
             ...Object.entries(this).filter(([k, v]) =>
                 !k.startsWith(Configuration.subObjectAttributeNamePrefix)
                 && k !== "ExportedNodes"
-            )
+            ),
+            ["ScriptVariables", new (BlueprintEntity.attributes.ScriptVariables)(scriptVariables.reverse())]
         )
         return new BlueprintEntity(Object.fromEntries(entries))
     }
+
+    /** @param {ObjectEntity[]} entities */
+    getVariablesAttributesReferringTo(...entities) {
+        let pins = new Set(...entities.flatMap(entity => entity.getPinEntities()).map(pin => pin.PinName.toString()))
+        let attributes = this.ScriptVariables
+            .valueOf()
+            .map(v => {
+                const keySimple = Configuration.subObjectAttributeNameFromReference(v.ScriptVariable, false)
+                const keyFull = Configuration.subObjectAttributeNameFromReference(v.ScriptVariable, true)
+                return {
+                    simple: [keySimple, this[keySimple]],
+                    full: [keyFull, this[keyFull]],
+                    variable: v,
+                }
+            })
+            .filter(v => pins.has(v.full?.["Variable"]?.["Name"]))
+            .reduce(
+                (acc, cur) => {
+                    acc.simple.push([cur.simple[0], cur.simple[1]])
+                    acc.full.push([cur.full[0], cur.full[1]])
+                    acc.ScriptVariables.push(cur.variable)
+                    return acc
+                },
+                ({ simple: [], full: [], ScriptVariables: [] })
+            )
+        return {
+
+        }
+    }
 }

js/entity/IEntity.js

@@ -146,9 +146,9 @@ export default class IEntity {
      * @this {T}
      * @returns {T}
      */
-    static asUniqueClass() {
+    static asUniqueClass(alwaysCreate = false) {
         let result = this
-        if (this.name.length) {
+        if (this.name.length || alwaysCreate) {
             // @ts-expect-error
             result = (() => class extends this { })() // Comes from a lambda otherwise the class will have name "result"
             result.grammar = result.createGrammar() // Reassign grammar to capture the correct this from subclass

js/entity/ObjectEntity.js

@@ -368,7 +368,7 @@ export default class ObjectEntity extends IEntity {
                     : i
         })
         const reference = this.ExportPath?.valueOf()
-        if (reference?.path.endsWith(this.Name?.valueOf())) {
+        if (reference?.path.endsWith(this.Name?.toString())) {
             const mirroredEntity = /** @type {typeof ObjectEntity} */(this.constructor).attributes.ExportPath
             const objectReferenceEntity = /** @type {typeof ObjectReferenceEntity} */(mirroredEntity.type)
             const nameLength = this.Name.valueOf().length
@@ -442,14 +442,14 @@ export default class ObjectEntity extends IEntity {
     }
 
     getType() {
-        let classValue = this.getClass()
-        if (this.MacroGraphReference?.MacroGraph?.path) {
-            return this.MacroGraphReference.MacroGraph.path
+        const path = this.MacroGraphReference?.MacroGraph?.path
+        if (path) {
+            return path
         }
         if (this.MaterialExpression) {
             return this.MaterialExpression.type
         }
-        return classValue
+        return this.getClass()
     }
 
     getObjectName(dropCounter = false) {

js/entity/ObjectReferenceEntity.js

@@ -25,6 +25,7 @@ export default class ObjectReferenceEntity extends IEntity {
         return this.#path
     }
     set path(value) {
+        this.#name = ""
         this.#path = value
     }
 
@@ -36,6 +37,8 @@ export default class ObjectReferenceEntity extends IEntity {
         this.#full = value
     }
 
+    #name = ""
+
     /** @param {(t: String, p: String) => String} full */
     constructor(
         type = "None",
@@ -101,7 +104,13 @@ export default class ObjectReferenceEntity extends IEntity {
     }
 
     getName(dropCounter = false) {
-        return Utility.getNameFromPath(this.path.replace(/_C$/, ""), dropCounter)
+        if (!this.#name) {
+            if (!dropCounter) {
+                return this.#name = Utility.getNameFromPath(this.path.replace(/_C$/, ""), dropCounter)
+            }
+            return Utility.getNameFromPath(this.path.replace(/_C$/, ""), dropCounter)
+        }
+        return this.#name
     }
 
     doSerialize(insideString = false) {

js/entity/UnknownKeysEntity.js

@@ -1,9 +1,14 @@
 import P from "parsernostrum"
 import Grammar from "../serialization/Grammar.js"
+import GuidEntity from "./GuidEntity.js"
 import IEntity from "./IEntity.js"
 
 export default class UnknownKeysEntity extends IEntity {
 
+    static attributes = {
+        ...super.attributes,
+        VariableGuid: GuidEntity,
+    }
     static grammar = this.createGrammar()
 
     static {