game-data-gen 5.0.0 → 6.0.0

package/README.md

@@ -31,55 +31,105 @@ npm i -D game-data-gen
 npx game-data-gen <input-file-path> <optional-output-file-path>
 ```
 
-## Supported fields
+## Types
 
-### group
+Each block in the Markdown file starts with a heading that defines the type, followed by a list of fields.
 
-| Field type         | Example                  |
-| ------------------ | ------------------------ |
-| (none)             | `- health`               |
-| `int8 <length>`    | `- ids int8 64`          |
-| `int16 <length>`   | `- ids int16 64`         |
-| `int32 <length>`   | `- ids int32 64`         |
-| `uint8 <length>`   | `- ids uint8 64`         |
-| `uint16 <length>`  | `- ids uint16 64`        |
-| `uint32 <length>`  | `- ids uint32 64`        |
-| `float32 <length>` | `- positions float32 64` |
-| `float64 <length>` | `- positions float64 64` |
+### Group
 
-Whether a field is a scalar or an array is derived from whether a length is provided. A scalar field generates a plain `number`. An array field generates a typed array with a `count` variable and `push`/`pop` functions to simulate a dynamic array within the fixed capacity.
+```
+# <name> group
+```
+
+A set of module-level variables with individual setter and zero functions, plus a combined zero function.
+
+| Field type  | Description                 |
+| ----------- | --------------------------- |
+| `string`    | A string primitive          |
+| `number`    | A number primitive          |
+| `boolean`   | A boolean primitive         |
+| `string[]`  | A dynamic array of strings  |
+| `number[]`  | A dynamic array of numbers  |
+| `boolean[]` | A dynamic array of booleans |
+
+### Structure of Arrays (SOA)
+
+```
+# <name> soa <capacity>
+```
 
-### soa (Structure of Arrays)
+A set of typed arrays of fixed capacity, ideal for cache-friendly iteration over many elements.
 
-| Field type | Example        |
+| Field type | Typed array    |
 | ---------- | -------------- |
-| `int8`     | `- val int8`   |
-| `int16`    | `- val int16`  |
-| `int32`    | `- val int32`  |
-| `uint8`    | `- val uint8`  |
-| `uint16`   | `- val uint16` |
-| `uint32`   | `- val uint32` |
-| `float32`  | `- x float32`  |
-| `float64`  | `- x float64`  |
+| `int8`     | `Int8Array`    |
+| `int16`    | `Int16Array`   |
+| `int32`    | `Int32Array`   |
+| `uint8`    | `Uint8Array`   |
+| `uint16`   | `Uint16Array`  |
+| `uint32`   | `Uint32Array`  |
+| `float32`  | `Float32Array` |
+| `float64`  | `Float64Array` |
 
-## Example
+### Struct
+
+```
+# <name> struct
+```
+
+A TypeScript type with create, copy, and zero functions. Fields can be primitives, primitive arrays, or other structs.
+
+| Field type  | Description                                          |
+| ----------- | ---------------------------------------------------- |
+| `string`    | A string primitive                                   |
+| `number`    | A number primitive                                   |
+| `boolean`   | A boolean primitive                                  |
+| `string[]`  | A dynamic array of strings                           |
+| `number[]`  | A dynamic array of numbers                           |
+| `boolean[]` | A dynamic array of booleans                          |
+| `<name>`    | A nested struct (must be defined before this struct) |
+
+### Array of Structures (AOS)
 
-Create a Markdown file somewhere in your source code.
+```
+# <name> aos <capacity> <struct>
+```
+
+A pre-allocated fixed-length array of struct objects.
+
+## Example
 
-For example `src/data.md`:
+Create a Markdown file somewhere in your source code, for example `src/data.md`:
 
 ```md
-# game
+# game group
+
+- score number
+- name string
+- isPaused boolean
+- enemies number[]
+
+# particles soa 256
+
+- x float32
+- y float32
+- lifetime float32
+- type int8
 
-- playerId
-- enemies uint16 64
+# Vector2 struct
 
-# entity 1000
+- x number
+- y number
 
