@blamnetwork/blf 1.0.0-alpha.1

package/dist/bitstream/writer.js

@@ -0,0 +1,330 @@
+import { e_bitstream_byte_fill_direction, e_bitstream_byte_order, e_bitstream_state, } from "./enums";
+import { assert_ok, BitstreamError } from "./errors";
+import { quantize_real } from "./math";
+const { _bitstream_byte_fill_direction_msb_to_lsb, _bitstream_byte_fill_direction_lsb_to_msb, } = e_bitstream_byte_fill_direction;
+export class c_bitstream_writer {
+    m_data;
+    m_data_size_bytes;
+    m_state;
+    m_byte_order;
+    m_packed_byte_order;
+    m_byte_pack_direction;
+    m_byte_unpack_direction;
+    current_stream_bit_position;
+    current_stream_byte_position;
+    static new(size, byte_order) {
+        return new c_bitstream_writer(size, byte_order, {
+            packed_byte_order: byte_order,
+            byte_pack_direction: _bitstream_byte_fill_direction_msb_to_lsb,
+            byte_unpack_direction: _bitstream_byte_fill_direction_msb_to_lsb,
+        });
+    }
+    /** Use this when dealing with bitstream data from the Halo 3 Beta or prior. */
+    static new_with_legacy_settings(size, byte_order) {
+        return new c_bitstream_writer(size, byte_order, {
+            packed_byte_order: e_bitstream_byte_order.swap(byte_order),
+            byte_pack_direction: _bitstream_byte_fill_direction_lsb_to_msb,
+            byte_unpack_direction: _bitstream_byte_fill_direction_lsb_to_msb,
+        });
+    }
+    static new_from_instance(size, instance) {
+        return new c_bitstream_writer(size, instance.get_byte_order(), {
+            packed_byte_order: instance.m_packed_byte_order,
+            byte_pack_direction: instance.m_byte_pack_direction,
+            byte_unpack_direction: instance.m_byte_unpack_direction,
+        });
+    }
+    constructor(size, byte_order, options) {
+        this.m_data = new Uint8Array(size);
+        this.m_data_size_bytes = size;
+        this.m_state = e_bitstream_state._bitstream_state_initial;
+        this.m_byte_order = byte_order;
+        this.m_packed_byte_order = options.packed_byte_order;
+        this.m_byte_pack_direction = options.byte_pack_direction;
+        this.m_byte_unpack_direction = options.byte_unpack_direction;
+        this.current_stream_bit_position = 0;
+        this.current_stream_byte_position = 0;
+    }
+    get_byte_order() {
+        return this.m_byte_order;
+    }
+    get_current_offset() {
+        return [
+            this.current_stream_byte_position,
+            this.current_stream_bit_position,
+        ];
+    }
+    write_enum(value, size_in_bits) {
+        this.write_integer(value, size_in_bits);
+    }
+    write_integer(value, size_in_bits) {
+        assert_ok(this.writing());
+        const bytes = new Uint8Array(4);
+        const view = new DataView(bytes.buffer);
+        const u = value >>> 0;
+        switch (this.m_packed_byte_order) {
+            case e_bitstream_byte_order._bitstream_byte_order_little_endian:
+                view.setUint32(0, u, true);
+                break;
+            case e_bitstream_byte_order._bitstream_byte_order_big_endian:
+                view.setUint32(0, u, false);
+                break;
+        }
+        this.write_bits_internal(bytes, size_in_bits);
+    }
+    write_signed_integer(value, size_in_bits) {
+        assert_ok(this.writing());
+        assert_ok(size_in_bits > 0 && size_in_bits <= 32);
+        // Avoid `1 << 31` — JS bitwise ops are 32-bit signed and overflow.
+        const maximum = size_in_bits === 32 ? 0x7fffffff : (1 << (size_in_bits - 1)) - 1;
+        const minimum = size_in_bits === 32 ? -0x80000000 : ~maximum;
+        assert_ok(value >= minimum, "value>=minimum");
+        assert_ok(value <= maximum, "value<=maximum");
+        this.write_integer(value >>> 0, size_in_bits);
+    }
+    write_bool(value) {
+        this.write_integer(value ? 1 : 0, 1);
+    }
+    seek_relative(bits) {
+        const zero_bytes = new Uint8Array(Math.ceil(bits / 8));
+        this.write_bits_internal(zero_bytes, bits);
+    }
+    write_float(value, size_in_bits) {
+        assert_ok(this.writing());
+        const bytes = new Uint8Array(4);
+        const view = new DataView(bytes.buffer);
+        switch (this.m_packed_byte_order) {
+            case e_bitstream_byte_order._bitstream_byte_order_little_endian:
+                view.setFloat32(0, value, true);
+                break;
+            case e_bitstream_byte_order._bitstream_byte_order_big_endian:
+                view.setFloat32(0, value, false);
+                break;
+        }
+        this.write_bits_internal(bytes, size_in_bits);
+    }
+    write_raw_data(value, size_in_bits) {
+        assert_ok(value.length >= Math.ceil(size_in_bits / 8));
+        this.write_bits_internal(value, size_in_bits);
+    }
+    write_qword(value, size_in_bits) {
+        assert_ok(this.writing());
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer);
+        switch (this.m_packed_byte_order) {
+            case e_bitstream_byte_order._bitstream_byte_order_little_endian:
+                view.setBigUint64(0, value, true);
+                break;
+            case e_bitstream_byte_order._bitstream_byte_order_big_endian:
+                view.setBigUint64(0, value, false);
+                break;
+        }
+        this.write_bits_internal(bytes, size_in_bits);
+    }
+    write_index(value, max_value, bit_size) {
+        assert_ok(value <= max_value);
+        if (value === -1) {
+            this.write_bool(true);
+        }
+        else {
+            this.write_bool(false);
+            this.write_integer(value, bit_size);
+        }
+    }
+    write_quantized_real(value, min_value, max_value, size_in_bits, exact_midpoint, exact_endpoints) {
+        const quantized = quantize_real(value, min_value, max_value, 1 << size_in_bits, exact_midpoint, exact_endpoints);
+        this.write_integer(quantized, size_in_bits);
+    }
+    write_point3d(point, axis_encoding_size_in_bits) {
+        assert_ok(axis_encoding_size_in_bits > 0 && axis_encoding_size_in_bits <= 32);
+        assert_ok(point.x < 1 << axis_encoding_size_in_bits);
+        assert_ok(point.y < 1 << axis_encoding_size_in_bits);
+        assert_ok(point.z < 1 << axis_encoding_size_in_bits);
+        this.write_integer(point.x, axis_encoding_size_in_bits);
+        this.write_integer(point.y, axis_encoding_size_in_bits);
+        this.write_integer(point.z, axis_encoding_size_in_bits);
+    }
+    write_point3d_efficient(point, axis_encoding_size_in_bits) {
+        assert_ok(axis_encoding_size_in_bits.x > 0 && axis_encoding_size_in_bits.x <= 32);
+        assert_ok(axis_encoding_size_in_bits.y > 0 && axis_encoding_size_in_bits.y <= 32);
+        assert_ok(axis_encoding_size_in_bits.z > 0 && axis_encoding_size_in_bits.z <= 32);
+        assert_ok(point.x >>> 0 < 1 << axis_encoding_size_in_bits.x);
+        assert_ok(point.y >>> 0 < 1 << axis_encoding_size_in_bits.y);
+        assert_ok(point.z >>> 0 < 1 << axis_encoding_size_in_bits.z);
+        this.write_integer(point.x, axis_encoding_size_in_bits.x);
+        this.write_integer(point.y, axis_encoding_size_in_bits.y);
+        this.write_integer(point.z, axis_encoding_size_in_bits.z);
+    }
+    /** Writes raw UTF-8 bytes + NUL (matches blf_lib `String::as_bytes()`). */
+    write_string_utf8(char_string, max_string_size) {
+        assert_ok(this.writing());
+        assert_ok(max_string_size > 0);
+        const bytes = new TextEncoder().encode(char_string);
+        assert_ok(bytes.length <= max_string_size);
+        for (const byte of bytes) {
+            this.write_value_internal(new Uint8Array([byte]), 8);
+        }
+        this.write_value_internal(new Uint8Array([0]), 8);
+    }
+    write_string_extended_ascii(char_string, max_string_size) {
+        assert_ok(this.writing());
+        assert_ok(max_string_size > 0);
+        assert_ok(char_string.length <= max_string_size);
+        for (const ch of char_string) {
+            const code = ch.codePointAt(0);
+            if (code > 0xff) {
+                throw new BitstreamError(`Cannot encode non-Latin-1 char: ${ch}`);
+            }
+            this.write_value_internal(new Uint8Array([code]), 8);
+        }
+        this.write_value_internal(new Uint8Array([0]), 8);
+    }
+    write_string_wchar(value, max_string_size) {
+        assert_ok(this.writing());
+        assert_ok(max_string_size > 0);
+        assert_ok(value.length <= max_string_size);
+        for (let i = 0; i < value.length; i++) {
+            const code = value.charCodeAt(i);
+            const bytes = new Uint8Array(2);
+            const view = new DataView(bytes.buffer);
+            switch (this.m_packed_byte_order) {
+                case e_bitstream_byte_order._bitstream_byte_order_little_endian:
+                    view.setUint16(0, code, true);
+                    break;
+                case e_bitstream_byte_order._bitstream_byte_order_big_endian:
+                    view.setUint16(0, code, false);
+                    break;
+            }
+            this.write_value_internal(bytes, 16);
+        }
+        this.write_value_internal(new Uint8Array(2), 16);
+    }
+    begin_writing() {
+        this.reset(e_bitstream_state._bitstream_state_writing);
+    }
+    writing() {
+        return this.m_state === e_bitstream_state._bitstream_state_writing;
+    }
+    finish_writing() {
+        this.m_state = e_bitstream_state._bitstream_state_write_finished;
+        this.m_data_size_bytes = Math.ceil((this.current_stream_byte_position * 8 +
+            this.current_stream_bit_position) /
+            8);
+    }
+    get_data() {
+        assert_ok(!this.writing());
+        return this.m_data.slice(0, this.m_data_size_bytes);
+    }
+    write_value_internal(data, size_in_bits) {
+        this.write_bits_internal(data, size_in_bits);
+    }
+    write_bits_internal(data, size_in_bits) {
+        const size_in_bytes = Math.ceil(size_in_bits / 8);
+        if (data.length < size_in_bytes) {
+            throw new BitstreamError(`Tried to write ${size_in_bits} bits but only ${data.length * 8} were provided`);
+        }
+        const surplus_bytes = data.length - size_in_bytes;
+        const surplus_bits = (data.length * 8 - size_in_bits) % 8;
+        let remaining_bits_to_write = size_in_bits;
+        while (remaining_bits_to_write > 0) {
+            const bytes_written = Math.floor((size_in_bits - remaining_bits_to_write) / 8);
+            let bits_written = 0;
+            let writing_byte;
+            switch (this.m_packed_byte_order) {
+                case e_bitstream_byte_order._bitstream_byte_order_little_endian:
+                    if (remaining_bits_to_write < 8) {
+                        writing_byte =
+                            (data[bytes_written] << (8 - remaining_bits_to_write)) & 0xff;
+                    }
+                    else {
+                        writing_byte = data[bytes_written];
+                    }
+                    break;
+                case e_bitstream_byte_order._bitstream_byte_order_big_endian: {
+                    let bits = (data[bytes_written + surplus_bytes] << surplus_bits) & 0xff;
+                    if (surplus_bits !== 0 &&
+                        remaining_bits_to_write > 8 - surplus_bits) {
+                        bits |=
+                            (data[bytes_written + surplus_bytes + 1] >> (8 - surplus_bits)) &
+                                0xff;
+                    }
+                    writing_byte = bits;
+                    break;
+                }
+            }
+            writing_byte &= 0xff << (8 - Math.min(8, remaining_bits_to_write));
+            const writing_bits_at_position = Math.min(8 - this.current_stream_bit_position, remaining_bits_to_write);
+            const remaining_bits_at_position = 8 - this.current_stream_bit_position;
+            let bits;
+            switch (this.m_byte_unpack_direction) {
+                case _bitstream_byte_fill_direction_lsb_to_msb:
+                    bits =
+                        (writing_byte <<
+                            (Math.min(8, remaining_bits_to_write) -
+                                writing_bits_at_position)) &
+                            0xff;
+                    break;
+                case _bitstream_byte_fill_direction_msb_to_lsb:
+                    bits = writing_byte & (0xff << (8 - writing_bits_at_position));
+                    break;
+            }
+            switch (this.m_byte_pack_direction) {
+                case _bitstream_byte_fill_direction_lsb_to_msb:
+                    bits >>>=
+                        8 - (this.current_stream_bit_position + writing_bits_at_position);
+                    break;
+                case _bitstream_byte_fill_direction_msb_to_lsb:
+                    bits >>>= this.current_stream_bit_position;
+                    break;
+            }
+            this.ensure_byte_capacity(this.current_stream_byte_position);
+            this.m_data[this.current_stream_byte_position] |= bits;
+            bits_written += writing_bits_at_position;
+            if (writing_bits_at_position === remaining_bits_at_position) {
+                this.current_stream_bit_position = 0;
+                this.current_stream_byte_position += 1;
+            }
+            else {
+                this.current_stream_bit_position += writing_bits_at_position;
+            }
+            remaining_bits_to_write -= writing_bits_at_position;
+            if (remaining_bits_to_write > 0 && bits_written < 8) {
+                const extra_bits_at_position = Math.min(remaining_bits_to_write, 8 - bits_written);
+                let extra_bits;
+                switch (this.m_byte_unpack_direction) {
+                    case _bitstream_byte_fill_direction_lsb_to_msb:
+                        extra_bits = writing_byte & (0xff << (8 - extra_bits_at_position));
+                        break;
+                    case _bitstream_byte_fill_direction_msb_to_lsb:
+                        extra_bits = (writing_byte << bits_written) & 0xff;
+                        break;
+                }
+                if (this.m_byte_pack_direction ===
+                    _bitstream_byte_fill_direction_lsb_to_msb) {
+                    extra_bits >>>= 8 - extra_bits_at_position;
+                }
+                this.ensure_byte_capacity(this.current_stream_byte_position);
+                this.m_data[this.current_stream_byte_position] |= extra_bits;
+                bits_written += extra_bits_at_position;
+                this.current_stream_bit_position = extra_bits_at_position;
+                remaining_bits_to_write -= extra_bits_at_position;
+            }
+        }
+    }
+    ensure_byte_capacity(byte_index) {
+        if (byte_index < this.m_data.length) {
+            return;
+        }
+        const new_size = Math.max(this.m_data.length * 2, byte_index + 1);
+        const grown = new Uint8Array(new_size);
+        grown.set(this.m_data);
+        this.m_data = grown;
+        this.m_data_size_bytes = new_size;
+    }
+    reset(state) {
+        this.m_state = state;
+        this.current_stream_bit_position = 0;
+        this.current_stream_byte_position = 0;
+        this.m_data.fill(0);
+    }
+}

