game-data-gen 1.2.1 → 2.1.0

package/README.md

@@ -34,7 +34,7 @@ npx game-data-gen <input-file-path> <optional-output-file-path>
 ## Format
 
 ```
-name type? length?
+name type? length? struct?
 fieldName fieldType fieldArrayType? fieldArrayLength?
 ```
 
@@ -42,13 +42,14 @@ fieldName fieldType fieldArrayType? fieldArrayLength?
 
 The name of the data structure.
 
-`type` (optional)
+`type`
 
 Supported data structure types:
 
+- group
+- struct
 - soa (Structure of Arrays)
-
-If no type is given, it will act as a group which gets a zero function for the whole group.
+- aos (Array of Structures)
 
 `length` (optional)
 
@@ -56,6 +57,10 @@ 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.
@@ -64,30 +69,27 @@ The name of one of the fields within the data structure.
 
 Supported field types:
 
+- string
+- number
+- boolean
 - array
+- a struct (see entity struct in example below)
 
-`fieldArrayType` (optional, required if fieldType=array)
+`fieldArrayType` (required if fieldType=array)
 
 Supported array field types:
 
 - string
 - boolean
 - number
-- int8
-- int16
-- int32
-- uint8
-- uint16
-- uint32
-- float32
-- float64
 
 `fieldArrayLength` (optional)
 