-- type uint8
-- posX float32
-- posY float32
-- health uint16
+# Entity struct
+
+- name string
+- health number
+- isActive boolean
+- position Vector2
+- tags string[]
+
+# entities aos 64 Entity
 ```
 
 Run the package with (consider making this a script in your package.json):
@@ -97,78 +147,180 @@ This will create or update the `src/data.ts` file (see below). The data and func
  * --------------------------------------------------
  */
 
-export let playerId = 0;
-export const enemies = new Uint16Array(64);
-export let enemiesCount = 0;
+export let score = 0;
+export let name = "";
+export let isPaused = false;
+export const enemies: Array<number> = [];
+
+/** Set the value of the score field within the game group. */
+export function setScore(v: number) {
+  score = v;
+}
 
-/** Set the value of the playerId field within the game group. */
-export function setPlayerId(v: number) {
-  playerId = v;
+/** Set the value of the name field within the game group. */
+export function setName(v: string) {
+  name = v;
 }
 
-/** Push a value onto the enemies field within the game group. */
-export function pushEnemies(v: number) {
-  enemies[enemiesCount++] = v;
+/** Set the value of the isPaused field within the game group. */
+export function setIsPaused(v: boolean) {
+  isPaused = v;
 }
 
-/** Pop a value from the enemies field within the game group. */
-export function popEnemies() {
-  return enemies[--enemiesCount];
+/** Zero the score field within the game group. */
+export function zeroScore() {
+  score = 0;
 }
 
-/** Zero the playerId field within the game group. */
-export function zeroPlayerId() {
-  playerId = 0;
+/** Zero the name field within the game group. */
+export function zeroName() {
+  name = "";
+}
+
+/** Zero the isPaused field within the game group. */
+export function zeroIsPaused() {
+  isPaused = false;
 }
 
 /** Zero the enemies field within the game group. */
 export function zeroEnemies() {
-  enemiesCount = 0;
+  enemies.length = 0;
 }
 
 /** Zero all fields within the game group. */
 export function zeroGame() {
-  playerId = 0;
-  enemiesCount = 0;
+  score = 0;
+  name = "";
+  isPaused = false;
+  enemies.length = 0;
 }
 
 /*
  * --------------------------------------------------
- * entity (Structure Of Arrays)
+ * particles (Structure Of Arrays)
  * --------------------------------------------------
  */
 
-export const MAX_ENTITY_COUNT = 1000;
+export const MAX_PARTICLES_COUNT = 256;
 
-export const type = new Uint8Array(1000);
-export const posX = new Float32Array(1000);
-export const posY = new Float32Array(1000);
-export const health = new Uint16Array(1000);
+export const x = new Float32Array(256);
+export const y = new Float32Array(256);
+export const lifetime = new Float32Array(256);
+export const type = new Int8Array(256);
 
-/** Zero an index within the entity structure of arrays. */
-export function zeroEntityAt(i: number) {
+/** Zero an index within the particles structure of arrays. */
+export function zeroParticlesAt(i: number) {
+  x[i] = 0;
+  y[i] = 0;
+  lifetime[i] = 0;
   type[i] = 0;
-  posX[i] = 0;
-  posY[i] = 0;
-  health[i] = 0;
 }
 
-/** Zero all fields within the entity structure of arrays. */
-export function zeroEntity() {
+/** Zero all fields within the particles structure of arrays. */
+export function zeroParticles() {
+  x.fill(0);
+  y.fill(0);
+  lifetime.fill(0);
   type.fill(0);
-  posX.fill(0);
-  posY.fill(0);
-  health.fill(0);
 }
-```
 
-The `enemies` array in the group acts as a dynamic list within its fixed capacity. Iterate only the active entries using the generated `count`:
+/*
+ * --------------------------------------------------
+ * Vector2 (Struct)
+ * --------------------------------------------------
+ */
 