package/dist/blam/common/cache/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./security_functions";
+//# sourceMappingURL=index.d.ts.map

package/dist/blam/common/cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/blam/common/cache/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC"}

package/dist/blam/common/cache/index.js

@@ -0,0 +1 @@
+export * from "./security_functions";

package/dist/blam/common/cache/security_functions.d.ts

@@ -0,0 +1,2 @@
+export declare function security_calculate_hash(data: Uint8Array): Uint8Array;
+//# sourceMappingURL=security_functions.d.ts.map

package/dist/blam/common/cache/security_functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security_functions.d.ts","sourceRoot":"","sources":["../../../../src/blam/common/cache/security_functions.ts"],"names":[],"mappings":"AAcA,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAGpE"}

package/dist/blam/common/cache/security_functions.js

@@ -0,0 +1,19 @@
+import { sha1 } from "js-sha1";
+const GEN3_SALT = hex_to_bytes("EDD43009666D5C4A5C3657FAB40E022F535AC6C9EE471F01F1A44756B7714F1C36EC");
+function hex_to_bytes(hex) {
+    const out = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < out.length; i++) {
+        out[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return out;
+}
+export function security_calculate_hash(data) {
+    const digest = sha1.arrayBuffer(concat(GEN3_SALT, data));
+    return new Uint8Array(digest);
+}
+function concat(a, b) {
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a, 0);
+    out.set(b, a.length);
+    return out;
+}