-The length of the array field.
+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).
@@ -95,13 +97,24 @@ Create a plain text file somewhere in your source code (without a file extension
 For example `src/data/game`:
 
 ```
-Game
+game group
 activeEntities array number
 
-Entity soa 2048
-posX array float32
-posY array float32
-isActive array uint8
+vector struct
+x number
+y number
+
+entity struct
+position vector
+velocity vector
+health number
+isActive boolean
+
+entities aos 2048 entity
+
+particle soa 1024
+posX array number
+posY array number
 ```
 
 Run the package with (consider making this a script in your package.json):
@@ -110,67 +123,134 @@ Run the package with (consider making this a script in your package.json):
 npx game-data-gen src/data/game
 ```
 
-This will create or update the `src/data/game.ts` file:
+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.
 
 ```typescript
 /*
  * --------------------------------------------------
- * Game (group)
+ * game (group)
  * --------------------------------------------------
  */
 
-export const activeEntities = new Array<number>();
+export const activeEntities = new Array<number>()
 
-/** Zero the activeEntities field within the Game group. */
+/** Zero the activeEntities field within the game group. */
 export function zeroActiveEntities() {
-  activeEntities.length = 0;
+  activeEntities.length = 0
 }
 
-/** Zero all fields within the Game group. */
+/** Zero all fields within the game group. */
 export function zeroGameData() {
-  activeEntities.length = 0;
+  activeEntities.length = 0
 }
 
 /*
  * --------------------------------------------------
- * Entity (Structure of Arrays)
+ * vector (struct)
  * --------------------------------------------------
  */
 
-export const MAX_ENTITY_COUNT = 2048;
+export type Vector = {
+  x: number
+  y: number
+}
 
-export const posX = new Float32Array(2048);
-export const posY = new Float32Array(2048);
-export const isActive = new Uint8Array(2048);
+/** Create a new Vector object. */
+export function createVector(): Vector {
+  const obj = Object.create(null)
+  obj.x = 0
+  obj.y = 0
+  return obj
+}
 
-/** Zero an index within the Entity Structure of Arrays. */
-export function zeroEntity(idx: number) {
-  posX[idx] = 0;
-  posY[idx] = 0;
-  isActive[idx] = 0;
+/** Zero the given Vector object. */
+export function zeroVector(obj: Vector) {
+  obj.x = 0
+  obj.y = 0
 }
 
-/** Zero the posX field within the Entity Structure of Arrays. */
-export function zeroPosX() {
-  posX.fill(0);
+/*
+ * --------------------------------------------------
+ * entity (struct)
+ * --------------------------------------------------
+ */
+
+export type Entity = {
+  position: Vector
+  velocity: Vector
+  health: number
+  isActive: boolean
 }
 
-/** Zero the posY field within the Entity Structure of Arrays. */
-export function zeroPosY() {
-  posY.fill(0);
+/** Create a new Entity object. */
+export function createEntity(): Entity {
+  const obj = Object.create(null)
+  obj.position = createVector()
+  obj.velocity = createVector()
+  obj.health = 0
+  obj.isActive = false
+  return obj
 }
 
-/** Zero the isActive field within the Entity Structure of Arrays. */
-export function zeroIsActive() {
-  isActive.fill(0);
+/** Zero the given Entity object. */
+export function zeroEntity(obj: Entity) {
+  zeroVector(obj.position)
+  zeroVector(obj.velocity)
+  obj.health = 0
+  obj.isActive = false
 }
 
-/** Zero all fields within the Entity Structure of Arrays. */
-export function zeroEntityData() {
-  posX.fill(0);
-  posY.fill(0);
-  isActive.fill(0);
+/*
+ * --------------------------------------------------
+ * 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()
 }
-```
 
-Then import the data and its functions from `src/data/game.ts` in your code.
+/** Zero all objects within the entities array of structures. */
+export function zeroEntities() {
+  for (let i=0; i<2048; i++) {
+    zeroEntity(entities[i])
+  }
+}
+
+/*
+ * --------------------------------------------------
+ * particle (structure of arrays)
+ * --------------------------------------------------
+ */
+
+export const MAX_PARTICLE_COUNT = 1024
+
+export const posX = new Array<number>(1024).fill(0)
+export const posY = new Array<number>(1024).fill(0)
+
+/** Zero an index within the particle structure of arrays. */
+export function zeroParticle(idx: number) {
+  posX[idx] = 0
+  posY[idx] = 0
+}
+
+/** Zero the posX field within the particle structure of arrays. */
+export function zeroPosX() {
+  posX.fill(0)
+}
+
+/** Zero the posY field within the particle structure of arrays. */
+export function zeroPosY() {
+  posY.fill(0)
+}
+
+/** Zero all fields within the particle structure of arrays. */
+export function zeroParticleData() {
+  posX.fill(0)
+  posY.fill(0)
+}
+```

package/dist/consts.js

@@ -0,0 +1,21 @@
+export var Type;
+(function (Type) {
+    Type["SOA"] = "soa";
+    Type["AOS"] = "aos";
+    Type["STRUCT"] = "struct";
+    Type["GROUP"] = "group";
+})(Type || (Type = {}));
+export var FieldType;
+(function (FieldType) {
+    FieldType["STRING"] = "string";
+    FieldType["NUMBER"] = "number";
+    FieldType["BOOLEAN"] = "boolean";
+    FieldType["ARRAY"] = "array";
+    FieldType["SET"] = "set";
+})(FieldType || (FieldType = {}));
+export var ArrayType;
+(function (ArrayType) {
+    ArrayType["STRING"] = "string";
+    ArrayType["NUMBER"] = "number";
+    ArrayType["BOOLEAN"] = "boolean";
+})(ArrayType || (ArrayType = {}));

package/dist/lib/aos.js

@@ -0,0 +1,32 @@
+import { addFieldMaxLengthConstant } from "./fields.js";
+import { capitalize, getName } from "./utils.js";
+export function addArrayOfStructures(header, output) {
+    const [name, , length, struct] = header.split(" ");
+    addFieldMaxLengthConstant(name, length, output);
+    addArrayOfStructuresDefinition(name, struct, length, output);
+    addArrayOfStructuresZeroFunction(name, struct, length, output);
+    addArrayOfStructuresZeroAtIndexFunction(name, struct, 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 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(`  for (let i=0; i<${length}; i++) {`);
+    output.push(`    zero${capitalize(struct)}(${name}[i])`);
+    output.push("  }");
+    output.push("}");
+}
+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(struct)}At(index: number) {`);
+    output.push(`  zero${capitalize(struct)}(${name}[index])`);
+    output.push("}");
+}

package/dist/lib/fields.js

@@ -0,0 +1,102 @@
+import { ArrayType, FieldType } from "../consts.js";
+import { capitalize, getName } from "./utils.js";
+export function addFieldDefinition(field, baseLength, output) {
+    const [fieldName, fieldType, fieldArrayType, fieldLength] = field.split(" ");
+    const fieldArrayLength = baseLength || fieldLength || "";
+    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:
+            {
+                switch (fieldArrayType) {
+                    case ArrayType.STRING:
+                        output.push(`export let ${fieldName} = new Array<string>(${fieldArrayLength})${fieldArrayLength ? '.fill("")' : ""}`);
+                        break;
+                    case ArrayType.NUMBER:
+                        output.push(`export let ${fieldName} = new Array<number>(${fieldArrayLength})${fieldArrayLength ? ".fill(0)" : ""}`);
+                        break;
+                    case ArrayType.BOOLEAN:
+                        output.push(`export let ${fieldName} = new Array<boolean>(${fieldArrayLength})${fieldArrayLength ? ".fill(false)" : ""}`);
+                        break;
+                }
+            }
+            break;
+        case FieldType.SET:
+            output.push(`export let ${fieldName} = new Set<${getName(fieldArrayType)}>()`);
+            break;
+        default:
+            output.push(`export let ${fieldName} = create${capitalize(fieldType)}()`);
+    }
+}
+export function addFieldSetFunction(name, type, field, output) {
+    const [fieldName, fieldType, fieldArrayType] = field.split(" ");
+    output.push("");
+    output.push(`/** Set the value of the ${fieldName} field within the ${name} ${getName(type)}. */`);
+    output.push(`export function set${capitalize(fieldName)}(value: ${getName(fieldType, fieldArrayType)}) {`);
+    output.push(`  ${fieldName} = value`);
+    output.push("}");
+}
+export function addFieldZeroFunction(name, type, field, baseLength, output) {
+    const [fieldName, fieldType, fieldArrayType, fieldLength] = field.split(" ");
+    const length = baseLength || fieldLength || "";
+    output.push("");
+    output.push(`/** Zero the ${fieldName} field within the ${name} ${getName(type)}. */`);
+    output.push(`export function zero${capitalize(fieldName)}() {`);
+    zeroField(fieldName, fieldType, fieldArrayType, length, output);
+    output.push("}");
+}
+export function addZeroFunction(name, type, fields, baseLength, output) {
+    output.push("");
+    output.push(`/** Zero all fields within the ${name} ${getName(type)}. */`);
+    output.push(`export function zero${capitalize(name)}Data() {`);
+    for (const field of fields) {
+        const [fieldName, fieldType, fieldArrayType, fieldLength] = field.split(" ");
+        const length = baseLength || fieldLength || "";
+        zeroField(fieldName, fieldType, fieldArrayType, length, output);
+    }
+    output.push("}");
+}
+function zeroField(name, type, arrayType, length, 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:
+            {
+                switch (arrayType) {
+                    case ArrayType.STRING:
+                        output.push(`  ${name}.${length ? 'fill("")' : "length = 0"}`);
+                        break;
+                    case ArrayType.NUMBER:
+                        output.push(`  ${name}.${length ? "fill(0)" : "length = 0"}`);
+                        break;
+                    case ArrayType.BOOLEAN:
+                        output.push(`  ${name}.${length ? "fill(false)" : "length = 0"}`);
+                        break;
+                }
+            }
+            break;
+        case FieldType.SET:
+            output.push(`  ${name}.clear()`);
+            break;
+        default:
+            output.push(`  zero${capitalize(type)}(${name})`);
+    }
+}
+export function addFieldMaxLengthConstant(name, length, output) {
+    output.push(`export const MAX_${name.toUpperCase()}_COUNT = ${length}`);
+    output.push("");
+}

package/dist/lib/group.js

@@ -0,0 +1,14 @@
+import { addFieldDefinition, addFieldSetFunction, addFieldZeroFunction, addZeroFunction } from "./fields.js";
+export function addGroup(header, fields, output) {
+    const [name, type, baseLength] = header.split(" ");
+    for (const field of fields) {
+        addFieldDefinition(field, baseLength, output);
+    }
+    for (const field of fields) {
+        addFieldSetFunction(name, type, field, output);
+    }
+    for (const field of fields) {
+        addFieldZeroFunction(name, type, field, baseLength, output);
+    }
+    addZeroFunction(name, type, fields, baseLength, output);
+}

package/dist/lib/soa.js

@@ -0,0 +1,38 @@
+import { ArrayType } from "../consts.js";
+import { addFieldDefinition, addFieldMaxLengthConstant, addFieldSetFunction, addFieldZeroFunction, addZeroFunction } from "./fields.js";
+import { capitalize, getName } from "./utils.js";
+export function addStructureOfArrays(header, fields, output) {
+    const [name, type, baseLength] = header.split(" ");
+    addFieldMaxLengthConstant(name, baseLength, output);
+    for (const field of fields) {
+        addFieldDefinition(field, baseLength, output);
+    }
+    for (const field of fields) {
+        addFieldSetFunction(name, type, field, output);
+    }
+    addFieldZeroAtIndexFunction(name, type, fields, output);
+    for (const field of fields) {
+        addFieldZeroFunction(name, type, field, baseLength, output);
+    }
+    addZeroFunction(name, type, fields, baseLength, output);
+}
+function addFieldZeroAtIndexFunction(name, type, fields, output) {
+    output.push("");
+    output.push(`/** Zero an index within the ${name} ${getName(type)}. */`);
+    output.push(`export function zero${capitalize(name)}(idx: number) {`);
+    for (const field of fields) {
+        const [fieldName, _, fieldArrayType] = field.split(" ");
+        switch (fieldArrayType) {
+            case ArrayType.STRING:
+                output.push(`  ${fieldName}[idx] = ""`);
+                break;
+            case ArrayType.NUMBER:
+                output.push(`  ${fieldName}[idx] = 0`);
+                break;
+            case ArrayType.BOOLEAN:
+                output.push(`  ${fieldName}[idx] = false`);
+                break;
+        }
+    }
+    output.push("}");
+}

package/dist/lib/struct.js

@@ -0,0 +1,99 @@
+import { ArrayType, FieldType } from "../consts.js";
+import { capitalize, getName } from "./utils.js";
+export function addStruct(header, fields, output) {
+    const [name] = header.split(" ");
+    addStructTypeDefinition(name, fields, output);
+    addStructCreateFunction(name, fields, 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("}");
+}
+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)`);
+    for (const field of fields) {
+        const [fieldName, fieldType, fieldArrayType, fieldArrayLength = ""] = 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.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;
+                    }
+                }
+                break;
+            case FieldType.SET:
+                output.push(`  obj.${fieldName} = new Set<${getName(fieldArrayType)}>()`);
+                break;
+            default: {
+                output.push(`  obj.${fieldName} = create${capitalize(fieldType)}()`);
+            }
+        }
+    }
+    output.push("  return obj");
+    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)}) {`);
+    for (const field of fields) {
+        const [fieldName, fieldType, fieldArrayType, fieldArrayLength] = 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.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;
+                    }
+                }
+                break;
+            case FieldType.SET:
+                output.push(`  obj.${fieldName}.clear()`);
+                break;
+            default:
+                output.push(`  zero${capitalize(fieldType)}(obj.${fieldName})`);
+        }
+    }
+    output.push("}");
+}