-```typescript
-import { enemies, enemiesCount } from "./data.ts";
+export type Vector2 = {
+  x: number;
+  y: number;
+};
+
+/** Create a new Vector2 object. */
+export function createVector2() {
+  const obj: Vector2 = Object.create(null);
+  obj.x = 0;
+  obj.y = 0;
+  return obj;
+}
+
+/** Copy the values of Vector2 object b into Vector2 object a. */
+export function copyVector2(a: Vector2, b: Vector2) {
+  a.x = b.x;
+  a.y = b.y;
+}
+
+/** Zero the given Vector2 object. */
+export function zeroVector2(obj: Vector2) {
+  obj.x = 0;
+  obj.y = 0;
+}
+
+/*
+ * --------------------------------------------------
+ * Entity (Struct)
+ * --------------------------------------------------
+ */
+
+export type Entity = {
+  name: string;
+  health: number;
+  isActive: boolean;
+  position: Vector2;
+  tags: string[];
+};
+
+/** Create a new Entity object. */
+export function createEntity() {
+  const obj: Entity = Object.create(null);
+  obj.name = "";
+  obj.health = 0;
+  obj.isActive = false;
+  obj.position = createVector2();
+  obj.tags = [];
+  return obj;
+}
+
+/** Copy the values of Entity object b into Entity object a. */
+export function copyEntity(a: Entity, b: Entity) {
+  a.name = b.name;
+  a.health = b.health;
+  a.isActive = b.isActive;
+  copyVector2(a.position, b.position);
+  a.tags.length = b.tags.length;
+  for (let i = 0; i < b.tags.length; i++) {
+    a.tags[i] = b.tags[i];
+  }
+}
+
+/** Zero the given Entity object. */
+export function zeroEntity(obj: Entity) {
+  obj.name = "";
+  obj.health = 0;
+  obj.isActive = false;
+  zeroVector2(obj.position);
+  obj.tags.length = 0;
+}
+
+/*
+ * --------------------------------------------------
+ * entities (Array Of Structures)
+ * --------------------------------------------------
+ */
+
+export const MAX_ENTITIES_COUNT = 64;
+
+/** An array of Entity objects (structures). */
+export const entities = Array.from({ length: 64 }, createEntity);
+
+/** Zero all objects within the entities array of structures. */
+export function zeroEntities() {
+  for (let i = 0; i < 64; i++) {
+    zeroEntity(entities[i]);
+  }
+}
 
-for (let i = 0; i < enemiesCount; i++) {
-  const id = enemies[i];
-  // ...
+/** Zero an object at a specific index within the entities array of structures. */
+export function zeroEntitiesAt(index: number) {
+  zeroEntity(entities[index]);
 }
 ```

package/dist/consts.js

@@ -1,5 +1,13 @@
+export var Type;
+(function (Type) {
+    Type["GROUP"] = "group";
+    Type["STRUCT"] = "struct";
+    Type["STRUCTURE_OF_ARRAYS"] = "soa";
+    Type["ARRAY_OF_STRUCTURES"] = "aos";
+})(Type || (Type = {}));
 export var FieldType;
 (function (FieldType) {
+    // Structure of Arrays
     FieldType["INT_8"] = "int8";
     FieldType["INT_16"] = "int16";
     FieldType["INT_32"] = "int32";
@@ -8,4 +16,12 @@ export var FieldType;
     FieldType["UINT_32"] = "uint32";
     FieldType["FLOAT_32"] = "float32";
     FieldType["FLOAT_64"] = "float64";
+    // Struct / Group
+    FieldType["STRING"] = "string";
+    FieldType["NUMBER"] = "number";
+    FieldType["BOOLEAN"] = "boolean";
+    // Primitive arrays (Group and Struct)
+    FieldType["ARRAY_STRING"] = "string[]";
+    FieldType["ARRAY_NUMBER"] = "number[]";
+    FieldType["ARRAY_BOOLEAN"] = "boolean[]";
 })(FieldType || (FieldType = {}));

package/dist/lib/aos.js

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

package/dist/lib/group.js