package/dist/blam/common/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./cache";
+export * from "./memory";
+//# sourceMappingURL=index.d.ts.map

package/dist/blam/common/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/blam/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,UAAU,CAAC"}

package/dist/blam/common/index.js

@@ -0,0 +1,2 @@
+export * from "./cache";
+export * from "./memory";

package/dist/blam/common/memory/data_compress.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Zlib (RFC 1950) compression matching blf_lib `runtime_data_compress`:
+ * `Compress::new_with_window_bits(Compression::new(9), true, 15)` via flate2+zlib.
+ */
+export declare function zlib_compress(data: Uint8Array): Uint8Array;
+/** Reach runtime blob: BE `u32` uncompressed size + zlib payload. */
+export declare function runtime_data_compress(source: Uint8Array, big_endian?: boolean): Uint8Array;
+/** Reach runtime blob: BE `u32` uncompressed size + zlib payload. */
+export declare function runtime_data_decompress(source: Uint8Array, big_endian?: boolean): Uint8Array;
+//# sourceMappingURL=data_compress.d.ts.map

package/dist/blam/common/memory/data_compress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data_compress.d.ts","sourceRoot":"","sources":["../../../../src/blam/common/memory/data_compress.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAM1D;AAED,qEAAqE;AACrE,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,UAAU,EAClB,UAAU,UAAO,GAChB,UAAU,CAMZ;AAED,qEAAqE;AACrE,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,UAAU,EAClB,UAAU,UAAO,GAChB,UAAU,CAOZ"}