package/dist/lib/utils.js

@@ -0,0 +1,34 @@
+import { FieldType, Type } from "../consts.js";
+/**
+ * Get the name based on the type of the data structure.
+ */
+export function getName(type, arrayType = "") {
+    switch (type) {
+        case Type.SOA:
+            return "structure of arrays";
+        case Type.AOS:
+            return "array of structures";
+        case Type.STRUCT:
+            return "struct";
+        case Type.GROUP:
+            return "group";
+        case FieldType.STRING:
+            return "string";
+        case FieldType.NUMBER:
+            return "number";
+        case FieldType.BOOLEAN:
+            return "boolean";
+        case FieldType.ARRAY:
+            return `Array<${getName(arrayType)}>`;
+        case FieldType.SET:
+            return `Set<${getName(arrayType)}>`;
+        default:
+            return capitalize(type);
+    }
+}
+/**
+ * Capitalize the first letter of a string.
+ */
+export function capitalize(str) {
+    return `${str.substring(0, 1).toUpperCase()}${str.substring(1)}`;
+}

package/dist/main.js

@@ -1,175 +1,45 @@
 #!/usr/bin/env node
-
-// src/main.ts
-import fs from "fs";
-var inputFile = process.argv[2];
-var outputFile = process.argv[3] || `${inputFile}.ts`;
-var input = fs.readFileSync(inputFile, "utf-8");
-var output = [];
+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 input = fs.readFileSync(inputFile, "utf-8");
+const output = [];
 output.push("/*");