@@ -9,92 +9,66 @@ export function addGroup(header, fields, output) {
     for (const field of fields) {
         addFieldSetFunction(name, field, output);
     }
-    for (const field of fields) {
-        addFieldPushFunction(name, field, output);
-    }
-    for (const field of fields) {
-        addFieldPopFunction(name, field, output);
-    }
     for (const field of fields) {
         addFieldZeroFunction(name, field, output);
     }
     addZeroFunction(name, fields, output);
 }
 function addFieldDefinition(field, output) {
-    const [fieldName, fieldType, fieldLength] = field.split(" ");
+    const [fieldName, fieldType] = field.split(" ");
     switch (fieldType) {
-        case FieldType.INT_8:
-            output.push(`export const ${fieldName} = new Int8Array(${fieldLength})`);
-            output.push(`export let ${fieldName}Count = 0`);
-            break;
-        case FieldType.INT_16:
-            output.push(`export const ${fieldName} = new Int16Array(${fieldLength})`);
-            output.push(`export let ${fieldName}Count = 0`);
-            break;
-        case FieldType.INT_32:
-            output.push(`export const ${fieldName} = new Int32Array(${fieldLength})`);
-            output.push(`export let ${fieldName}Count = 0`);
+        case FieldType.STRING:
+            output.push(`export let ${fieldName} = ""`);
             break;
-        case FieldType.UINT_8:
-            output.push(`export const ${fieldName} = new Uint8Array(${fieldLength})`);
-            output.push(`export let ${fieldName}Count = 0`);
+        case FieldType.NUMBER:
+            output.push(`export let ${fieldName} = 0`);
             break;
-        case FieldType.UINT_16:
-            output.push(`export const ${fieldName} = new Uint16Array(${fieldLength})`);
-            output.push(`export let ${fieldName}Count = 0`);
+        case FieldType.BOOLEAN:
+            output.push(`export let ${fieldName} = false`);
             break;
-        case FieldType.UINT_32:
-            output.push(`export const ${fieldName} = new Uint32Array(${fieldLength})`);
-            output.push(`export let ${fieldName}Count = 0`);
+        case FieldType.ARRAY_STRING:
+            output.push(`export const ${fieldName}: Array<string> = []`);
             break;
-        case FieldType.FLOAT_32:
-            output.push(`export const ${fieldName} = new Float32Array(${fieldLength})`);
-            output.push(`export let ${fieldName}Count = 0`);
+        case FieldType.ARRAY_NUMBER:
+            output.push(`export const ${fieldName}: Array<number> = []`);
             break;
-        case FieldType.FLOAT_64:
-            output.push(`export const ${fieldName} = new Float64Array(${fieldLength})`);
-            output.push(`export let ${fieldName}Count = 0`);
+        case FieldType.ARRAY_BOOLEAN:
+            output.push(`export const ${fieldName}: Array<boolean> = []`);
             break;
-        default:
-            output.push(`export let ${fieldName} = 0`);
     }
 }
 function addFieldSetFunction(name, field, output) {
-    const [fieldName, , fieldLength] = field.split(" ");
-    if (!fieldLength) {
-        output.push("");
-        output.push(`/** Set the value of the ${fieldName} field within the ${name} group. */`);
-        output.push(`export function set${capitalize(fieldName)}(v: number) {`);
-        output.push(`  ${fieldName} = v`);
-        output.push("}");
-    }
-}
-function addFieldPushFunction(name, field, output) {
-    const [fieldName, , fieldLength] = field.split(" ");
-    if (fieldLength) {
-        output.push("");
-        output.push(`/** Push a value onto the ${fieldName} field within the ${name} group. */`);
-        output.push(`export function push${capitalize(fieldName)}(v: number) {`);
-        output.push(`  ${fieldName}[${fieldName}Count++] = v`);
-        output.push("}");
-    }
-}
-function addFieldPopFunction(name, field, output) {
-    const [fieldName, , fieldLength] = field.split(" ");
-    if (fieldLength) {
-        output.push("");
-        output.push(`/** Pop a value from the ${fieldName} field within the ${name} group. */`);
-        output.push(`export function pop${capitalize(fieldName)}() {`);
-        output.push(`  return ${fieldName}[--${fieldName}Count]`);
-        output.push("}");
+    const [fieldName, fieldType] = field.split(" ");
+    switch (fieldType) {
+        case FieldType.STRING:
+            output.push("");
+            output.push(`/** Set the value of the ${fieldName} field within the ${name} group. */`);
+            output.push(`export function set${capitalize(fieldName)}(v: string) {`);
+            output.push(`  ${fieldName} = v`);
+            output.push("}");
+            break;
+        case FieldType.NUMBER:
+            output.push("");
+            output.push(`/** Set the value of the ${fieldName} field within the ${name} group. */`);
+            output.push(`export function set${capitalize(fieldName)}(v: number) {`);
+            output.push(`  ${fieldName} = v`);
+            output.push("}");
+            break;
+        case FieldType.BOOLEAN:
+            output.push("");
+            output.push(`/** Set the value of the ${fieldName} field within the ${name} group. */`);
+            output.push(`export function set${capitalize(fieldName)}(v: boolean) {`);
+            output.push(`  ${fieldName} = v`);
+            output.push("}");
+            break;
     }
 }
 function addFieldZeroFunction(name, field, output) {
-    const [fieldName, , fieldLength] = field.split(" ");
+    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, !!fieldLength, output);
+    zeroField(fieldName, fieldType, output);
     output.push("}");
 }
 function addZeroFunction(name, fields, output) {
@@ -102,16 +76,26 @@ function addZeroFunction(name, fields, output) {
     output.push(`/** Zero all fields within the ${name} group. */`);
     output.push(`export function zero${capitalize(name)}() {`);
     for (const field of fields) {
-        const [fieldName, , fieldLength] = field.split(" ");
-        zeroField(fieldName, !!fieldLength, output);
+        const [fieldName, fieldType] = field.split(" ");
+        zeroField(fieldName, fieldType, output);
     }
     output.push("}");
 }
-function zeroField(name, isArray, output) {
-    if (isArray) {
-        output.push(`  ${name}Count = 0`);
-    }
-    else {
-        output.push(`  ${name} = 0`);
+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_STRING:
+        case FieldType.ARRAY_NUMBER:
+        case FieldType.ARRAY_BOOLEAN:
+            output.push(`  ${name}.length = 0`);
+            break;
     }
 }

package/dist/lib/soa.js

@@ -1,7 +1,7 @@
 import { FieldType } from "../consts.js";
 import { addHeader, capitalize } from "./utils.js";
 export function addStructureOfArrays(header, fields, output) {
-    const [name, length] = header.split(" ");
+    const [name, , length] = header.split(" ");
     addHeader(`${name} (Structure Of Arrays)`, output);
     addFieldMaxLengthConstant(name, length, output);
     for (const field of fields) {
@@ -9,7 +9,6 @@ export function addStructureOfArrays(header, fields, output) {
     }
     addZeroAtIndexFunction(name, fields, output);
     addZeroFunction(name, fields, output);
-    addPrintAtIndexFunction(name, fields, output);
 }
 function addFieldMaxLengthConstant(name, length, output) {
     output.push(`export const MAX_${name.toUpperCase()}_COUNT = ${length}`);
@@ -64,15 +63,3 @@ function addZeroAtIndexFunction(name, fields, output) {
     }
     output.push("}");
 }
-function addPrintAtIndexFunction(name, fields, output) {
-    output.push("");
-    output.push(`/** Print an index within the ${name} structure of arrays to the console. */`);
-    output.push(`export function print${capitalize(name)}At(i: number) {`);
-    output.push("  console.table({");
-    for (const field of fields) {
-        const [fieldName] = field.split(" ");
-        output.push(`    ${fieldName}: ${fieldName}[i],`);
-    }
-    output.push("  })");
-    output.push("}");
-}

package/dist/lib/struct.js

@@ -1,19 +1,18 @@
 import { FieldType } from "../consts.js";
-import { addHeader, capitalize, getTypeName } from "./utils.js";
+import { addHeader, capitalize } 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] = field.split(" ");
-        output.push(`  ${fieldName}: ${getTypeName(fieldType)}`);
+        output.push(`  ${fieldName}: ${fieldType}`);
     }
     output.push("}");
 }