package/dist/blam/common/memory/data_compress.js

@@ -0,0 +1,28 @@
+import { deflate, inflate } from "pako";
+import { BlfError } from "../../../error";
+/**
+ * Zlib (RFC 1950) compression matching blf_lib `runtime_data_compress`:
+ * `Compress::new_with_window_bits(Compression::new(9), true, 15)` via flate2+zlib.
+ */
+export function zlib_compress(data) {
+    return deflate(data, {
+        level: 9,
+        windowBits: 15,
+        memLevel: 8,
+    });
+}
+/** Reach runtime blob: BE `u32` uncompressed size + zlib payload. */
+export function runtime_data_compress(source, big_endian = true) {
+    const compressed = zlib_compress(source);
+    const out = new Uint8Array(4 + compressed.length);
+    new DataView(out.buffer).setUint32(0, source.length, !big_endian);
+    out.set(compressed, 4);
+    return out;
+}
+/** Reach runtime blob: BE `u32` uncompressed size + zlib payload. */
+export function runtime_data_decompress(source, big_endian = true) {
+    if (source.length < 4) {
+        throw new BlfError(`runtime_data_decompress needs at least 4 bytes, got ${source.length}`);
+    }
+    return inflate(source.subarray(4));
+}

package/dist/blam/common/memory/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./data_compress";
+//# sourceMappingURL=index.d.ts.map