-output.push(` * Generated with game-data-gen on ${(/* @__PURE__ */ new Date()).toLocaleString()}. DO NOT MODIFY THIS FILE!`);
+output.push(` * Generated with game-data-gen on ${new Date().toLocaleString()}. DO NOT MODIFY THIS FILE!`);
 output.push(" */");
-var blocks = input.trim().split("\n\n");
+const blocks = input.trim().split("\n\n");
 for (const block of blocks) {
-  const fields = block.split("\n");
-  const header = fields.shift();
-  if (!header) continue;
-  const [name, type, baseLength] = header.split(" ");
-  output.push("");
-  output.push("/*");
-  output.push(` * ${"-".repeat(50)}`);
-  output.push(` * ${name} (${getTypeName(type)})`);
-  output.push(` * ${"-".repeat(50)}`);
-  output.push(" */");
-  output.push("");
-  if (type === "soa" /* SOA */) {
-    output.push(`export const MAX_${name.toUpperCase()}_COUNT = ${baseLength}`);
+    const fields = block.split("\n");
+    const header = fields.shift();
+    if (!header)
+        continue;
+    const [name, type] = header.split(" ");
     output.push("");
-  }
-  for (const field of fields) {
-    const [fieldName, fieldType, fieldArrayType, fieldLength] = field.split(" ");
-    const length = baseLength || fieldLength || "";
-    switch (fieldType) {
-      case "string" /* STRING */:
-        output.push(`export let ${fieldName} = ""`);
-        break;
-      case "boolean" /* BOOLEAN */:
-        output.push(`export let ${fieldName} = false`);
-        break;
-      case "number" /* NUMBER */:
-        output.push(`export let ${fieldName} = 0`);
-        break;
-      case "array" /* ARRAY */:
-        {
-          switch (fieldArrayType) {
-            case "int8" /* INT8 */:
-              output.push(`export const ${fieldName} = new Int8Array(${length})`);
-              break;
-            case "int16" /* INT16 */:
-              output.push(`export const ${fieldName} = new Int16Array(${length})`);
-              break;
-            case "int32" /* INT32 */:
-              output.push(`export const ${fieldName} = new Int32Array(${length})`);
-              break;
-            case "uint8" /* UINT8 */:
-              output.push(`export const ${fieldName} = new Uint8Array(${length})`);
-              break;
-            case "uint16" /* UINT16 */:
-              output.push(`export const ${fieldName} = new Uint16Array(${length})`);
-              break;
-            case "uint32" /* UINT32 */:
-              output.push(`export const ${fieldName} = new Uint32Array(${length})`);
-              break;
-            case "float32" /* FLOAT32 */:
-              output.push(`export const ${fieldName} = new Float32Array(${length})`);
-              break;
-            case "float64" /* FLOAT64 */:
-              output.push(`export const ${fieldName} = new Float64Array(${length})`);
-              break;
-            case "string" /* STRING */:
-              output.push(`export const ${fieldName} = new Array<string>(${length})${length ? '.fill("")' : ""}`);
-              break;
-            case "boolean" /* BOOLEAN */:
-              output.push(`export const ${fieldName} = new Array<boolean>(${length})${length ? ".fill(false)" : ""}`);
-              break;
-            case "number" /* NUMBER */:
-              output.push(`export const ${fieldName} = new Array<number>(${length})${length ? ".fill(0)" : ""}`);
-              break;
-            default:
-              output.push(`export const ${fieldName} = new Array<${fieldArrayType}>(${length})`);
-          }
-        }
-        break;
-    }
-  }
-  for (const field of fields) {
-    const [fieldName, fieldType] = field.split(" ");
-    switch (fieldType) {
-      case "string" /* STRING */:
-      case "boolean" /* BOOLEAN */:
-      case "number" /* NUMBER */:
-        output.push("");
-        output.push(`/** Set the value of the ${fieldName} field within the ${name} ${getTypeName(type)}. */`);
-        output.push(`export function set${capitalize(fieldName)}(value: ${fieldType}) {`);
-        output.push(`  ${fieldName} = value`);
-        output.push("}");
-        break;
-    }
-  }
-  if (type === "soa" /* SOA */) {
+    output.push("/*");
+    output.push(` * ${"-".repeat(50)}`);
+    output.push(` * ${name} (${getName(type)})`);
+    output.push(` * ${"-".repeat(50)}`);
+    output.push(" */");
     output.push("");
-    output.push(`/** Zero an index within the ${name} ${getTypeName(type)}. */`);
-    output.push(`export function zero${capitalize(name)}(idx: number) {`);
-    for (const field of fields) {
-      const [fieldName, _, fieldArrayType] = field.split(" ");
-      switch (fieldArrayType) {
-        case "string" /* STRING */:
-          output.push(`  ${fieldName}[idx] = ""`);
-          break;
-        case "boolean" /* BOOLEAN */:
-          output.push(`  ${fieldName}[idx] = false`);
-          break;
-        default:
-          output.push(`  ${fieldName}[idx] = 0`);
-      }
-    }
-    output.push("}");
-  }
-  for (const field of fields) {
-    const [fieldName, fieldType, fieldArrayType, fieldLength] = field.split(" ");
-    const length = baseLength || fieldLength || "";
-    output.push("");
-    output.push(`/** Zero the ${fieldName} field within the ${name} ${getTypeName(type)}. */`);
-    output.push(`export function zero${capitalize(fieldName)}() {`);
-    zeroField(fieldName, fieldType, fieldArrayType, length);
-    output.push("}");
-  }
-  output.push("");
-  output.push(`/** Zero all fields within the ${name} ${getTypeName(type)}. */`);
-  output.push(`export function zero${capitalize(name)}Data() {`);
-  for (const field of fields) {
-    const [fieldName, fieldType, fieldArrayType, fieldLength] = field.split(" ");
-    const length = baseLength || fieldLength || "";
-    zeroField(fieldName, fieldType, fieldArrayType, length);
-  }
-  output.push("}");
-}
-function zeroField(name, type, arrayType, length) {
-  switch (type) {
-    case "string" /* STRING */:
-      output.push(`  ${name} = ""`);
-      break;
-    case "boolean" /* BOOLEAN */:
-      output.push(`  ${name} = false`);
-      break;
-    case "number" /* NUMBER */:
-      output.push(`  ${name} = 0`);
-      break;
-    case "array" /* ARRAY */:
-      {
-        switch (arrayType) {
-          case "string" /* STRING */:
-            output.push(`  ${name}.${length ? 'fill("")' : "length = 0"}`);
+    switch (type) {
+        case Type.STRUCT:
+            addStruct(header, fields, output);
             break;
-          case "boolean" /* BOOLEAN */:
-            output.push(`  ${name}.${length ? "fill(false)" : "length = 0"}`);
+        case Type.GROUP:
+            addGroup(header, fields, output);
             break;
-          default:
-            output.push(`  ${name}.${length ? "fill(0)" : "length = 0"}`);
-        }
-      }
-      break;
-  }
-}
-function getTypeName(type) {
-  switch (type) {
-    case "soa" /* SOA */:
-      return "Structure of Arrays";
-    default:
-      return "group";
-  }
-}
-function capitalize(str) {
-  return `${str.substring(0, 1).toUpperCase()}${str.substring(1)}`;
+        case Type.SOA:
+            addStructureOfArrays(header, fields, output);
+            break;
+        case Type.AOS:
+            addArrayOfStructures(header, output);
+            break;
+    }
 }
 fs.writeFileSync(outputFile, output.join("\n"));

package/package.json

@@ -1,24 +1,24 @@
 {
   "name": "game-data-gen",
-  "version": "1.2.1",
+  "version": "2.1.0",
   "type": "module",
   "files": [
     "dist"
   ],
-  "bin": "dist/main.js",
+  "bin": {
+    "game-data-gen": "dist/main.js"
+  },
   "scripts": {
-    "start": "tsx watch src/main.ts tests/data",
-    "build": "tsc && esbuild src/main.ts --bundle --platform=node --format=esm --target=es6 --outdir=dist --banner:js='#!/usr/bin/env node'",
-    "test": "npm run build && npx game-data-gen tests/data"
+    "start": "tsc && node dist/main.js tests/data",
+    "build": "biome check && tsc"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/patrickswijgman/game-data-gen"
+    "url": "git+https://github.com/patrickswijgman/game-data-gen.git"
   },
   "devDependencies": {
-    "@types/node": "^22.15.18",
-    "esbuild": "^0.25.4",
-    "tsx": "^4.19.4",
-    "typescript": "~5.8.3"
+    "@biomejs/biome": "^2.4.11",
+    "@types/node": "^24.12.2",
+    "typescript": "^6.0.2"
   }
 }