game-data-gen 4.0.1 → 6.0.0

package/README.md

@@ -1,20 +1,20 @@
 # Game Data Generation
 
-A Javascript (Typescript) library to generate data structures with zeroing functions.
+A CLI code generator that creates Javascript (Typescript) data structures with zeroing functions.
 
 ## The problems
 
-If you're making a game in Javascript then you might (this was actually me):
+If you're making a game in Javascript then you might:
 
 - hit the garbage collector (GC) a bunch causing frame drops because you're creating/destroying objects every frame (particles, for example)
 - read a book about [Data Oriented Design](https://www.amazon.com/dp/1916478700)
 - notice the performance implications of OOP (especially classes and calling their methods) versus using something like Structure of Arrays
-- wanting to implement Structure of Arrays instead of Array of Structures (which is a list of class instances, see previous point)
+- want to implement Structure of Arrays instead of Array of Structures (which is a list of class instances, see previous point)
 - notice that Javascript can not simply zero out data structures (resetting all data back to initial values) like languages such as C and Rust
 
 ## The solution
 
-This library:
+This tool:
 
 - 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
@@ -31,54 +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                        |
-| --------------- | ------------------------------ |
-| `number`        | `- health number`              |
-| `array int8`    | `- ids array int8 64`          |
-| `array int16`   | `- ids array int16 64`         |
-| `array int32`   | `- ids array int32 64`         |
-| `array uint8`   | `- ids array uint8 64`         |
-| `array uint16`  | `- ids array uint16 64`        |
-| `array uint32`  | `- ids array uint32 64`        |
-| `array float32` | `- positions array float32 64` |
-| `array float64` | `- positions array float64 64` |
+### Group
 
-Array fields always require a length. A `count` variable and `push`/`pop` functions are generated 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
+```
 
-Create a Markdown file somewhere in your source code.
+A TypeScript type with create, copy, and zero functions. Fields can be primitives, primitive arrays, or other structs.
 
-For example `src/data.md`:
+| 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)
+
+```
+# <name> aos <capacity> <struct>
+```
+
+A pre-allocated fixed-length array of struct objects.
+
+## Example
+
+Create a Markdown file somewhere in your source code, for example `src/data.md`:
 
 ```md
 # game group
 
-- playerId number
-- entityIds array uint16 64
+- score number
+- name string
+- isPaused boolean
+- enemies number[]
 
-# particle soa 10_000
+# particles soa 256
 
-- active uint8
 - x float32
 - y float32
+- lifetime float32
+- type int8
+
+# Vector2 struct
+
+- x number
+- y number
+
+# 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):
@@ -96,79 +147,180 @@ This will create or update the `src/data.ts` file (see below). The data and func
  * --------------------------------------------------
  */
 
-export let playerId = 0;
-export const entityIds = new Uint16Array(64);
-export let entityIdsCount = 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 entityIds field within the game group. */
-export function pushEntityIds(v: number) {
-  entityIds[entityIdsCount++] = v;
+/** Set the value of the isPaused field within the game group. */
+export function setIsPaused(v: boolean) {
+  isPaused = v;
 }
 
-/** Pop a value from the entityIds field within the game group. */
-export function popEntityIds() {
-  return entityIds[--entityIdsCount];
+/** 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 entityIds field within the game group. */
-export function zeroEntityIds() {
-  entityIdsCount = 0;
+/** Zero the isPaused field within the game group. */
+export function zeroIsPaused() {
+  isPaused = false;
+}
+
+/** Zero the enemies field within the game group. */
+export function zeroEnemies() {
+  enemies.length = 0;
 }
 
 /** Zero all fields within the game group. */
 export function zeroGame() {
-  playerId = 0;
-  entityIdsCount = 0;
+  score = 0;
+  name = "";
+  isPaused = false;
+  enemies.length = 0;
 }
 
 /*
  * --------------------------------------------------
- * particle (Structure Of Arrays)
+ * particles (Structure Of Arrays)
  * --------------------------------------------------
  */
 
-export const MAX_PARTICLE_COUNT = 10_000;
+export const MAX_PARTICLES_COUNT = 256;
 
-export const active = new Uint8Array(10_000);
-export const x = new Float32Array(10_000);
-export const y = new Float32Array(10_000);
+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 particle structure of arrays. */
-export function zeroParticleAt(i: number) {
-  active[i] = 0;
+/** 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;
+}
+
+/** Zero all fields within the particles structure of arrays. */
+export function zeroParticles() {
+  x.fill(0);
+  y.fill(0);
+  lifetime.fill(0);
+  type.fill(0);
 }
 
-/** Zero the active field within the particle structure of arrays. */
-export function zeroActive() {
-  active.fill(0);
+/*
+ * --------------------------------------------------
+ * Vector2 (Struct)
+ * --------------------------------------------------
+ */
+
+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;
 }
 
-/** Zero the x field within the particle structure of arrays. */
-export function zeroX() {
-  x.fill(0);
+/** 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 y field within the particle structure of arrays. */
-export function zeroY() {
-  y.fill(0);
+/** Zero the given Vector2 object. */
+export function zeroVector2(obj: Vector2) {
+  obj.x = 0;
+  obj.y = 0;
 }
 
-/** Zero all fields within the particle structure of arrays. */
-export function zeroParticle() {
-  active.fill(0);
-  x.fill(0);
-  y.fill(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]);
+  }
+}
+
+/** 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,21 +1,27 @@
 export var Type;
 (function (Type) {
-    Type["SOA"] = "soa";
     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";
+    FieldType["UINT_8"] = "uint8";
+    FieldType["UINT_16"] = "uint16";
+    FieldType["UINT_32"] = "uint32";
+    FieldType["FLOAT_32"] = "float32";
+    FieldType["FLOAT_64"] = "float64";
+    // Struct / Group
+    FieldType["STRING"] = "string";
     FieldType["NUMBER"] = "number";
-    FieldType["ARRAY"] = "array";
+    FieldType["BOOLEAN"] = "boolean";
+    // Primitive arrays (Group and Struct)
+    FieldType["ARRAY_STRING"] = "string[]";
+    FieldType["ARRAY_NUMBER"] = "number[]";
+    FieldType["ARRAY_BOOLEAN"] = "boolean[]";
 })(FieldType || (FieldType = {}));
-export var ArrayType;
-(function (ArrayType) {
-    ArrayType["INT_8"] = "int8";
-    ArrayType["INT_16"] = "int16";
-    ArrayType["INT_32"] = "int32";
-    ArrayType["UINT_8"] = "uint8";
-    ArrayType["UINT_16"] = "uint16";
-    ArrayType["UINT_32"] = "uint32";
-    ArrayType["FLOAT_32"] = "float32";
-    ArrayType["FLOAT_64"] = "float64";
-})(ArrayType || (ArrayType = {}));

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

@@ -1,4 +1,4 @@
-import { ArrayType, FieldType } from "../consts.js";
+import { FieldType } from "../consts.js";
 import { addHeader, capitalize } from "./utils.js";
 export function addGroup(header, fields, output) {
     const [name] = header.split(" ");
@@ -9,82 +9,58 @@ 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, fieldArrayType, fieldArrayLength] = field.split(" ");
+    const [fieldName, fieldType] = 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.ARRAY:
-            switch (fieldArrayType) {
-                case ArrayType.INT_8:
-                    output.push(`export const ${fieldName} = new Int8Array(${fieldArrayLength})`);
-                    break;
-                case ArrayType.INT_16:
-                    output.push(`export const ${fieldName} = new Int16Array(${fieldArrayLength})`);
-                    break;
-                case ArrayType.INT_32:
-                    output.push(`export const ${fieldName} = new Int32Array(${fieldArrayLength})`);
-                    break;
-                case ArrayType.UINT_8:
-                    output.push(`export const ${fieldName} = new Uint8Array(${fieldArrayLength})`);
-                    break;
-                case ArrayType.UINT_16:
-                    output.push(`export const ${fieldName} = new Uint16Array(${fieldArrayLength})`);
-                    break;
-                case ArrayType.UINT_32:
-                    output.push(`export const ${fieldName} = new Uint32Array(${fieldArrayLength})`);
-                    break;
-                case ArrayType.FLOAT_32:
-                    output.push(`export const ${fieldName} = new Float32Array(${fieldArrayLength})`);
-                    break;
-                case ArrayType.FLOAT_64:
-                    output.push(`export const ${fieldName} = new Float64Array(${fieldArrayLength})`);
-                    break;
-            }
-            output.push(`export let ${fieldName}Count = 0`);
+        case FieldType.BOOLEAN:
+            output.push(`export let ${fieldName} = false`);
+            break;
+        case FieldType.ARRAY_STRING:
+            output.push(`export const ${fieldName}: Array<string> = []`);
+            break;
+        case FieldType.ARRAY_NUMBER:
+            output.push(`export const ${fieldName}: Array<number> = []`);
+            break;
+        case FieldType.ARRAY_BOOLEAN:
+            output.push(`export const ${fieldName}: Array<boolean> = []`);
             break;
     }
 }
 function addFieldSetFunction(name, field, output) {
     const [fieldName, fieldType] = field.split(" ");
-    if (fieldType === 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("}");
-    }
-}
-function addFieldPushFunction(name, field, output) {
-    const [fieldName, fieldType] = field.split(" ");
-    if (fieldType === FieldType.ARRAY) {
-        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, fieldType] = field.split(" ");
-    if (fieldType === FieldType.ARRAY) {
-        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("}");
+    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) {
@@ -107,11 +83,19 @@ function addZeroFunction(name, fields, output) {
 }
 function zeroField(name, type, output) {
     switch (type) {
+        case FieldType.STRING:
+            output.push(`  ${name} = ""`);
+            break;
         case FieldType.NUMBER:
             output.push(`  ${name} = 0`);
             break;
-        case FieldType.ARRAY:
-            output.push(`  ${name}Count = 0`);
+        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,4 +1,4 @@
-import { ArrayType } from "../consts.js";
+import { FieldType } from "../consts.js";
 import { addHeader, capitalize } from "./utils.js";
 export function addStructureOfArrays(header, fields, output) {
     const [name, , length] = header.split(" ");
@@ -7,10 +7,7 @@ export function addStructureOfArrays(header, fields, output) {
     for (const field of fields) {
         addFieldDefinition(field, length, output);
     }
-    addFieldZeroAtIndexFunction(name, fields, output);
-    for (const field of fields) {
-        addFieldZeroFunction(name, field, output);
-    }
+    addZeroAtIndexFunction(name, fields, output);
     addZeroFunction(name, fields, output);
 }
 function addFieldMaxLengthConstant(name, length, output) {
@@ -20,40 +17,32 @@ function addFieldMaxLengthConstant(name, length, output) {
 function addFieldDefinition(field, length, output) {
     const [fieldName, fieldType] = field.split(" ");
     switch (fieldType) {
-        case ArrayType.INT_8:
+        case FieldType.INT_8:
             output.push(`export const ${fieldName} = new Int8Array(${length})`);
             break;
-        case ArrayType.INT_16:
+        case FieldType.INT_16:
             output.push(`export const ${fieldName} = new Int16Array(${length})`);
             break;
-        case ArrayType.INT_32:
+        case FieldType.INT_32:
             output.push(`export const ${fieldName} = new Int32Array(${length})`);
             break;
-        case ArrayType.UINT_8:
+        case FieldType.UINT_8:
             output.push(`export const ${fieldName} = new Uint8Array(${length})`);
             break;
-        case ArrayType.UINT_16:
+        case FieldType.UINT_16:
             output.push(`export const ${fieldName} = new Uint16Array(${length})`);
             break;
-        case ArrayType.UINT_32:
+        case FieldType.UINT_32:
             output.push(`export const ${fieldName} = new Uint32Array(${length})`);
             break;
-        case ArrayType.FLOAT_32:
+        case FieldType.FLOAT_32:
             output.push(`export const ${fieldName} = new Float32Array(${length})`);
             break;
-        case ArrayType.FLOAT_64:
+        case FieldType.FLOAT_64:
             output.push(`export const ${fieldName} = new Float64Array(${length})`);
             break;
     }
 }
-function addFieldZeroFunction(name, field, output) {
-    const [fieldName] = field.split(" ");
-    output.push("");
-    output.push(`/** Zero the ${fieldName} field within the ${name} structure of arrays. */`);
-    output.push(`export function zero${capitalize(fieldName)}() {`);
-    output.push(`  ${fieldName}.fill(0)`);
-    output.push("}");
-}
 function addZeroFunction(name, fields, output) {
     output.push("");
     output.push(`/** Zero all fields within the ${name} structure of arrays. */`);
@@ -64,7 +53,7 @@ function addZeroFunction(name, fields, output) {
     }
     output.push("}");
 }
-function addFieldZeroAtIndexFunction(name, fields, output) {
+function addZeroAtIndexFunction(name, fields, output) {
     output.push("");
     output.push(`/** Zero an index within the ${name} structure of arrays. */`);
     output.push(`export function zero${capitalize(name)}At(i: number) {`);

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

@@ -2,8 +2,10 @@
 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");
@@ -43,7 +45,13 @@ for (const { header, fields } of blocks) {
         case Type.GROUP:
             addGroup(header, fields, output);
             break;
-        case Type.SOA:
+        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;
     }

package/package.json

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