package/dist/blam/common/memory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/blam/common/memory/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC"}

package/dist/blam/common/memory/index.js

@@ -0,0 +1 @@
+export * from "./data_compress";

package/dist/blam/haloreach/v12065_11_08_24_1738_tu1actual/game/c_game_engine_custom_variant.d.ts

@@ -0,0 +1,37 @@
+import type { c_bitstream_reader, c_bitstream_writer } from "../../../../bitstream";
+import { c_game_engine_custom_variant_au1_settings } from "./c_game_engine_custom_variant_au1_settings";
+import { c_game_engine_base_variant } from "./c_game_engine_default";
+import { s_player_trait_option } from "./c_game_engine_traits";
+import { c_string_table } from "./c_string_table";
+import { c_megalogamengine_map_permissions } from "./megalogamengine/c_megalogamengine_map_permissions";
+import { s_custom_game_engine_definition } from "./megalogamengine/s_custom_game_engine_definition";
+import { s_game_engine_player_rating_parameters } from "./megalogamengine/s_game_engine_player_rating_parameters";
+import { s_user_defined_option } from "./megalogamengine/s_user_defined_option";
+export declare class c_game_engine_custom_variant {
+    m_encoding_version: number;
+    m_build_number: number;
+    m_base_variant: c_game_engine_base_variant;
+    m_player_traits: s_player_trait_option[];
+    m_user_defined_options: s_user_defined_option[];
+    m_script_strings: c_string_table;
+    m_base_name_string_index: number;
+    m_localized_name: c_string_table;
+    m_localized_description: c_string_table;
+    m_localized_category: c_string_table;
+    m_engine_icon: number;
+    m_engine_category: number;
+    m_map_permissions: c_megalogamengine_map_permissions;
+    m_player_ratings: s_game_engine_player_rating_parameters;
+    m_score_to_win_round: number;
+    m_fire_teams_enabled: boolean;
+    m_symmetric_gametype: boolean;
+    m_base_variant_parameters_locked: boolean[];
+    m_base_variant_parameters_hidden: boolean[];
+    m_user_defined_options_locked: boolean[];
+    m_user_defined_options_hidden: boolean[];
+    m_game_engine: s_custom_game_engine_definition;
+    m_au1_settings?: c_game_engine_custom_variant_au1_settings;
+    decode(bitstream: c_bitstream_reader): void;
+    encode(bitstream: c_bitstream_writer): void;
+}
+//# sourceMappingURL=c_game_engine_custom_variant.d.ts.map