@@ -21,18 +20,23 @@ function addStructCreateFunction(name, fields, output) {
     output.push("");
     output.push(`/** Create a new ${capitalize(name)} object. */`);
     output.push(`export function create${capitalize(name)}() {`);
-    output.push(`  const obj: ${getTypeName(name)} = Object.create(null)`);
+    output.push(`  const obj: ${name} = Object.create(null)`);
     for (const field of fields) {
         const [fieldName, fieldType] = field.split(" ");
         switch (fieldType) {
             case FieldType.STRING:
                 output.push(`  obj.${fieldName} = ""`);
                 break;
+            case FieldType.NUMBER:
+                output.push(`  obj.${fieldName} = 0`);
+                break;
             case FieldType.BOOLEAN:
                 output.push(`  obj.${fieldName} = false`);
                 break;
-            case FieldType.NUMBER:
-                output.push(`  obj.${fieldName} = 0`);
+            case FieldType.ARRAY_STRING:
+            case FieldType.ARRAY_NUMBER:
+            case FieldType.ARRAY_BOOLEAN:
+                output.push(`  obj.${fieldName} = []`);
                 break;
             default:
                 output.push(`  obj.${fieldName} = create${capitalize(fieldType)}()`);
@@ -44,37 +48,49 @@ function addStructCreateFunction(name, fields, output) {
 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)}) {`);
+    output.push(`export function copy${capitalize(name)}(a: ${name}, b: ${name}) {`);
     for (const field of fields) {
-        const [fieldName] = field.split(" ");
-        output.push(`  a.${fieldName} = b.${fieldName}`);
+        const [fieldName, fieldType] = field.split(" ");
+        switch (fieldType) {
+            case FieldType.STRING:
+            case FieldType.NUMBER:
+            case FieldType.BOOLEAN:
+                output.push(`  a.${fieldName} = b.${fieldName}`);
+                break;
+            case FieldType.ARRAY_STRING:
+            case FieldType.ARRAY_NUMBER:
+            case FieldType.ARRAY_BOOLEAN:
+                output.push(`  a.${fieldName}.length = b.${fieldName}.length`);
+                output.push(`  for (let i = 0; i < b.${fieldName}.length; i++) {`);
+                output.push(`    a.${fieldName}[i] = b.${fieldName}[i]`);
+                output.push(`  }`);
+                break;
+            default:
+                output.push(`  copy${capitalize(fieldType)}(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: ${getTypeName(name)}) {`);
+    output.push(`export function zero${capitalize(name)}(obj: ${name}) {`);
     for (const field of fields) {
         const [fieldName, fieldType] = field.split(" ");
         switch (fieldType) {
             case FieldType.STRING:
                 output.push(`  obj.${fieldName} = ""`);
                 break;
+            case FieldType.NUMBER:
+                output.push(`  obj.${fieldName} = 0`);
+                break;
             case FieldType.BOOLEAN:
                 output.push(`  obj.${fieldName} = false`);
                 break;
-            case FieldType.NUMBER:
-                output.push(`  obj.${fieldName} = 0`);
+            case FieldType.ARRAY_STRING:
+            case FieldType.ARRAY_NUMBER:
+            case FieldType.ARRAY_BOOLEAN:
+                output.push(`  obj.${fieldName}.length = 0`);
                 break;
             default:
                 output.push(`  zero${capitalize(fieldType)}(obj.${fieldName})`);

package/dist/main.js

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
 import fs from "node:fs";
 import { marked } from "marked";
+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";
 const inputFile = process.argv[2];
 const outputFile = process.argv[3] || inputFile.replace(".md", ".ts");
 const input = fs.readFileSync(inputFile, "utf-8");
@@ -37,12 +40,20 @@ for (const token of tokens) {
     }
 }
 for (const { header, fields } of blocks) {
-    const [, length] = header.split(" ");
-    if (length) {
-        addStructureOfArrays(header, fields, output);
-    }
-    else {
-        addGroup(header, fields, output);
+    const [, type] = header.split(" ");
+    switch (type) {
+        case Type.GROUP:
+            addGroup(header, fields, output);
+            break;
+        case Type.STRUCT:
+            addStruct(header, fields, output);
+            break;
+        case Type.ARRAY_OF_STRUCTURES:
+            addArrayOfStructures(header, output);
+            break;
+        case Type.STRUCTURE_OF_ARRAYS:
+            addStructureOfArrays(header, fields, output);
+            break;
     }
 }
 fs.writeFileSync(outputFile, output.join("\n"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "game-data-gen",
-  "version": "5.0.0",
+  "version": "6.0.0",
   "type": "module",
   "files": [
     "dist"