game-data-gen 2.2.0 → 3.0.0

package/README.md

@@ -16,7 +16,7 @@ If you're making a game in Javascript then you might (this was actually me):
 
 This library:
 
-- creates data structures based on a very easy syntax (I tried JSON, didn't feel it)
+- creates data structures based on Markdown file (see example below)
 - each data structure gets associated functions to zero out its memory so it can be reused
 
 ## Installation
@@ -31,122 +31,98 @@ npm i -D game-data-gen
 npx game-data-gen <input-file-path> <optional-output-file-path>
 ```
 
-## Format
-
-```
-name type? length? struct?
-fieldName fieldType fieldArrayType? fieldArrayLength?
-```
-
-`name`
-
-The name of the data structure.
-
-`type`
-
-Supported data structure types:
-
-- group
-- struct
-- soa (Structure of Arrays)
-- aos (Array of Structures)
-
-`length` (optional)
-
-The length of the arrays within the Structure of Arrays data structure.
-
-If no length is given to the type and no length is given to a field it is considered a dynamic array and zeroing will set the array's length back to zero (emptying it).
-
-`struct` (optional, required if type=aos)
-
-The struct to use for this Array of Structures.
-
-`fieldName`
-
-The name of one of the fields within the data structure.
-
-`fieldType`
-
-Supported field types:
-
-- string
-- number
-- boolean
-- array
-- a struct (see entity struct in example below)
-
-`fieldArrayType` (required if fieldType=array)
-
-Supported array field types:
-
-- string
-- boolean
-- number
-
-`fieldArrayLength` (optional)
-
-The length of the array field, leave empty to use a dynamically sized array instead of a fixed size array.
-
-In case of a Structure of Arrays data structure (type=soa), setting the length on the type instead is recommended so that all arrays have the same length.
-
-
 ## Example
 
-Create a plain text file somewhere in your source code (without a file extension).
+Create a Markdown file somewhere in your source code (without a file extension).
 
-For example `src/data/game`:
+For example `src/data.md`:
 
-```
-game group
-activeEntities array number
+```md
+# game group
+- activeEntities array entity
+- activeEntityIds array number
+- playerId number
 
-vector struct
-x number
-y number
+# vector struct
+- x number
+- y number
 
-entity struct
-position vector
-velocity vector
-health number
-isActive boolean
+# entity struct
+- position vector
+- velocity vector
+<!-- stats -->
+- health number
+<!-- inventory -->
+- items array number
+<!-- flags -->
+- isActive boolean
 
-entities aos 2048 entity
+# entities aos 2048 entity
 
-particle soa 1024
-posX array number
-posY array number
+# particle soa 10_000
+- type string
+- pos Vector
 ```
 
 Run the package with (consider making this a script in your package.json):
 
 ```shell
-npx game-data-gen src/data/game
+npx game-data-gen src/data.md
 ```
 
-This will create or update the `src/data/game.ts` file (see below). The data and functions can then be imported from this file into your code.
+This will create or update the `src/data.ts` file (see below). The data and functions can then be imported from this file into your code.
 
 ```typescript
 /*
  * --------------------------------------------------
- * game (group)
+ * game (Group)
  * --------------------------------------------------
  */
 
-export const activeEntities = new Array<number>()
+export let activeEntities = new Array<Entity>()
+export let activeEntityIds = new Array<number>()
+export let playerId = 0
+
+/** Set the value of the activeEntities field within the game group. */
+export function setActiveEntities(value: Array<Entity>) {
+  activeEntities = value
+}
+
+/** Set the value of the activeEntityIds field within the game group. */
+export function setActiveEntityIds(value: Array<number>) {
+  activeEntityIds = value
+}
+
+/** Set the value of the playerId field within the game group. */
+export function setPlayerId(value: number) {
+  playerId = value
+}
 
 /** Zero the activeEntities field within the game group. */
 export function zeroActiveEntities() {
   activeEntities.length = 0
 }
 
+/** Zero the activeEntityIds field within the game group. */
+export function zeroActiveEntityIds() {
+  activeEntityIds.length = 0
+}
+
+/** Zero the playerId field within the game group. */
+export function zeroPlayerId() {
+  playerId = 0
+}
+
 /** Zero all fields within the game group. */
 export function zeroGameData() {
   activeEntities.length = 0
+  activeEntityIds.length = 0
+  playerId = 0
 }
 
 /*
  * --------------------------------------------------
- * vector (struct)
+ * vector (Struct)
  * --------------------------------------------------
  */
 
@@ -156,13 +132,26 @@ export type Vector = {
 }
 
 /** Create a new Vector object. */
-export function createVector(): Vector {
-  const obj = Object.create(null)
+export function createVector() {
+  const obj: Vector = Object.create(null)
   obj.x = 0
   obj.y = 0
   return obj
 }
 
+/** Copy the values of Vector object b into Vector object a. */
+export function copyVector(a: Vector, b: Vector) {
+  a.x = b.x
+  a.y = b.y
+}
+
+/** Clone the given Vector object. */
+export function cloneVector(obj: Vector) {
+  const clone = createVector()
+  copyVector(clone, obj)
+  return clone
+}
+
 /** Zero the given Vector object. */
 export function zeroVector(obj: Vector) {
   obj.x = 0
@@ -171,7 +160,7 @@ export function zeroVector(obj: Vector) {
 
 /*
  * --------------------------------------------------
- * entity (struct)
+ * entity (Struct)
  * --------------------------------------------------
  */
 
@@ -179,40 +168,56 @@ export type Entity = {
   position: Vector
   velocity: Vector
   health: number
+  items: Array<number>
   isActive: boolean
 }
 
 /** Create a new Entity object. */
-export function createEntity(): Entity {
-  const obj = Object.create(null)
+export function createEntity() {
+  const obj: Entity = Object.create(null)
   obj.position = createVector()
   obj.velocity = createVector()
   obj.health = 0
+  obj.items = new Array<number>()
   obj.isActive = false
   return obj
 }
 
+/** Copy the values of Entity object b into Entity object a. */
+export function copyEntity(a: Entity, b: Entity) {
+  a.position = b.position
+  a.velocity = b.velocity
+  a.health = b.health
+  a.items = b.items
+  a.isActive = b.isActive
+}
+
+/** Clone the given Entity object. */
+export function cloneEntity(obj: Entity) {
+  const clone = createEntity()
+  copyEntity(clone, obj)
+  return clone
+}
+
 /** Zero the given Entity object. */
 export function zeroEntity(obj: Entity) {
   zeroVector(obj.position)
   zeroVector(obj.velocity)
   obj.health = 0
+  obj.items.length = 0
   obj.isActive = false
 }
 
 /*
  * --------------------------------------------------
- * entities (array of structures)
+ * entities (Array Of Structures)
  * --------------------------------------------------
  */
 
 export const MAX_ENTITIES_COUNT = 2048
 
 /** An array of Entity objects (structures). */
-export const entities = new Array<Entity>(2048)
-for (let i=0; i<2048; i++) {
-  entities[i] = createEntity()
-}
+export const entities = Array.from({ length: 2048 }, createEntity)
 
 /** Zero all objects within the entities array of structures. */
 export function zeroEntities() {
@@ -221,36 +226,41 @@ export function zeroEntities() {
   }
 }
 
+/** Zero an object at a specific index within the entities array of structures. */
+export function zeroEntitiesAt(index: number) {
+  zeroEntity(entities[index])
+}
+
 /*
  * --------------------------------------------------
- * particle (structure of arrays)
+ * particle (Structure Of Arrays)
  * --------------------------------------------------
  */
 
-export const MAX_PARTICLE_COUNT = 1024
+export const MAX_PARTICLE_COUNT = 10_000
 
-export const posX = new Array<number>(1024).fill(0)
-export const posY = new Array<number>(1024).fill(0)
+export const type = new Array(10_000).fill("")
+export const pos = Array.from({ length: 10_000 }, createVector)
 
 /** Zero an index within the particle structure of arrays. */
 export function zeroParticle(idx: number) {
-  posX[idx] = 0
-  posY[idx] = 0
+  type[idx] = ""
+  zeroVector(pos[idx])
 }
 
-/** Zero the posX field within the particle structure of arrays. */
-export function zeroPosX() {
-  posX.fill(0)
+/** Zero the type field within the particle structure of arrays. */
+export function zeroType() {
+  type.fill("")
 }
 
-/** Zero the posY field within the particle structure of arrays. */
-export function zeroPosY() {
-  posY.fill(0)
+/** Zero the pos field within the particle structure of arrays. */
+export function zeroPos() {
+  pos.forEach(zeroVector)
 }
 
 /** Zero all fields within the particle structure of arrays. */
 export function zeroParticleData() {
-  posX.fill(0)
-  posY.fill(0)
+  type.fill("")
+  pos.forEach(zeroVector)
 }
 ```

package/dist/consts.js

@@ -11,7 +11,6 @@ export var FieldType;
     FieldType["NUMBER"] = "number";
     FieldType["BOOLEAN"] = "boolean";
     FieldType["ARRAY"] = "array";
-    FieldType["SET"] = "set";
 })(FieldType || (FieldType = {}));
 export var ArrayType;
 (function (ArrayType) {

package/dist/lib/aos.js

@@ -1,32 +1,33 @@
-import { addFieldMaxLengthConstant } from "./fields.js";
-import { capitalize, getName } from "./utils.js";
+import { addHeader, capitalize } from "./utils.js";
 export function addArrayOfStructures(header, output) {
-    const [name, , length, struct] = header.split(" ");
+    const [name, , length, type] = header.split(" ");
+    addHeader(`${name} (Array Of Structures)`, output);
     addFieldMaxLengthConstant(name, length, output);
-    addArrayOfStructuresDefinition(name, struct, length, output);
-    addArrayOfStructuresZeroFunction(name, struct, length, output);
-    addArrayOfStructuresZeroAtIndexFunction(name, struct, output);
+    addArrayOfStructuresDefinition(name, type, length, output);
+    addArrayOfStructuresZeroFunction(name, type, length, output);
+    addArrayOfStructuresZeroAtIndexFunction(name, type, output);
 }
-function addArrayOfStructuresDefinition(name, struct, length, output) {
-    output.push(`/** An array of ${capitalize(struct)} objects (structures). */`);
-    output.push(`export const ${name} = new Array<${getName(struct)}>(${length})`);
-    output.push(`for (let i=0; i<${length}; i++) {`);
-    output.push(`  ${name}[i] = create${capitalize(struct)}()`);
-    output.push("}");
+function addFieldMaxLengthConstant(name, length, output) {
+    output.push(`export const MAX_${name.toUpperCase()}_COUNT = ${length}`);
+    output.push("");
+}
+function addArrayOfStructuresDefinition(name, type, length, output) {
+    output.push(`/** An array of ${capitalize(type)} objects (structures). */`);
+    output.push(`export const ${name} = Array.from({ length: ${length} }, create${capitalize(type)})`);
 }
-function addArrayOfStructuresZeroFunction(name, struct, length, output) {
+function addArrayOfStructuresZeroFunction(name, type, length, output) {
     output.push("");
     output.push(`/** Zero all objects within the ${name} array of structures. */`);
     output.push(`export function zero${capitalize(name)}() {`);
     output.push(`  for (let i=0; i<${length}; i++) {`);
-    output.push(`    zero${capitalize(struct)}(${name}[i])`);
+    output.push(`    zero${capitalize(type)}(${name}[i])`);
     output.push("  }");
     output.push("}");
 }
-function addArrayOfStructuresZeroAtIndexFunction(name, struct, output) {
+function addArrayOfStructuresZeroAtIndexFunction(name, type, output) {
     output.push("");
     output.push(`/** Zero an object at a specific index within the ${name} array of structures. */`);
-    output.push(`export function zero${capitalize(struct)}At(index: number) {`);
-    output.push(`  zero${capitalize(struct)}(${name}[index])`);
+    output.push(`export function zero${capitalize(name)}At(i: number) {`);
+    output.push(`  zero${capitalize(type)}(${name}[i])`);
     output.push("}");
 }

package/dist/lib/fields.js

@@ -101,6 +101,6 @@ function zeroField(name, type, arrayType, length, output) {
     }
 }
 export function addFieldMaxLengthConstant(name, length, output) {
-    output.push(`export const MAX_${name.toUpperCase()}_COUNT = ${length}`);
+    output.push(`export const MAX_${name.toUpperCase()} = ${length}`);
     output.push("");
 }

package/dist/lib/group.js

@@ -1,14 +1,79 @@
-import { addFieldDefinition, addFieldSetFunction, addFieldZeroFunction, addZeroFunction } from "./fields.js";
+import { FieldType } from "../consts.js";
+import { addHeader, capitalize, getTypeName } from "./utils.js";
 export function addGroup(header, fields, output) {
-    const [name, type, baseLength] = header.split(" ");
+    const [name] = header.split(" ");
+    addHeader(`${name} (Group)`, output);
     for (const field of fields) {
-        addFieldDefinition(field, baseLength, output);
+        addFieldDefinition(field, output);
     }
     for (const field of fields) {
-        addFieldSetFunction(name, type, field, output);
+        addFieldSetFunction(name, field, output);
     }
     for (const field of fields) {
-        addFieldZeroFunction(name, type, field, baseLength, output);
+        addFieldZeroFunction(name, field, output);
+    }
+    addZeroFunction(name, fields, output);
+}
+function addFieldDefinition(field, output) {
+    const [fieldName, fieldType, fieldArrayType] = field.split(" ");
+    switch (fieldType) {
+        case FieldType.STRING:
+            output.push(`export let ${fieldName} = ""`);
+            break;
+        case FieldType.NUMBER:
+            output.push(`export let ${fieldName} = 0`);
+            break;
+        case FieldType.BOOLEAN:
+            output.push(`export let ${fieldName} = false`);
+            break;
+        case FieldType.ARRAY:
+            output.push(`export let ${fieldName} = new Array<${getTypeName(fieldArrayType)}>()`);
+            break;
+        default:
+            output.push(`export let ${fieldName} = create${capitalize(fieldType)}()`);
+    }
+}
+function addFieldSetFunction(name, field, output) {
+    const [fieldName, fieldType, fieldArrayType] = field.split(" ");
+    output.push("");
+    output.push(`/** Set the value of the ${fieldName} field within the ${name} group. */`);
+    output.push(`export function set${capitalize(fieldName)}(v: ${getTypeName(fieldType, fieldArrayType)}) {`);
+    output.push(`  ${fieldName} = v`);
+    output.push("}");
+}
+function addFieldZeroFunction(name, field, output) {
+    const [fieldName, fieldType] = field.split(" ");
+    output.push("");
+    output.push(`/** Zero the ${fieldName} field within the ${name} group. */`);
+    output.push(`export function zero${capitalize(fieldName)}() {`);
+    zeroField(fieldName, fieldType, output);
+    output.push("}");
+}
+function addZeroFunction(name, fields, output) {
+    output.push("");
+    output.push(`/** Zero all fields within the ${name} group. */`);
+    output.push(`export function zero${capitalize(name)}Data() {`);
+    for (const field of fields) {
+        const [fieldName, fieldType] = field.split(" ");
+        zeroField(fieldName, fieldType, output);
+    }
+    output.push("}");
+}
+function zeroField(name, type, output) {
+    switch (type) {
+        case FieldType.STRING:
+            output.push(`  ${name} = ""`);
+            break;
+        case FieldType.NUMBER:
+            output.push(`  ${name} = 0`);
+            break;
+        case FieldType.BOOLEAN:
+            output.push(`  ${name} = false`);
+            break;
+        case FieldType.ARRAY:
+            output.push(`  ${name}.length = 0`);
+            break;
+        default:
+            output.push(`  zero${capitalize(type)}(${name})`);
     }
-    addZeroFunction(name, type, fields, baseLength, output);
 }

package/dist/lib/soa.js

@@ -1,37 +1,89 @@
 import { ArrayType } from "../consts.js";
-import { addFieldDefinition, addFieldMaxLengthConstant, addFieldSetFunction, addFieldZeroFunction, addZeroFunction } from "./fields.js";
-import { capitalize, getName } from "./utils.js";
+import { addHeader, capitalize } from "./utils.js";
 export function addStructureOfArrays(header, fields, output) {
-    const [name, type, baseLength] = header.split(" ");
-    addFieldMaxLengthConstant(name, baseLength, output);
+    const [name, _, length] = header.split(" ");
+    addHeader(`${name} (Structure Of Arrays)`, output);
+    addFieldMaxLengthConstant(name, length, output);
     for (const field of fields) {
-        addFieldDefinition(field, baseLength, output);
+        addFieldDefinition(field, length, output);
     }
+    addFieldZeroAtIndexFunction(name, fields, output);
     for (const field of fields) {
-        addFieldSetFunction(name, type, field, output);
+        addFieldZeroFunction(name, field, output);
     }
-    addFieldZeroAtIndexFunction(name, type, fields, output);
+    addZeroFunction(name, fields, output);
+}
+function addFieldMaxLengthConstant(name, length, output) {
+    output.push(`export const MAX_${name.toUpperCase()}_COUNT = ${length}`);
+    output.push("");
+}
+function addFieldDefinition(field, length, output) {
+    const [fieldName, fieldType] = field.split(" ");
+    switch (fieldType) {
+        case ArrayType.STRING:
+            output.push(`export const ${fieldName} = new Array(${length}).fill("")`);
+            break;
+        case ArrayType.NUMBER:
+            output.push(`export const ${fieldName} = new Array(${length}).fill(0)`);
+            break;
+        case ArrayType.BOOLEAN:
+            output.push(`export const ${fieldName} = new Array(${length}).fill(false)`);
+            break;
+        default:
+            output.push(`export const ${fieldName} = Array.from({ length: ${length} }, create${capitalize(fieldType)})`);
+    }
+}
+function addFieldZeroFunction(name, field, output) {
+    const [fieldName, fieldType] = field.split(" ");
+    output.push("");
+    output.push(`/** Zero the ${fieldName} field within the ${name} structure of arrays. */`);
+    output.push(`export function zero${capitalize(fieldName)}() {`);
+    zeroField(fieldName, fieldType, output);
+    output.push("}");
+}
+function addZeroFunction(name, fields, output) {
+    output.push("");
+    output.push(`/** Zero all fields within the ${name} structure of arrays. */`);
+    output.push(`export function zero${capitalize(name)}Data() {`);
     for (const field of fields) {
-        addFieldZeroFunction(name, type, field, baseLength, output);
+        const [fieldName, fieldType] = field.split(" ");
+        zeroField(fieldName, fieldType, output);
+    }
+    output.push("}");
+}
+function zeroField(name, type, output) {
+    switch (type) {
+        case ArrayType.STRING:
+            output.push(`  ${name}.fill("")`);
+            break;
+        case ArrayType.NUMBER:
+            output.push(`  ${name}.fill(0)`);
+            break;
+        case ArrayType.BOOLEAN:
+            output.push(`  ${name}.fill(false)`);
+            break;
+        default:
+            output.push(`  ${name}.forEach(zero${capitalize(type)})`);
     }
-    addZeroFunction(name, type, fields, baseLength, output);
 }
-function addFieldZeroAtIndexFunction(name, type, fields, output) {
+function addFieldZeroAtIndexFunction(name, fields, output) {
     output.push("");
-    output.push(`/** Zero an index within the ${name} ${getName(type)}. */`);
-    output.push(`export function zero${capitalize(name)}(idx: number) {`);
+    output.push(`/** Zero an index within the ${name} structure of arrays. */`);
+    output.push(`export function zero${capitalize(name)}(i: number) {`);
     for (const field of fields) {
-        const [fieldName, _, fieldArrayType] = field.split(" ");
-        switch (fieldArrayType) {
+        const [fieldName, fieldType] = field.split(" ");
+        switch (fieldType) {
             case ArrayType.STRING:
-                output.push(`  ${fieldName}[idx] = ""`);
+                output.push(`  ${fieldName}[i] = ""`);
                 break;
             case ArrayType.NUMBER:
-                output.push(`  ${fieldName}[idx] = 0`);
+                output.push(`  ${fieldName}[i] = 0`);
                 break;
             case ArrayType.BOOLEAN:
-                output.push(`  ${fieldName}[idx] = false`);
+                output.push(`  ${fieldName}[i] = false`);
                 break;
+            default:
+                output.push(`  zero${capitalize(fieldType)}(${fieldName}[i])`);
         }
     }
     output.push("}");

package/dist/lib/struct.js

@@ -1,26 +1,29 @@
-import { ArrayType, FieldType } from "../consts.js";
-import { capitalize, getName } from "./utils.js";
+import { FieldType } from "../consts.js";
+import { addHeader, capitalize, getTypeName } from "./utils.js";
 export function addStruct(header, fields, output) {
     const [name] = header.split(" ");
+    addHeader(`${name} (Struct)`, output);
     addStructTypeDefinition(name, fields, output);
     addStructCreateFunction(name, fields, output);
+    addStructCopyFunction(name, fields, output);
+    addStructCloneFunction(name, output);
     addStructZeroFunction(name, fields, output);
 }
 function addStructTypeDefinition(name, fields, output) {
     output.push(`export type ${capitalize(name)} = {`);
     for (const field of fields) {
         const [fieldName, fieldType, fieldArrayType] = field.split(" ");
-        output.push(`  ${fieldName}: ${getName(fieldType, fieldArrayType)}`);
+        output.push(`  ${fieldName}: ${getTypeName(fieldType, fieldArrayType)}`);
     }
     output.push("}");
 }
 function addStructCreateFunction(name, fields, output) {
     output.push("");
     output.push(`/** Create a new ${capitalize(name)} object. */`);
-    output.push(`export function create${capitalize(name)}(): ${capitalize(name)} {`);
-    output.push(`  const obj = Object.create(null)`);
+    output.push(`export function create${capitalize(name)}() {`);
+    output.push(`  const obj: ${getTypeName(name)} = Object.create(null)`);
     for (const field of fields) {
-        const [fieldName, fieldType, fieldArrayType, fieldArrayLength = ""] = field.split(" ");
+        const [fieldName, fieldType, fieldArrayType] = field.split(" ");
         switch (fieldType) {
             case FieldType.STRING:
                 output.push(`  obj.${fieldName} = ""`);
@@ -32,24 +35,7 @@ function addStructCreateFunction(name, fields, output) {
                 output.push(`  obj.${fieldName} = false`);
                 break;
             case FieldType.ARRAY:
-                {
-                    switch (fieldArrayType) {
-                        case ArrayType.STRING:
-                            output.push(`  obj.${fieldName} = new Array<string>(${fieldArrayLength})${fieldArrayLength ? '.fill("")' : ""}`);
-                            break;
-                        case ArrayType.NUMBER:
-                            output.push(`  obj.${fieldName} = new Array<number>(${fieldArrayLength})${fieldArrayLength ? ".fill(0)" : ""}`);
-                            break;
-                        case ArrayType.BOOLEAN:
-                            output.push(`  obj.${fieldName} = new Array<boolean>(${fieldArrayLength})${fieldArrayLength ? ".fill(false)" : ""}`);
-                            break;
-                        default:
-                            output.push(`  obj.${fieldName} = new Array<${getName(fieldArrayType)}>()`);
-                    }
-                }
-                break;
-            case FieldType.SET:
-                output.push(`  obj.${fieldName} = new Set<${getName(fieldArrayType)}>()`);
+                output.push(`  obj.${fieldName} = new Array<${getTypeName(fieldArrayType)}>()`);
                 break;
             default: {
                 output.push(`  obj.${fieldName} = create${capitalize(fieldType)}()`);
@@ -59,12 +45,31 @@ function addStructCreateFunction(name, fields, output) {
     output.push("  return obj");
     output.push("}");
 }
+function addStructCopyFunction(name, fields, output) {
+    output.push("");
+    output.push(`/** Copy the values of ${capitalize(name)} object b into ${capitalize(name)} object a. */`);
+    output.push(`export function copy${capitalize(name)}(a: ${getTypeName(name)}, b: ${getTypeName(name)}) {`);
+    for (const field of fields) {
+        const [fieldName] = field.split(" ");
+        output.push(`  a.${fieldName} = b.${fieldName}`);
+    }
+    output.push("}");
+}
+function addStructCloneFunction(name, output) {
+    output.push("");
+    output.push(`/** Clone the given ${capitalize(name)} object. */`);
+    output.push(`export function clone${capitalize(name)}(obj: ${getTypeName(name)}) {`);
+    output.push(`  const clone = create${capitalize(name)}()`);
+    output.push(`  copy${capitalize(name)}(clone, obj)`);
+    output.push("  return clone");
+    output.push("}");
+}
 function addStructZeroFunction(name, fields, output) {
     output.push("");
     output.push(`/** Zero the given ${capitalize(name)} object. */`);
-    output.push(`export function zero${capitalize(name)}(obj: ${capitalize(name)}) {`);
+    output.push(`export function zero${capitalize(name)}(obj: ${getTypeName(name)}) {`);
     for (const field of fields) {
-        const [fieldName, fieldType, fieldArrayType, fieldArrayLength] = field.split(" ");
+        const [fieldName, fieldType] = field.split(" ");
         switch (fieldType) {
             case FieldType.STRING:
                 output.push(`  obj.${fieldName} = ""`);
@@ -76,24 +81,7 @@ function addStructZeroFunction(name, fields, output) {
                 output.push(`  obj.${fieldName} = false`);
                 break;
             case FieldType.ARRAY:
-                {
-                    switch (fieldArrayType) {
-                        case ArrayType.STRING:
-                            output.push(`  obj.${fieldName}.${fieldArrayLength ? 'fill("")' : "length = 0"}`);
-                            break;
-                        case ArrayType.NUMBER:
-                            output.push(`  obj.${fieldName}.${fieldArrayLength ? "fill(0)" : "length = 0"}`);
-                            break;
-                        case ArrayType.BOOLEAN:
-                            output.push(`  obj.${fieldName}.${fieldArrayLength ? "fill(false)" : "length = 0"}`);
-                            break;
-                        default:
-                            output.push(`  obj.${fieldName}.length = 0`);
-                    }
-                }
-                break;
-            case FieldType.SET:
-                output.push(`  obj.${fieldName}.clear()`);
+                output.push(`  obj.${fieldName}.length = 0`);
                 break;
             default:
                 output.push(`  zero${capitalize(fieldType)}(obj.${fieldName})`);

package/dist/lib/utils.js

@@ -1,8 +1,17 @@
 import { FieldType, Type } from "../consts.js";
+export function addHeader(name, output) {
+    output.push("");
+    output.push("/*");
+    output.push(` * ${"-".repeat(50)}`);
+    output.push(` * ${name}`);
+    output.push(` * ${"-".repeat(50)}`);
+    output.push(" */");
+    output.push("");
+}
 /**
  * Get the name based on the type of the data structure.
  */
-export function getName(type, arrayType = "") {
+export function getTypeName(type, arrayType = "") {
     switch (type) {
         case Type.SOA:
             return "structure of arrays";
@@ -19,9 +28,7 @@ export function getName(type, arrayType = "") {
         case FieldType.BOOLEAN:
             return "boolean";
         case FieldType.ARRAY:
-            return `Array<${getName(arrayType)}>`;
-        case FieldType.SET:
-            return `Set<${getName(arrayType)}>`;
+            return `Array<${getTypeName(arrayType)}>`;
         default:
             return capitalize(type);
     }

package/dist/main.js

@@ -1,32 +1,31 @@
 #!/usr/bin/env node
+var _a;
 import fs from "node:fs";
 import { Type } from "./consts.js";
 import { addArrayOfStructures } from "./lib/aos.js";
 import { addGroup } from "./lib/group.js";
 import { addStructureOfArrays } from "./lib/soa.js";
 import { addStruct } from "./lib/struct.js";
-import { getName } from "./lib/utils.js";
 const inputFile = process.argv[2];
-const outputFile = process.argv[3] || `${inputFile}.ts`;
+const outputFile = process.argv[3] || `${inputFile.replace(/\.md$/, "")}.ts`;
 const input = fs.readFileSync(inputFile, "utf-8");
 const output = [];
 output.push("/*");
 output.push(` * Generated with game-data-gen on ${new Date().toLocaleString()}. DO NOT MODIFY THIS FILE!`);
 output.push(" */");
-const blocks = input.trim().split("\n\n");
+const blocks = input
+    .split("\n")
+    .filter((line) => !line.startsWith("<!--"))
+    .join("\n")
+    .trim()
+    .split("\n\n");
 for (const block of blocks) {
-    const fields = block.split("\n");
-    const header = fields.shift();
+    const lines = block.split("\n");
+    const header = (_a = lines.shift()) === null || _a === void 0 ? void 0 : _a.replace(/^#\s*/, "");
     if (!header)
         continue;
-    const [name, type] = header.split(" ");
-    output.push("");
-    output.push("/*");
-    output.push(` * ${"-".repeat(50)}`);
-    output.push(` * ${name} (${getName(type)})`);
-    output.push(` * ${"-".repeat(50)}`);
-    output.push(" */");
-    output.push("");
+    const fields = lines.map((line) => line.replace(/^-\s*/, ""));
+    const [_, type] = header.split(" ");
     switch (type) {
         case Type.STRUCT:
             addStruct(header, fields, output);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "game-data-gen",
-  "version": "2.2.0",
+  "version": "3.0.0",
   "type": "module",
   "files": [
     "dist"
@@ -9,7 +9,7 @@
     "game-data-gen": "dist/main.js"
   },
   "scripts": {
-    "start": "tsc && node dist/main.js tests/data",
+    "start": "tsc && node dist/main.js tests/data.md",
     "build": "biome check && tsc"
   },
   "repository": {