package/dist/blam/haloreach/v12065_11_08_24_1738_tu1actual/game/c_game_engine_custom_variant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"c_game_engine_custom_variant.d.ts","sourceRoot":"","sources":["../../../../../src/blam/haloreach/v12065_11_08_24_1738_tu1actual/game/c_game_engine_custom_variant.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,yCAAyC,EAAE,MAAM,6CAA6C,CAAC;AACxG,OAAO,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,iCAAiC,EAAE,MAAM,qDAAqD,CAAC;AACxG,OAAO,EAAE,+BAA+B,EAAE,MAAM,mDAAmD,CAAC;AACpG,OAAO,EAAE,sCAAsC,EAAE,MAAM,0DAA0D,CAAC;AAClH,OAAO,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AAEhF,qBAAa,4BAA4B;IACvC,kBAAkB,SAAK;IACvB,cAAc,SAAK;IACnB,cAAc,6BAAoC;IAClD,eAAe,EAAE,qBAAqB,EAAE,CAAM;IAC9C,sBAAsB,EAAE,qBAAqB,EAAE,CAAM;IACrD,gBAAgB,iBAA8C;IAC9D,wBAAwB,SAAK;IAC7B,gBAAgB,iBAAyC;IACzD,uBAAuB,iBAA2C;IAClE,oBAAoB,iBAAyC;IAC7D,aAAa,SAAK;IAClB,iBAAiB,SAAK;IACtB,iBAAiB,oCAA2C;IAC5D,gBAAgB,yCAAgD;IAChE,oBAAoB,SAAK;IACzB,oBAAoB,UAAS;IAC7B,oBAAoB,UAAS;IAC7B,gCAAgC,EAAE,OAAO,EAAE,CAGzC;IACF,gCAAgC,EAAE,OAAO,EAAE,CAGzC;IACF,6BAA6B,EAAE,OAAO,EAAE,CAGtC;IACF,6BAA6B,EAAE,OAAO,EAAE,CAGtC;IACF,aAAa,kCAAyC;IACtD,cAAc,CAAC,EAAE,yCAAyC,CAAC;IAE3D,MAAM,CAAC,SAAS,EAAE,kBAAkB,GAAG,IAAI;IA0E3C,MAAM,CAAC,SAAS,EAAE,kBAAkB,GAAG,IAAI;CA8C5C"}

package/dist/blam/haloreach/v12065_11_08_24_1738_tu1actual/game/c_game_engine_custom_variant.js

