game-data-gen 3.0.2 → 4.0.0

package/README.md

@@ -31,41 +31,54 @@ npm i -D game-data-gen
 npx game-data-gen <input-file-path> <optional-output-file-path>
 ```
 
+## Supported fields
+
+### group
+
+| 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` |
+
+Array fields without a length generate a `count` variable and `push`/`pop` functions.
+
+### soa (Structure of Arrays)
+
+| Field type | Example        |
+| ---------- | -------------- |
+| `int8`     | `- val int8`   |
+| `int16`    | `- val int16`  |
+| `int32`    | `- val int32`  |
+| `uint8`    | `- val uint8`  |
+| `uint16`   | `- val uint16` |
+| `uint32`   | `- val uint32` |
+| `float32`  | `- x float32`  |
+| `float64`  | `- x float64`  |
+
 ## Example
 
-Create a Markdown file somewhere in your source code (without a file extension).
+Create a Markdown file somewhere in your source code.
 
 For example `src/data.md`:
 
 ```md
 # game group
 
-- activeEntities array entity
-- activeEntityIds array number
 - playerId number
-
-# vector struct
-
-- x number
-- y number
-
-# entity struct
-
-- position vector
-- velocity vector
-<!-- stats -->
-- health number
-<!-- inventory -->
-- items array number
-<!-- flags -->
-- isActive boolean
-
-# entities aos 2048 entity
+- entityIds array uint16
 
 # particle soa 10_000
 
-- type string
-- pos Vector
+- active uint8
+- x float32
+- y float32
 ```
 
 Run the package with (consider making this a script in your package.json):
@@ -83,156 +96,39 @@ This will create or update the `src/data.ts` file (see below). The data and func
  * --------------------------------------------------
  */
 
-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(v: Array<Entity>) {
-  activeEntities = v
-}
-
-/** Set the value of the activeEntityIds field within the game group. */
-export function setActiveEntityIds(v: Array<number>) {
-  activeEntityIds = v
-}
+export let playerId = 0;
+export const entityIds = new Uint16Array();
+export let entityIdsCount = 0;
 
 /** Set the value of the playerId field within the game group. */
 export function setPlayerId(v: number) {
-  playerId = v
+  playerId = v;
 }
 
