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 {
+
+        }
+    }
 }