@@ -0,0 +1,125 @@
+import { BlfError } from "../../../../error";
+import { c_game_engine_custom_variant_au1_settings } from "./c_game_engine_custom_variant_au1_settings";
+import { c_game_engine_base_variant } from "./c_game_engine_default";
+import { s_player_trait_option } from "./c_game_engine_traits";
+import { c_string_table } from "./c_string_table";
+import { c_megalogamengine_map_permissions } from "./megalogamengine/c_megalogamengine_map_permissions";
+import { s_custom_game_engine_definition } from "./megalogamengine/s_custom_game_engine_definition";
+import { s_game_engine_player_rating_parameters } from "./megalogamengine/s_game_engine_player_rating_parameters";
+import { s_user_defined_option } from "./megalogamengine/s_user_defined_option";
+export class c_game_engine_custom_variant {
+    m_encoding_version = 0;
+    m_build_number = 0;
+    m_base_variant = new c_game_engine_base_variant();
+    m_player_traits = [];
+    m_user_defined_options = [];
+    m_script_strings = new c_string_table(112, 0x4c00, 15, 15, 7);
+    m_base_name_string_index = 0;
+    m_localized_name = new c_string_table(1, 0x180, 9, 9, 1);
+    m_localized_description = new c_string_table(1, 0xc00, 12, 12, 1);
+    m_localized_category = new c_string_table(1, 0x180, 9, 9, 1);
+    m_engine_icon = 0;
+    m_engine_category = 0;
+    m_map_permissions = new c_megalogamengine_map_permissions();
+    m_player_ratings = new s_game_engine_player_rating_parameters();
+    m_score_to_win_round = 0;
+    m_fire_teams_enabled = false;
+    m_symmetric_gametype = false;
+    m_base_variant_parameters_locked = Array.from({ length: 1280 }, () => false);
+    m_base_variant_parameters_hidden = Array.from({ length: 1280 }, () => false);
+    m_user_defined_options_locked = Array.from({ length: 32 }, () => false);
+    m_user_defined_options_hidden = Array.from({ length: 32 }, () => false);
+    m_game_engine = new s_custom_game_engine_definition();
+    m_au1_settings;
+    decode(bitstream) {
+        this.m_encoding_version = bitstream.read_signed_integer("encoding-version", 32);
+        this.m_build_number = bitstream.read_signed_integer("version", 32);
+        this.m_base_variant.decode(bitstream);
+        const player_trait_count = bitstream.read_integer("player-trait-count", 5);
+        for (let i = 0; i < player_trait_count; i++) {
+            const traits = new s_player_trait_option();
+            traits.decode(bitstream);
+            this.m_player_traits.push(traits);
+        }
+        const user_defined_option_count = bitstream.read_integer("user-defined-option-count", 5);
+        for (let i = 0; i < user_defined_option_count; i++) {
+            const option = new s_user_defined_option();
+            option.decode(bitstream);
+            this.m_user_defined_options.push(option);
+        }
+        this.m_script_strings.decode(bitstream);
+        this.m_base_name_string_index = bitstream.read_integer("base-name-string-index", 7);
+        this.m_localized_name.decode(bitstream);
+        this.m_localized_description.decode(bitstream);
+        this.m_localized_category.decode(bitstream);
+        this.m_engine_icon = bitstream.read_integer("engine-icon-index", 5);
+        this.m_engine_category = bitstream.read_integer("engine-category", 5);
+        this.m_map_permissions.decode(bitstream);
+        this.m_player_ratings.decode(bitstream);
+        this.m_score_to_win_round = bitstream.read_signed_integer("score-to-win-round", 16);
+        this.m_fire_teams_enabled = bitstream.read_bool("fire-teams-enabled");
+        this.m_symmetric_gametype = bitstream.read_bool("symmetric-gametype");
+        for (let i = 0; i < 1280; i++) {
+            this.m_base_variant_parameters_locked[i] = bitstream.read_bool("base-variant-parameters-locked");
+        }
+        for (let i = 0; i < 1280; i++) {
+            this.m_base_variant_parameters_hidden[i] = bitstream.read_bool("base-variant-parameters-hidden");
+        }
+        for (let i = 0; i < 32; i++) {
+            this.m_user_defined_options_locked[i] = bitstream.read_bool("user-defined-options-locked");
+        }
+        for (let i = 0; i < 32; i++) {
+            this.m_user_defined_options_hidden[i] = bitstream.read_bool("user-defined-options-hidden");
+        }
+        this.m_game_engine.decode(bitstream);
+        if (this.m_encoding_version > 106) {
+            const au1 = new c_game_engine_custom_variant_au1_settings();
+            au1.decode(bitstream);
+            this.m_au1_settings = au1;
+        }
+    }
+    encode(bitstream) {
+        bitstream.write_signed_integer(this.m_encoding_version, 32);
+        bitstream.write_signed_integer(this.m_build_number, 32);
+        this.m_base_variant.encode(bitstream);
+        bitstream.write_integer(this.m_player_traits.length, 5);
+        for (const player_trait of this.m_player_traits) {
+            player_trait.encode(bitstream);
+        }
+        bitstream.write_integer(this.m_user_defined_options.length, 5);
+        for (const option of this.m_user_defined_options) {
+            option.encode(bitstream);
+        }
+        this.m_script_strings.encode(bitstream);
+        bitstream.write_integer(this.m_base_name_string_index, 7);
+        this.m_localized_name.encode(bitstream);
+        this.m_localized_description.encode(bitstream);
+        this.m_localized_category.encode(bitstream);
+        bitstream.write_integer(this.m_engine_icon, 5);
+        bitstream.write_integer(this.m_engine_category, 5);
+        this.m_map_permissions.encode(bitstream);
+        this.m_player_ratings.encode(bitstream);
+        bitstream.write_signed_integer(this.m_score_to_win_round, 16);
+        bitstream.write_bool(this.m_fire_teams_enabled);
+        bitstream.write_bool(this.m_symmetric_gametype);
+        for (const parameter of this.m_base_variant_parameters_locked) {
+            bitstream.write_bool(parameter);
+        }
+        for (const parameter of this.m_base_variant_parameters_hidden) {
+            bitstream.write_bool(parameter);
+        }
+        for (const parameter of this.m_user_defined_options_locked) {
+            bitstream.write_bool(parameter);
+        }
+        for (const parameter of this.m_user_defined_options_hidden) {
+            bitstream.write_bool(parameter);
+        }
+        this.m_game_engine.encode(bitstream);
+        if (this.m_encoding_version > 106) {
+            if (!this.m_au1_settings) {
+                throw new BlfError("Writing v107 gametypes (and higher) requires AU1 Options to be set.");
+            }
+            this.m_au1_settings.encode(bitstream);
+        }
+    }
+}

