t2-demo-parser 2.2.0 → 3.0.0

package/dist/DataBlockParsers.js

@@ -7,6 +7,8 @@
  * getBitCount(getNextPow2(0x800)) = 11 bits.
  * If flag is false, sets objectId to -1 (0xFFFFFFFF).
  */
+/** particleEngine.cc: PDC_MAX_TEX. */
+const ParticleDataMaxTextures = 50;
 function readDataBlockRef(bs) {
     return bs.readFlag() ? bs.readInt(11) : null;
 }
@@ -22,6 +24,11 @@ function readRangedS32(bs, min, max) {
  * From decompiled binary: FUN_0043f040 calls FUN_0043efe0 which reads 4 × stream->read(1, &byte).
  * Each byte is multiplied by 1/255.0 to produce the float value.
  * NOTE: This is NOT 4×F32 (128 bits) — it's 4×U8 (32 bits).
+ *
+ * Colour representation follows the engine's own field type: fields the
+ * engine stores as ColorF (this reader) are normalised to [0, 1]; fields
+ * it stores as ColorI (sensorColor, sensor group colours) keep the raw
+ * 0–255 bytes.
  */
 function readColorF(bs) {
     return {
@@ -37,13 +44,23 @@ function readColorF(bs) {
  * Many DataBlock fields use write(sizeof(bool)) instead of writeFlag().
  */
 function readBool(bs) {
-    return bs.readInt(8) !== 0;
+    return bs.readBool();
+}
+/** Read a ranged float: min + readFloat(bits) * (max - min). */
+function readRangedF32(bs, min, max, bits) {
+    return min + bs.readFloat(bits) * (max - min);
 }
 /**
- * Read a ranged float: min + readInt(bits) / ((1 << bits) - 1) * (max - min).
+ * Read a U32 count and reject it unless `minBitsPerEntry × count` bits
+ * remain: exhausted reads return 0 without throwing, so a corrupt count
+ * would otherwise spin allocating until memory ran out.
  */
-function readRangedF32(bs, min, max, bits) {
-    return min + (bs.readInt(bits) / ((1 << bits) - 1)) * (max - min);
+function readCheckedCount(bs, minBitsPerEntry, what) {
+    const count = bs.readU32();
+    if (count > bs.getRemainingBits() / minBitsPerEntry) {
+        throw new Error(`Invalid ${what}: ${count}`);
+    }
+    return count;
 }
 // ============================================================
 // Base class parsers (inheritance chain)
@@ -90,6 +107,7 @@ function shapeBaseDataUnpack(bs) {
     result.debrisShapeName = bs.readString();
     // sensorRadius — flag; if true: readInt(10) + 4×U8 (RGBA bytes)
     // Binary: readInt(10) → this+0x15c (cast to float), then 4 × read(1) → 0x160-0x163
+    // sensorColor is a ColorI in the engine, so the bytes are kept as-is.
     if (bs.readFlag()) {
         result.sensorRadius = bs.readInt(10);
         result.sensorColor = {
@@ -134,11 +152,7 @@ function shapeBaseDataUnpack(bs) {
     // Binary: readFlag, if true: read(4) × 3 → this+0x98, 0x9c, 0xa0
     // NOTE: This field is NOT in the V12 reference source — Tribes 2 addition.
     if (bs.readFlag()) {
-        result.shieldEffectScale = {
-            x: bs.readF32(),
-            y: bs.readF32(),
-            z: bs.readF32(),
-        };
+        result.shieldEffectScale = bs.readPoint3F();
     }
     // HUD images loop (8 iterations, NumHudRenderImages=8)
     // Binary: do-while uVar4 < 8 at offset this + uVar4*4 + 0x174
@@ -222,11 +236,7 @@ function shapeBaseImageDataUnpack(bs) {
         };
     }
     // shellExitDir — 3×F32 (mathWrite Point3F)
-    result.shellExitDir = {
-        x: bs.readF32(),
-        y: bs.readF32(),
-        z: bs.readF32(),
-    };
+    result.shellExitDir = bs.readPoint3F();
     // shellExitVariance — F32
     result.shellExitVariance = bs.readF32();
     // shellVelocity — F32
@@ -366,9 +376,7 @@ function playerDataUnpack(bs) {
     // [0x364 hardcoded to 0, not from stream]
     // 3. 2 optional DataBlock refs (readClassId pattern)
     result.jetEmitter = readDataBlockRef(bs); // 0x368 (jetEmitter @0x364)
-    if (bs.readFlag()) {
-        result.jetEffect = bs.readInt(11); // 0x370 (jetEffect @0x36c; no else/-1)
-    }
+    result.jetEffect = readDataBlockRef(bs); // 0x370 (jetEffect @0x36c)
     // 4. 9× F32 (offsets 0x374-0x394)
     result.runForce = bs.readF32(); // 0x374
     result.runEnergyDrain = bs.readF32(); // 0x378
@@ -415,20 +423,11 @@ function playerDataUnpack(bs) {
     // Binary: zeros 0x428+i*4, then flag + readClassId → 0x4a8+i*4
     const sounds = [];
     for (let i = 0; i < 32; i++) {
-        if (bs.readFlag()) {
-            sounds.push(bs.readInt(11));
-        }
-        else {
-            sounds.push(null);
-        }
+        sounds.push(readDataBlockRef(bs));
     }
     result.sounds = sounds;
     // 12. boxSize 3×F32 (offsets 0x528, 0x52c, 0x530)
-    result.boxSize = {
-        x: bs.readF32(),
-        y: bs.readF32(),
-        z: bs.readF32(),
-    };
+    result.boxSize = bs.readPoint3F();
     // 13. footPuffEmitter + 2 F32s (offset 0xcf0, 0xcf4, 0xcf8)
     result.footPuffEmitter = readDataBlockRef(bs);
     result.footPuffNumParts = bs.readF32();
@@ -524,16 +523,8 @@ function vehicleDataUnpack(bs) {
     }
     result.splashEmitters = splashEmitters;
     // 8. 2×3 F32 damage emitter offsets (2 sets of x,y,z) → offsets 0x3e8-0x3f4
-    result.damageEmitterOffset0 = {
-        x: bs.readF32(),
-        y: bs.readF32(),
-        z: bs.readF32(),
-    };
-    result.damageEmitterOffset1 = {
-        x: bs.readF32(),
-        y: bs.readF32(),
-        z: bs.readF32(),
-    };
+    result.damageEmitterOffset0 = bs.readPoint3F();
+    result.damageEmitterOffset1 = bs.readPoint3F();
     // 9. 2 F32 damage level tolerance → offsets 0x400, 0x404
     result.damageLevelTolerance0 = bs.readF32();
     result.damageLevelTolerance1 = bs.readF32();
@@ -602,11 +593,7 @@ function hoverVehicleDataUnpack(bs) {
     result.floatingThrustFactor = bs.readF32();
     result.brakingForce = bs.readF32();
     // 3×F32 (dustTrailOffset)
-    result.dustTrailOffset = {
-        x: bs.readF32(),
-        y: bs.readF32(),
-        z: bs.readF32(),
-    };
+    result.dustTrailOffset = bs.readPoint3F();
     // 2 F32s
     result.dustTrailFreqMod = bs.readF32();
     result.triggerTrailHeight = bs.readF32();
@@ -748,11 +735,7 @@ function projectileDataUnpack(bs) {
     result.faceViewer = bs.readFlag();
     // flag(nonDefaultScale); if true: 3×F32
     if (bs.readFlag()) {
-        result.scale = {
-            x: bs.readF32(),
-            y: bs.readF32(),
-            z: bs.readF32(),
-        };
+        result.scale = bs.readPoint3F();
     }
     // 9 readDataBlockRef fields in pack order (verified against decompiled
     // Tribes2.exe FUN_00631010 / FUN_006303f0 struct offsets).
@@ -1175,16 +1158,8 @@ function explosionDataUnpack(bs) {
     result.shakeCamera = bs.readFlag();
     result.hasLight = bs.readFlag();
     // 9×F32
-    result.camShakeFreq = {
-        x: bs.readF32(),
-        y: bs.readF32(),
-        z: bs.readF32(),
-    };
-    result.camShakeAmp = {
-        x: bs.readF32(),
-        y: bs.readF32(),
-        z: bs.readF32(),
-    };
+    result.camShakeFreq = bs.readPoint3F();
+    result.camShakeAmp = bs.readPoint3F();
     result.camShakeDuration = bs.readF32();
     result.camShakeRadius = bs.readF32();
     result.camShakeFalloff = bs.readF32();
@@ -1238,9 +1213,11 @@ function debrisDataUnpack(bs) {
     result.snapOnMaxBounce = readBool(bs);
     result.lifetime = bs.readF32(); // 0x54
     result.lifetimeVariance = bs.readF32(); // 0x58
-    // "Written twice" bug: same offsets 0x64/0x68 written again
-    result.minSpinSpeed_dup = bs.readF32();
-    result.maxSpinSpeed_dup = bs.readF32();
+    // The binary writes minSpinSpeed/maxSpinSpeed (0x64/0x68) a second
+    // time here; the client's second read overwrites the first, so do the
+    // same.
+    result.minSpinSpeed = bs.readF32();
+    result.maxSpinSpeed = bs.readF32();
     result.velocity = bs.readF32(); // 0x44
     result.velocityVariance = bs.readF32(); // 0x48
     // 2 bools via stream->write(sizeof(bool)) = 8 bits each (0x70, 0x71)
@@ -1266,11 +1243,7 @@ function debrisDataUnpack(bs) {
 function splashDataUnpack(bs) {
     const result = {};
     // 3×F32 (scale)
-    result.scale = {
-        x: bs.readF32(),
-        y: bs.readF32(),
-        z: bs.readF32(),
-    };
+    result.scale = bs.readPoint3F();
     // ~15 F32/S32 values
     result.delayMS = bs.readS32();
     result.delayVariance = bs.readS32();
@@ -1317,11 +1290,7 @@ function splashDataUnpack(bs) {
 function shockwaveDataUnpack(bs) {
     const result = {};
     // 3×F32 (scale)
-    result.scale = {
-        x: bs.readF32(),
-        y: bs.readF32(),
-        z: bs.readF32(),
-    };
+    result.scale = bs.readPoint3F();
     // ~17 F32/S32/bool values
     result.delayMS = bs.readS32();
     result.delayVariance = bs.readS32();
@@ -1401,9 +1370,11 @@ function particleEmitterDataUnpack(bs) {
     // Verified against decompiled binary FUN_006222a0:
     //   read(4, &count) → U32 count
     //   for each: readFlag → if true: FUN_00436d10 (readClassId, 11 bits); else: 0xFFFFFFFF
-    const particleCount = bs.readU32();
+    // particleEngine.cc sizes the vector straight from the count (no cap);
+    // each entry is at least the 1-bit presence flag.
+    const particleCount = readCheckedCount(bs, 1, "ParticleEmitterData particle count");
     const particles = [];
-    for (let i = 0; i < particleCount && i < 16; i++) {
+    for (let i = 0; i < particleCount; i++) {
         particles.push(readDataBlockRef(bs));
     }
     result.particles = particles;
@@ -1454,10 +1425,14 @@ function particleDataUnpack(bs) {
         });
     }
     result.keys = keys;
-    // readInt(6) texCount; per tex: readString
+    // readInt(6) texCount; per tex: readString. The writer only emits up
+    // to PDC_MAX_TEX names, so a larger count means the stream is corrupt.
     const texCount = bs.readInt(6);
+    if (texCount > ParticleDataMaxTextures) {
+        throw new Error(`Invalid ParticleData texture count: ${texCount}`);
+    }
     const textures = [];
-    for (let i = 0; i < texCount && i < 50; i++) {
+    for (let i = 0; i < texCount; i++) {
         textures.push(bs.readString());
     }
     result.textures = textures;
@@ -1805,7 +1780,7 @@ function tsShapeConstructorUnpack(bs) {
     result.shape = bs.readString();
     const count = bs.readInt(7);
     const sequences = [];
-    for (let i = 0; i < count && i < 128; i++) {
+    for (let i = 0; i < count; i++) {
         sequences.push(bs.readString());
     }
     result.sequences = sequences;