-/** Zero the activeEntities field within the game group. */
-export function zeroActiveEntities() {
-  activeEntities.length = 0
+/** Push a value onto the entityIds field within the game group. */
+export function pushEntityIds(v: number) {
+  entityIds[entityIdsCount++] = v;
 }
 
-/** Zero the activeEntityIds field within the game group. */
-export function zeroActiveEntityIds() {
-  activeEntityIds.length = 0
+/** Pop a value from the entityIds field within the game group. */
+export function popEntityIds() {
+  return entityIds[--entityIdsCount];
 }
 
 /** Zero the playerId field within the game group. */
 export function zeroPlayerId() {
-  playerId = 0
+  playerId = 0;
 }
 
-/** Zero all fields within the game group. */
-export function zeroGameData() {
-  activeEntities.length = 0
-  activeEntityIds.length = 0
-  playerId = 0
+/** Zero the entityIds field within the game group. */
+export function zeroEntityIds() {
+  entityIdsCount = 0;
 }
 
-/*
- * --------------------------------------------------
- * vector (Struct)
- * --------------------------------------------------
- */
-
-export type Vector = {
-  x: number
-  y: number
-}
-
-/** Create a new Vector object. */
-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
-  obj.y = 0
-}
-
-/*
- * --------------------------------------------------
- * entity (Struct)
- * --------------------------------------------------
- */
-
-export type Entity = {
-  position: Vector
-  velocity: Vector
-  health: number
-  items: Array<number>
-  isActive: boolean
-}
-
-/** Create a new Entity object. */
-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)
- * --------------------------------------------------
- */
-
-export const MAX_ENTITIES_COUNT = 2048
-
-/** An array of Entity objects (structures). */
-export const entities = Array.from({ length: 2048 }, createEntity)
-
-/** Zero all objects within the entities array of structures. */
-export function zeroEntities() {
-  for (let i=0; i<2048; i++) {
-    zeroEntity(entities[i])
-  }
-}
-
-/** Zero an object at a specific index within the entities array of structures. */
-export function zeroEntitiesAt(i: number) {
-  zeroEntity(entities[i])
+/** Zero all fields within the game group. */
+export function zeroGame() {
+  playerId = 0;
+  entityIdsCount = 0;
 }
 
 /*
@@ -241,30 +137,38 @@ export function zeroEntitiesAt(i: number) {
  * --------------------------------------------------
  */
 
-export const MAX_PARTICLE_COUNT = 10_000
+export const MAX_PARTICLE_COUNT = 10_000;
 
-export const type = new Array(10_000).fill("")
-export const pos = Array.from({ length: 10_000 }, createVector)
+export const active = new Uint8Array(10_000);
+export const x = new Float32Array(10_000);
+export const y = new Float32Array(10_000);
 
 /** Zero an index within the particle structure of arrays. */
-export function zeroParticle(i: number) {
-  type[i] = ""
-  zeroVector(pos[i])
+export function zeroParticleAt(i: number) {
+  active[i] = 0;
+  x[i] = 0;
+  y[i] = 0;
+}
+
+/** Zero the active field within the particle structure of arrays. */
+export function zeroActive() {
+  active.fill(0);
 }
 
-/** Zero the type field within the particle structure of arrays. */
-export function zeroType() {
-  type.fill("")
+/** Zero the x field within the particle structure of arrays. */
+export function zeroX() {
+  x.fill(0);
 }
 
-/** Zero the pos field within the particle structure of arrays. */
-export function zeroPos() {
-  pos.forEach(zeroVector)
+/** Zero the y field within the particle structure of arrays. */
+export function zeroY() {
+  y.fill(0);
 }
 
 /** Zero all fields within the particle structure of arrays. */
-export function zeroParticleData() {
-  type.fill("")
-  pos.forEach(zeroVector)
+export function zeroParticle() {
+  active.fill(0);
+  x.fill(0);
+  y.fill(0);
 }
 ```

package/dist/consts.js

@@ -1,20 +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 || (FieldType = {}));
 export var ArrayType;
 (function (ArrayType) {
-    ArrayType["STRING"] = "string";
-    ArrayType["NUMBER"] = "number";
-    ArrayType["BOOLEAN"] = "boolean";
+    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

@@ -4,7 +4,7 @@ export function addArrayOfStructures(header, output) {
     addHeader(`${name} (Array Of Structures)`, output);
     addFieldMaxLengthConstant(name, length, output);
     addArrayOfStructuresDefinition(name, type, length, output);
-    addArrayOfStructuresZeroFunction(name, type, length, output);
+    addArrayOfStructuresZeroFunction(name, type, output);
     addArrayOfStructuresZeroAtIndexFunction(name, type, output);
 }
 function addFieldMaxLengthConstant(name, length, output) {
@@ -15,13 +15,11 @@ 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, type, length, output) {
+function addArrayOfStructuresZeroFunction(name, type, 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(type)}(${name}[i])`);
-    output.push("  }");
+    output.push(`  ${name}.forEach(zero${capitalize(type)})`);
     output.push("}");
 }
 function addArrayOfStructuresZeroAtIndexFunction(name, type, output) {

package/dist/lib/group.js

@@ -1,5 +1,5 @@
-import { FieldType } from "../consts.js";
-import { addHeader, capitalize, getTypeName } from "./utils.js";
+import { ArrayType, FieldType } from "../consts.js";
+import { addHeader, capitalize } from "./utils.js";
 export function addGroup(header, fields, output) {
     const [name] = header.split(" ");
     addHeader(`${name} (Group)`, output);
@@ -9,71 +9,121 @@ 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] = field.split(" ");
+    const [fieldName, fieldType, fieldArrayType, fieldArrayLength = ""] = 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)}>()`);
+            {
+                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;
+                }
+                if (isDynamicArray(fieldType, fieldArrayLength)) {
+                    output.push(`export let ${fieldName}Count = 0`);
+                }
+            }
             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("}");
+    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, , fieldArrayLength] = field.split(" ");
+    if (isDynamicArray(fieldType, fieldArrayLength)) {
+        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, , fieldArrayLength] = field.split(" ");
+    if (isDynamicArray(fieldType, fieldArrayLength)) {
+        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("}");
+    }
 }
 function addFieldZeroFunction(name, field, output) {
-    const [fieldName, fieldType] = field.split(" ");
+    const [fieldName, fieldType, , fieldArrayLength = ""] = 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);
+    zeroField(fieldName, fieldType, fieldArrayLength, 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() {`);
+    output.push(`export function zero${capitalize(name)}() {`);
     for (const field of fields) {
-        const [fieldName, fieldType] = field.split(" ");
-        zeroField(fieldName, fieldType, output);
+        const [fieldName, fieldType, , fieldArrayLength = ""] = field.split(" ");
+        zeroField(fieldName, fieldType, fieldArrayLength, output);
     }
     output.push("}");
 }
-function zeroField(name, type, output) {
+function zeroField(name, type, arrayLength, 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`);
+            if (isDynamicArray(type, arrayLength)) {
+                output.push(`  ${name}Count = 0`);
+            }
+            else {
+                output.push(`  ${name}.fill(0)`);
+            }
             break;
-        default:
-            output.push(`  zero${capitalize(type)}(${name})`);
     }
 }
+function isDynamicArray(fieldType, fieldArrayLength) {
+    return fieldType === FieldType.ARRAY && !fieldArrayLength;
+}

package/dist/lib/soa.js

@@ -1,7 +1,7 @@
 import { ArrayType } 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) {
@@ -20,71 +20,57 @@ function addFieldMaxLengthConstant(name, length, output) {
 function addFieldDefinition(field, length, output) {
     const [fieldName, fieldType] = field.split(" ");
     switch (fieldType) {
-        case ArrayType.STRING:
-            output.push(`export const ${fieldName} = new Array<string>(${length}).fill("")`);
+        case ArrayType.INT_8:
+            output.push(`export const ${fieldName} = new Int8Array(${length})`);
             break;
-        case ArrayType.NUMBER:
-            output.push(`export const ${fieldName} = new Array<number>(${length}).fill(0)`);
+        case ArrayType.INT_16:
+            output.push(`export const ${fieldName} = new Int16Array(${length})`);
             break;
-        case ArrayType.BOOLEAN:
-            output.push(`export const ${fieldName} = new Array<boolean>(${length}).fill(false)`);
+        case ArrayType.INT_32:
+            output.push(`export const ${fieldName} = new Int32Array(${length})`);
+            break;
+        case ArrayType.UINT_8:
+            output.push(`export const ${fieldName} = new Uint8Array(${length})`);
+            break;
+        case ArrayType.UINT_16:
+            output.push(`export const ${fieldName} = new Uint16Array(${length})`);
+            break;
+        case ArrayType.UINT_32:
+            output.push(`export const ${fieldName} = new Uint32Array(${length})`);
+            break;
+        case ArrayType.FLOAT_32:
+            output.push(`export const ${fieldName} = new Float32Array(${length})`);
+            break;
+        case ArrayType.FLOAT_64:
+            output.push(`export const ${fieldName} = new Float64Array(${length})`);
             break;
-        default:
-            output.push(`export const ${fieldName} = Array.from({ length: ${length} }, create${capitalize(fieldType)})`);
     }
 }
 function addFieldZeroFunction(name, field, output) {
-    const [fieldName, fieldType] = field.split(" ");
+    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)}() {`);
-    zeroField(fieldName, fieldType, output);
+    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. */`);
-    output.push(`export function zero${capitalize(name)}Data() {`);
+    output.push(`export function zero${capitalize(name)}() {`);
     for (const field of fields) {
-        const [fieldName, fieldType] = field.split(" ");
-        zeroField(fieldName, fieldType, output);
+        const [fieldName] = field.split(" ");
+        output.push(`  ${fieldName}.fill(0)`);
     }
     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)})`);
-    }
-}
 function addFieldZeroAtIndexFunction(name, fields, output) {
     output.push("");
     output.push(`/** Zero an index within the ${name} structure of arrays. */`);
-    output.push(`export function zero${capitalize(name)}(i: number) {`);
+    output.push(`export function zero${capitalize(name)}At(i: number) {`);
     for (const field of fields) {
-        const [fieldName, fieldType] = field.split(" ");
-        switch (fieldType) {
-            case ArrayType.STRING:
-                output.push(`  ${fieldName}[i] = ""`);
-                break;
-            case ArrayType.NUMBER:
-                output.push(`  ${fieldName}[i] = 0`);
-                break;
-            case ArrayType.BOOLEAN:
-                output.push(`  ${fieldName}[i] = false`);
-                break;
-            default:
-                output.push(`  zero${capitalize(fieldType)}(${fieldName}[i])`);
-        }
+        const [fieldName] = field.split(" ");
+        output.push(`  ${fieldName}[i] = 0`);
     }
     output.push("}");
 }

package/dist/lib/struct.js

@@ -12,8 +12,8 @@ export function addStruct(header, 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}: ${getTypeName(fieldType, fieldArrayType)}`);
+        const [fieldName, fieldType] = field.split(" ");
+        output.push(`  ${fieldName}: ${getTypeName(fieldType)}`);
     }
     output.push("}");
 }
@@ -23,23 +23,19 @@ function addStructCreateFunction(name, fields, output) {
     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] = field.split(" ");
+        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.ARRAY:
-                output.push(`  obj.${fieldName} = new Array<${getTypeName(fieldArrayType)}>()`);
+            case FieldType.NUMBER:
+                output.push(`  obj.${fieldName} = 0`);
                 break;
-            default: {
+            default:
                 output.push(`  obj.${fieldName} = create${capitalize(fieldType)}()`);
-            }
         }
     }
     output.push("  return obj");
@@ -74,14 +70,11 @@ function addStructZeroFunction(name, fields, output) {
             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:
-                output.push(`  obj.${fieldName}.length = 0`);
+            case FieldType.NUMBER:
+                output.push(`  obj.${fieldName} = 0`);
                 break;
             default:
                 output.push(`  zero${capitalize(fieldType)}(obj.${fieldName})`);

package/dist/lib/utils.js

@@ -1,4 +1,3 @@
-import { FieldType, Type } from "../consts.js";
 export function addHeader(name, output) {
     output.push("");
     output.push("/*");
@@ -8,34 +7,6 @@ export function addHeader(name, output) {
     output.push(" */");
     output.push("");
 }
-/**
- * Get the name based on the type of the data structure.
- */
-export function getTypeName(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<${getTypeName(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,45 +1,51 @@
 #!/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 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
-    .replace(/^# (.+)\n\n- /gm, "$1\n")
-    .replace(/^# /gm, "")
-    .replace(/^- /gm, "")
-    .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();
-    if (!header)
-        continue;
-    const [_, type] = header.split(" ");
-    switch (type) {
-        case Type.STRUCT:
-            addStruct(header, fields, output);
+const tokens = marked.lexer(input);
+const blocks = [];
+let block = {
+    header: "",
+    fields: [],
+};
+for (const token of tokens) {
+    switch (token.type) {
+        case "heading":
+            {
+                block = {
+                    header: token.text,
+                    fields: [],
+                };
+                blocks.push(block);
+            }
+            break;
+        case "list":
+            {
+                for (const item of token.items) {
+                    block.fields.push(item.text);
+                }
+            }
             break;
+    }
+}
+for (const { header, fields } of blocks) {
+    const [, type] = header.split(" ");
+    switch (type) {
         case Type.GROUP:
             addGroup(header, fields, output);
             break;
         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,6 +1,6 @@
 {
   "name": "game-data-gen",
-  "version": "3.0.2",
+  "version": "4.0.0",
   "type": "module",
   "files": [
     "dist"
@@ -20,5 +20,8 @@
     "@biomejs/biome": "^2.4.11",
     "@types/node": "^24.12.2",
     "typescript": "^6.0.2"
+  },
+  "dependencies": {
+    "marked": "^18.0.2"
   }
 }

package/dist/lib/fields.js

@@ -1,106 +0,0 @@
-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;
-                    default:
-                        output.push(`export let ${fieldName} = new Array<${getName(fieldArrayType)}>()`);
-                }
-            }
-            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;
-                    default:
-                        output.push(`  ${name}.length = 0`);
-                }
-            }
-            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()} = ${length}`);
-    output.push("");
-}