package/dist/blam/haloreach/v12065_11_08_24_1738_tu1actual/game/c_game_engine_custom_variant_au1_settings.d.ts

@@ -0,0 +1,14 @@
+import type { c_bitstream_reader, c_bitstream_writer } from "../../../../bitstream";
+export declare class c_game_engine_custom_variant_au1_settings {
+    m_flags: number;
+    m_precision_bloom: number;
+    m_active_camo_energy_curve_min: number;
+    m_active_camo_energy_curve_max: number;
+    m_armor_lock_damage_drain: number;
+    m_armor_lock_damage_drain_limit: number;
+    m_magnum_damage: number;
+    m_magnum_fire_delay: number;
+    decode(bitstream: c_bitstream_reader): void;
+    encode(bitstream: c_bitstream_writer): void;
+}
+//# sourceMappingURL=c_game_engine_custom_variant_au1_settings.d.ts.map

package/dist/blam/haloreach/v12065_11_08_24_1738_tu1actual/game/c_game_engine_custom_variant_au1_settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"c_game_engine_custom_variant_au1_settings.d.ts","sourceRoot":"","sources":["../../../../../src/blam/haloreach/v12065_11_08_24_1738_tu1actual/game/c_game_engine_custom_variant_au1_settings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,uBAAuB,CAAC;AAE/B,qBAAa,yCAAyC;IACpD,OAAO,SAAK;IACZ,iBAAiB,SAAK;IACtB,8BAA8B,SAAK;IACnC,8BAA8B,SAAK;IACnC,yBAAyB,SAAK;IAC9B,+BAA+B,SAAK;IACpC,eAAe,SAAK;IACpB,mBAAmB,SAAK;IAExB,MAAM,CAAC,SAAS,EAAE,kBAAkB,GAAG,IAAI;IA+C3C,MAAM,CAAC,SAAS,EAAE,kBAAkB,GAAG,IAAI;CAoD5C"}

package/dist/blam/haloreach/v12065_11_08_24_1738_tu1actual/game/c_game_engine_custom_variant_au1_settings.js

@@ -0,0 +1,30 @@
+export class c_game_engine_custom_variant_au1_settings {
+    m_flags = 0;
+    m_precision_bloom = 0;
+    m_active_camo_energy_curve_min = 0;
+    m_active_camo_energy_curve_max = 0;
+    m_armor_lock_damage_drain = 0;
+    m_armor_lock_damage_drain_limit = 0;
+    m_magnum_damage = 0;
+    m_magnum_fire_delay = 0;
+    decode(bitstream) {
+        this.m_flags = bitstream.read_integer("flags", 32);
+        this.m_precision_bloom = bitstream.read_quantized_real(0, 2, 8, false, true);
+        this.m_active_camo_energy_curve_min = bitstream.read_quantized_real(0, 2, 8, false, true);
+        this.m_active_camo_energy_curve_max = bitstream.read_quantized_real(0, 2, 8, false, true);
+        this.m_armor_lock_damage_drain = bitstream.read_quantized_real(0, 2, 8, false, true);
+        this.m_armor_lock_damage_drain_limit = bitstream.read_quantized_real(0, 2, 8, false, true);
+        this.m_magnum_damage = bitstream.read_quantized_real(0, 10, 8, false, true);
+        this.m_magnum_fire_delay = bitstream.read_quantized_real(0, 10, 8, false, true);
+    }
+    encode(bitstream) {
+        bitstream.write_integer(this.m_flags, 32);
+        bitstream.write_quantized_real(this.m_precision_bloom, 0, 2, 8, false, true);
+        bitstream.write_quantized_real(this.m_active_camo_energy_curve_min, 0, 2, 8, false, true);
+        bitstream.write_quantized_real(this.m_active_camo_energy_curve_max, 0, 2, 8, false, true);
+        bitstream.write_quantized_real(this.m_armor_lock_damage_drain, 0, 2, 8, false, true);
+        bitstream.write_quantized_real(this.m_armor_lock_damage_drain_limit, 0, 2, 8, false, true);
+        bitstream.write_quantized_real(this.m_magnum_damage, 0, 10, 8, false, true);
+        bitstream.write_quantized_real(this.m_magnum_fire_delay, 0, 10, 8, false, true);
+    }
+}