@amodx/ncs 0.0.22 → 0.0.24

package/Nodes/NodeCursor.js

@@ -15,17 +15,20 @@ export class NodeCursor {
         return cursor;
     }
     static Retrun(cursor) {
-        cursor.clear(cursor.hasEvents, cursor.hasContexts, cursor.hasObservers, cursor.hasComponents, cursor.hasTags);
+        if (cursor.index !== -1) {
+            cursor.clear(cursor.hasEvents, cursor.hasContexts, cursor.hasObservers, cursor.hasComponents, cursor.hasTags);
+        }
         NCSPools.nodeCursor.addItem(cursor);
     }
     clear(events, context, observers, compoents, tags) {
+        this._index = -1;
         if (events && this._events) {
             NodeEvents.Retrun(this._events);
             this._events = null;
         }
-        if (context && this._components) {
-            NodeComponents.Retrun(this._components);
-            this._components = null;
+        if (context && this._context) {
+            NodeContext.Retrun(this._context);
+            this._context = null;
         }
         if (observers && this._observers) {
             NodeObservers.Retrun(this._observers);
@@ -43,9 +46,6 @@ export class NodeCursor {
     get index() {
         return this._index;
     }
-    get parentIndex() {
-        return this.arrays._parents[this._index];
-    }
     get id() {
         return this.graph._nodes._indexMap[this.index] || null;
     }
@@ -132,7 +132,7 @@ export class NodeCursor {
     get isDisposed() {
         return this.arrays._disposed[this._index];
     }
-    _index = 0;
+    _index = -1;
     constructor() { }
     setNode(graph, index) {
         this._index = index;
@@ -170,21 +170,39 @@ export class NodeCursor {
         return cursor.setNode(this.graph, this.index);
     }
     /** Traverse the node's direct children */
-    *children(cursor = nodeCursor) {
+    *children(cursor) {
         const array = this.childrenArray;
         if (!array)
             return false;
+        const templChildArray = NCSPools.numberArray.get() || [];
         for (let i = 0; i < array.length; i++) {
-            cursor.setNode(this.graph, array[i]);
+            templChildArray[i] = array[i];
+        }
+        let usedTemp = false;
+        if (!cursor) {
+            usedTemp = true;
+            cursor = NodeCursor.Get();
+        }
+        for (let i = 0; i < templChildArray.length; i++) {
+            cursor.setNode(this.graph, templChildArray[i]);
             yield cursor;
         }
+        templChildArray.length = 0;
+        NCSPools.numberArray.addItem(templChildArray);
+        if (usedTemp)
+            cursor.returnCursor();
         return true;
     }
     /** Traverse all the node's descendants */
-    *traverseChildren(cursor = nodeCursor) {
+    *traverseChildren(cursor) {
         if (!this.childrenArray)
             return false;
         const children = [this.childrenArray];
+        let usedTemp = false;
+        if (!cursor) {
+            usedTemp = true;
+            cursor = NodeCursor.Get();
+        }
         while (children.length) {
             const childrenArray = children.shift();
             if (!childrenArray)
@@ -197,39 +215,63 @@ export class NodeCursor {
                 }
             }
         }
+        if (usedTemp)
+            cursor.returnCursor();
         return true;
     }
     /** Traverse all the node's parents */
-    *traverseParents(cursor = nodeCursor) {
+    *traverseParents(cursor) {
         let parent = this.parent;
         if (parent === undefined || parent < 0)
             return false;
+        let usedTemp = false;
+        if (!cursor) {
+            usedTemp = true;
+            cursor = NodeCursor.Get();
+        }
         while (true) {
             cursor.setNode(this.graph, parent);
             yield cursor;
             parent = this.arrays._parents[cursor._index];
-            if (parent === undefined || parent < 0)
+            if (parent === undefined || parent < 0) {
+                if (usedTemp)
+                    cursor.returnCursor();
                 return true;
+            }
         }
     }
     /** Traverse all the node's components */
-    *traverseComponents(cursor = componentCursor) {
+    *traverseComponents(cursor) {
         const components = this.components.components;
-        if (!components)
+        if (!components || !components.length)
             return false;
+        let usedTemp = false;
+        if (!cursor) {
+            usedTemp = true;
+            cursor = ComponentCursor.Get();
+        }
         for (let i = 0; i < components.length; i += 2) {
             yield cursor.setInstance(this, components[i], components[i + 1]);
         }
+        if (usedTemp)
+            cursor.returnCursor();
         return true;
     }
     /** Traverse all the node's tags */
-    *traverseTags(cursor = tagCursor) {
+    *traverseTags(cursor) {
         const tags = this.tags.tags;
         if (!this.tags)
             return false;
+        let usedTemp = false;
+        if (!cursor) {
+            usedTemp = true;
+            cursor = TagCursor.Get();
+        }
         for (let i = 0; i < tags.length; i += 2) {
             yield cursor.setTag(this, tags[i], tags[i + 1]);
         }
+        if (usedTemp)
+            cursor.returnCursor();
         return true;
     }
     dispose() {
@@ -238,10 +280,6 @@ export class NodeCursor {
         this.hasObservers &&
             this.observers.isDisposedSet &&
             this.observers.disposed.notify(this);
-        if (this.parent !== undefined) {
-            nodeCursor.setNode(this.graph, this.parent);
-            nodeCursor.removeChild(this.index);
-        }
         if (this.arrays._components[this._index]?.length) {
             this.components.dispose();
         }
@@ -249,10 +287,25 @@ export class NodeCursor {
             this.tags.dispose();
         }
         if (this.childrenArray) {
-            for (let i = 0; i < this.childrenArray.length; i++) {
-                nodeCursor.setNode(this.graph, this.childrenArray[i]);
-                nodeCursor.dispose();
+            const templChildArray = NCSPools.numberArray.get() || [];
+            const children = this.childrenArray;
+            for (let i = 0; i < children.length; i++) {
+                templChildArray[i] = children[i];
+            }
+            const tempCursor = NodeCursor.Get();
+            for (let i = 0; i < templChildArray.length; i++) {
+                tempCursor.setNode(this.graph, templChildArray[i]);
+                tempCursor.dispose();
             }
+            tempCursor.returnCursor();
+            templChildArray.length = 0;
+            NCSPools.numberArray.addItem(templChildArray);
+        }
+        if (this.parent > -1) {
+            const tempCursor = NodeCursor.Get();
+            tempCursor.setNode(this.graph, this.parent);
+            tempCursor.removeChild(tempCursor.getChildIndex(this.index));
+            tempCursor.returnCursor();
         }
         this.graph.removeNode(this.index);
         this.clear(this.hasEvents, this.hasContexts, this.hasObservers, this.hasComponents, this.hasTags);
@@ -267,17 +320,21 @@ export class NodeCursor {
         return false;
     }
     parentTo(nodeToParentTo) {
+        if (this.index == nodeToParentTo.index)
+            throw new Error(`NCS: Tried to parent node ${this.index} ${this.name} to itself`);
         if (nodeToParentTo.hasChild(this))
             return;
-        if (this.parent !== undefined) {
-            nodeCursor.setNode(this.graph, this.parent);
-            nodeCursor.removeChild(this.index);
+        const tempCursor = NodeCursor.Get();
+        if (this.parent > -1) {
+            tempCursor.setNode(this.graph, this.parent);
+            tempCursor.removeChild(tempCursor.getChildIndex(this.index));
         }
         nodeToParentTo.addChild(this);
         this.parent = nodeToParentTo.index;
         this.hasObservers &&
             this.observers.isParentedSet &&
-            nodeToParentTo.observers.parented.notify(nodeCursor);
+            nodeToParentTo.observers.parented.notify(tempCursor);
+        tempCursor.returnCursor();
     }
     getChild(index, cursor = NodeCursor.Get()) {
         const childrenArray = this.childrenArray;
@@ -285,9 +342,18 @@ export class NodeCursor {
             return null;
         return cursor.setNode(this.graph, childrenArray[index]);
     }
+    getChildIndex(node) {
+        let index = typeof node == "number" ? node : node.index;
+        for (let i = 0; i < this.childrenArray.length; i++) {
+            if (this.childrenArray[i] == index) {
+                return i;
+            }
+        }
+        return -1;
+    }
     addChild(node) {
         if (this.hasChild(node))
-            return;
+            return this.getChildIndex(node);
         if (!this.childrenArray) {
             this.arrays._children[this._index] = NCSPools.numberArray.get() || [];
         }
@@ -297,40 +363,39 @@ export class NodeCursor {
             this.observers.isChildAddedSet &&
                 this.observers.childAdded.notify(node);
             this.observers.isChildrenUpdatedSet &&
-                this.observers.childrenUpdated.notify(node);
+                this.observers.childrenUpdated.notify(this);
         }
         if (node.hasObservers) {
             node.observers.isParentedSet && node.observers.parented.notify(node);
         }
+        return this.childrenArray.length - 1;
     }
     removeChild(index) {
-        if (!this.childrenArray)
+        if (!this.childrenArray || !this.childrenArray[index])
             return;
-        for (let i = 0; i < this.childrenArray.length; i++) {
-            if (this.childrenArray[i] == index) {
-                const child = this.childrenArray.splice(i, 1)[0];
-                nodeCursor.setNode(this.graph, child);
-                if (this.hasObservers) {
-                    this.hasObservers &&
-                        this.observers.isChildRemovedSet &&
-                        this.observers.childRemoved.notify(nodeCursor);
-                    this.hasObservers &&
-                        this.observers.isChildrenUpdatedSet &&
-                        this.observers.childrenUpdated.notify(nodeCursor);
-                }
-                if (nodeCursor.hasObservers) {
-                    nodeCursor.observers.isRemovedFromParentSet &&
-                        nodeCursor.observers.removedFromParent.notify(nodeCursor);
-                }
-                return child;
-            }
+        const child = this.childrenArray.splice(index, 1)[0];
+        const tempCursor = NodeCursor.Get();
+        tempCursor.setNode(this.graph, child);
+        if (this.hasObservers) {
+            this.hasObservers &&
+                this.observers.isChildRemovedSet &&
+                this.observers.childRemoved.notify(tempCursor);
+            this.hasObservers &&
+                this.observers.isChildrenUpdatedSet &&
+                this.observers.childrenUpdated.notify(this);
+        }
+        if (tempCursor.hasObservers) {
+            tempCursor.observers.isRemovedFromParentSet &&
+                tempCursor.observers.removedFromParent.notify(tempCursor);
         }
-        return null;
+        tempCursor.returnCursor();
+        return child;
     }
-    addUniqueId() {
+    uniqueId() {
         let id = this.graph._nodes._indexMap[this.index];
-        if (!id)
-            id = NodeId.Create();
+        if (id)
+            return id;
+        id = NodeId.Create();
         this.graph._nodes.addNodeId(this.index, id);
         return id;
     }
@@ -343,6 +408,3 @@ export class NodeCursor {
         return newCursor;
     }
 }
-const componentCursor = ComponentCursor.Get();
-const tagCursor = TagCursor.Get();
-const nodeCursor = NodeCursor.Get();

package/Nodes/NodeId.d.ts

@@ -1,5 +1,8 @@
 export declare class NodeId {
     static Create(): bigint;
+    static GetHighPart(id: bigint): bigint;
+    static GetLowPart(id: bigint): bigint;
+    static GetCombined(lower: bigint, upper: bigint): bigint;
     static CreateString(): string;
     static FromString(id: string): bigint;
     static ToHexString(id: BigInt): string;

package/Nodes/NodeId.js

@@ -1,6 +1,7 @@
 const buffer = new ArrayBuffer(16);
 const randomArray = new Uint8Array(buffer);
 const view = new DataView(buffer);
+const mask64 = 0xffffffffffffffffn;
 export class NodeId {
     static Create() {
         crypto.getRandomValues(randomArray);
@@ -11,6 +12,15 @@ export class NodeId {
         const bigIntId = high | midHigh | midLow | low;
         return bigIntId;
     }
+    static GetHighPart(id) {
+        return (id >> 64n) & mask64;
+    }
+    static GetLowPart(id) {
+        return id & mask64;
+    }
+    static GetCombined(lower, upper) {
+        return ((upper & mask64) << 64n) | (lower & mask64);
+    }
     static CreateString() {
         return this.ToHexString(this.Create());
     }

package/Nodes/NodeTags.js

@@ -1,7 +1,7 @@
+import { TagArray } from "../Tags/TagArray";
 import { NCSPools } from "../Pools/NCSPools";
 import { NCSRegister } from "../Register/NCSRegister";
 import { TagCursor } from "../Tags/TagCursor";
-const tagCursor = TagCursor.Get();
 export class NodeTags {
     node;
     static Get() {
@@ -18,41 +18,63 @@ export class NodeTags {
     }
     constructor() { }
     dispose() {
+        const tempCursor = TagCursor.Get();
         for (let i = 0; i < this.tags.length; i += 2) {
-            tagCursor.setTag(this.node, this.tags[i], this.tags[i + 1]);
-            tagCursor.dispose();
+            tempCursor.setTag(this.node, this.tags[i], this.tags[i + 1]);
+            tempCursor.dispose();
         }
     }
-    add(id, cursor = tagCursor) {
-        const newTag = this.node.graph._tags[id].addTag(this.node.index);
+    add(id, cursor) {
+        let usedTemp = false;
+        if (!cursor) {
+            usedTemp = true;
+            cursor = TagCursor.Get();
+        }
+        let tagArray = this.node.graph._tags[id];
+        if (!tagArray) {
+            tagArray = new TagArray(NCSRegister.tags.get(id).id);
+            this.node.graph._tags[id] = tagArray;
+        }
+        const newTag = tagArray.addTag(this.node.index);
+        if (!this.node.arrays._tags[this.node.index]) {
+            this.node.arrays._tags[this.node.index] =
+                NCSPools.numberArray.get() || [];
+        }
         this.tags.push(id, newTag);
         cursor.setTag(this.node, id, newTag);
         if (this.node.hasObservers) {
             this.node.observers.isTagsAddedSet &&
                 this.node.observers.tagsAdded.notify(cursor);
         }
+        if (usedTemp)
+            cursor.returnCursor();
         return cursor;
     }
     remove(id) {
         const tagId = NCSRegister.tags.idPalette.getNumberId(id);
         const tags = this.tags;
+        const tempCursor = TagCursor.Get();
         for (let i = 0; i < tags.length; i++) {
             if (tags[i] == tagId) {
-                tagCursor.setTag(this.node, tagId, tags[i]);
-                tagCursor.dispose();
+                tempCursor.setTag(this.node, tagId, tags[i]);
+                tempCursor.dispose();
                 this.tags.splice(i, 2);
                 this.node.hasObservers &&
                     this.node.observers.isTagsRemovedSet &&
-                    this.node.observers.tagsRemoved.notify(tagCursor);
+                    this.node.observers.tagsRemoved.notify(tempCursor);
                 this.node.hasObservers &&
                     this.node.observers.isTagsUpdatedSet &&
                     this.node.observers.tagsUpdated.notify(0);
-                return true;
+                {
+                    tempCursor.returnCursor();
+                    return true;
+                }
             }
         }
+        tempCursor.returnCursor();
         return false;
     }
-    get(type, cursor = tagCursor) {
+    get(type, cursor = TagCursor.Get()) {
         const tagId = NCSRegister.tags.idPalette.getNumberId(type);
         const tags = this.tags;
         for (let i = 0; i < tags.length; i += 2) {
@@ -63,7 +85,7 @@ export class NodeTags {
         }
         return null;
     }
-    getChild(type, cursor = tagCursor) {
+    getChild(type, cursor = TagCursor.Get()) {
         for (const child of this.node.traverseChildren()) {
             const found = child.tags.get(type, cursor);
             if (found)
@@ -81,7 +103,7 @@ export class NodeTags {
         }
         return tags;
     }
-    getParent(type, cursor = tagCursor) {
+    getParent(type, cursor = TagCursor.Get()) {
         for (const parent of this.node.traverseParents()) {
             const found = parent.tags.get(type, cursor);
             if (found)
@@ -91,12 +113,14 @@ export class NodeTags {
     }
     getAllParents(type) {
         const tags = [];
+        const temp = TagCursor.Get();
         for (const child of this.node.traverseParents()) {
-            const found = child.tags.get(type, tagCursor);
+            const found = child.tags.get(type, temp);
             if (found) {
                 tags.push(TagCursor.Get().setTag(this.node, found.typeId, found.index));
             }
         }
+        temp.returnCursor();
         return tags;
     }
 }

package/Register/NCSRegister.js

@@ -11,7 +11,7 @@ class ItemRegister {
             ? this.items[this.idPalette.getNumberId(id)]
             : this.items[id];
         if (!item)
-            throw new Error(`[${this.itemtype}]: Entry with id ${id} does not exist`);
+            throw new Error(`NCS: [${this.itemtype}]: Entry with id ${id} does not exist`);
         return item;
     }
     has(id) {

package/Register/registerComponent.js

@@ -24,7 +24,6 @@ export const registerComponent = (data) => {
                 nodeCursor.setNode(graph, array._node[i]);
                 yield nodeCursor;
             }
-            NodeCursor.Retrun(nodeCursor);
             return true;
         },
         *getComponents(graph, cursor = ComponentCursor.Get(), nodeCursor = NodeCursor.Get()) {
@@ -36,8 +35,6 @@ export const registerComponent = (data) => {
                 cursor.setInstance(nodeCursor, typeId, i);
                 yield cursor;
             }
-            ComponentCursor.Retrun(cursor);
-            NodeCursor.Retrun(nodeCursor);
             return true;
         },
         set(node, schema, schemaView, cursor = ComponentCursor.Get()) {
@@ -55,7 +52,7 @@ export const registerComponent = (data) => {
         getRequired(node, cursor, nodeCursor) {
             const found = node.components.get(data.type, cursor, nodeCursor);
             if (!found)
-                throw new Error(`Node [${node.name}] does not have required component [${data.type}].`);
+                throw new Error(`NCS: Node [${node.name}] does not have required component [${data.type}].`);
             return found;
         },
         getChild(node, cursor, nodeCursor) {
@@ -64,7 +61,7 @@ export const registerComponent = (data) => {
         getRequiredChild(node, cursor, nodeCursor) {
             const comp = node.components.getChild(data.type, cursor, nodeCursor);
             if (!comp)
-                throw new Error(`Node [${node.name}] does not have a child with required component [${data.type}].`);
+                throw new Error(`NCS: Node [${node.name}] does not have a child with required component [${data.type}].`);
             return comp;
         },
         getParent(node, cursor, nodeCursor) {
@@ -73,7 +70,7 @@ export const registerComponent = (data) => {
         getRequiredParent(node, cursor, nodeCursor) {
             const comp = node.components.getParent(data.type, cursor, nodeCursor);
             if (!comp)
-                throw new Error(`Node [${node.name}] does not have a parent with required component [${data.type}].`);
+                throw new Error(`NCS: Node [${node.name}] does not have a parent with required component [${data.type}].`);
             return comp;
         },
         getAll(node) {

package/Register/registerContext.js

@@ -27,7 +27,7 @@ export function registerContext(data) {
         getRequired: (parent) => {
             const found = parent.context.get(data.type);
             if (!found)
-                throw new Error(`Could not find required context type: ${data.type}`);
+                throw new Error(`NCS: Could not find required context type: ${data.type}`);
             return found;
         },
         remove: (parent) => {

package/Register/registerTag.js

@@ -1,17 +1,43 @@
 import { NCSRegister } from "./NCSRegister";
+import { NodeCursor } from "../Nodes/NodeCursor";
 import { TagCursor } from "../Tags/TagCursor";
 import { Tag } from "../Tags/Tag";
 export function registerTag(data) {
     const tag = new Tag(null, data);
     const typeId = NCSRegister.tags.register(data.id, tag);
-    // const map = TagInstanceMap.registerTag(tag.id);
     const createTag = () => {
         return typeId;
     };
     return Object.assign(createTag, data, {
         tag,
         data,
-        // getNodes: (graph: Graph) => map.getNodes(graph),
+        *getNodes(graph, nodeCursor = NodeCursor.Get()) {
+            const array = graph._tags[typeId];
+            if (!array)
+                return false;
+            for (let i = 0; i < array._node.length; i++) {
+                const slot = array._node[i];
+                if (slot < 0)
+                    continue;
+                nodeCursor.setNode(graph, array._node[i]);
+                yield nodeCursor;
+            }
+            return true;
+        },
+        *getTags(graph, cursor = TagCursor.Get(), nodeCursor = NodeCursor.Get()) {
+            const array = graph._tags[typeId];
+            if (!array)
+                return false;
+            for (let i = 0; i < array._node.length; i++) {
+                const slot = array._node[i];
+                if (slot < 0)
+                    continue;
+                nodeCursor.setNode(graph, slot);
+                cursor.setTag(nodeCursor, typeId, i);
+                yield cursor;
+            }
+            return true;
+        },
         // getTags: (graph: Graph) => map.getItems(graph),
         getChild(parent, cursor) {
             return parent.tags.getChild(data.id, cursor);

package/Schema/Schema.js

@@ -11,7 +11,9 @@ const traverseCreate = (parent, properties, index) => {
     parent.children ??= [];
     for (let i = 0; i < properties.length; i++) {
         const data = properties[i];
-        if (typeof data.value == "object" && !data.children?.length) {
+        if (typeof data.value == "object" &&
+            !data.children?.length &&
+            !Array.isArray(data.value)) {
             data.children ??= [];
             for (const key in data.value) {
                 const value = data.value[key];
@@ -115,7 +117,11 @@ export class Schema {
         const data = [];
         for (const id in shape) {
             const value = shape[id];
-            if (typeof value == "object") {
+            if (typeof value == "object" &&
+                value !== null &&
+                typeof value !== "undefined" &&
+                !Array.isArray(id) &&
+                !ArrayBuffer.isView(value)) {
                 data.push(traverseCreateFromObject(value, {
                     id,
                     value: {},
@@ -191,7 +197,7 @@ export class Schema {
             view = new SchemaView(this, data.id, meta, byteOffsets, byteSize, data, this._binaryObjectCursorClass);
         }
         if (!view)
-            throw new Error(`Invalid data`);
+            throw new Error(`NCS: Invalid data`);
         const viewIndex = this.viewIdPalettew.register(data.id);
         this.views[viewIndex] = view;
         return view;

package/Schema/SchemaView.js

@@ -103,7 +103,7 @@ export class SchemaView {
             }
             return current;
         }
-        throw new Error(`Invalid create data`);
+        throw new Error(`NCS: Invalid create data`);
     }
     createCursor() {
         return new this._cursorClass(this, this.meta, this._createData, this.byteOffset);

package/Systems/System.types.d.ts

@@ -12,5 +12,5 @@ export type SystemRegisterData = {
     /**
      * The update function  of the system.
      */
-    update(system: SystemInstance): void;
+    update(system: SystemInstance, delta: number): void;
 };

package/Systems/SystemInstance.d.ts

@@ -8,6 +8,6 @@ export declare class SystemInstance {
     queries: QueryInstance[];
     node: NodeCursor;
     constructor(graph: Graph, proto: SystemRegisterData);
-    update(): void;
+    update(delta: number): void;
     dispose(): void;
 }

package/Systems/SystemInstance.js

@@ -12,8 +12,8 @@ export class SystemInstance {
         }
         this.graph._systems.push(this);
     }
-    update() {
-        this.proto.update(this);
+    update(delta) {
+        this.proto.update(this, delta);
     }
     dispose() {
         for (let i = 0; i < this.graph._systems.length; i++) {

package/Tags/TagCursor.d.ts

@@ -17,4 +17,5 @@ export declare class TagCursor {
     setTag(node: NodeCursor, type: number, index: number): this;
     dispose(): true | null;
     toJSON(): string;
+    returnCursor(): void;
 }

package/Tags/TagCursor.js

@@ -42,4 +42,7 @@ export class TagCursor {
     toJSON() {
         return this.id;
     }
+    returnCursor() {
+        TagCursor.Retrun(this);
+    }
 }