@blamnetwork/blf 1.0.0-alpha.1

package/dist-cjs/bitstream/writer.js

@@ -0,0 +1,334 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.c_bitstream_writer = void 0;
+const enums_1 = require("./enums");
+const errors_1 = require("./errors");
+const math_1 = require("./math");
+const { _bitstream_byte_fill_direction_msb_to_lsb, _bitstream_byte_fill_direction_lsb_to_msb, } = enums_1.e_bitstream_byte_fill_direction;
+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: enums_1.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 = enums_1.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) {
+        (0, errors_1.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 enums_1.e_bitstream_byte_order._bitstream_byte_order_little_endian:
+                view.setUint32(0, u, true);
+                break;
+            case enums_1.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) {
+        (0, errors_1.assert_ok)(this.writing());
+        (0, errors_1.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;
+        (0, errors_1.assert_ok)(value >= minimum, "value>=minimum");
+        (0, errors_1.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) {
+        (0, errors_1.assert_ok)(this.writing());
+        const bytes = new Uint8Array(4);
+        const view = new DataView(bytes.buffer);
+        switch (this.m_packed_byte_order) {
+            case enums_1.e_bitstream_byte_order._bitstream_byte_order_little_endian:
+                view.setFloat32(0, value, true);
+                break;
+            case enums_1.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) {
+        (0, errors_1.assert_ok)(value.length >= Math.ceil(size_in_bits / 8));
+        this.write_bits_internal(value, size_in_bits);
+    }
+    write_qword(value, size_in_bits) {
+        (0, errors_1.assert_ok)(this.writing());
+        const bytes = new Uint8Array(8);
+        const view = new DataView(bytes.buffer);
+        switch (this.m_packed_byte_order) {
+            case enums_1.e_bitstream_byte_order._bitstream_byte_order_little_endian:
+                view.setBigUint64(0, value, true);
+                break;
+            case enums_1.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) {
+        (0, errors_1.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 = (0, math_1.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) {
+        (0, errors_1.assert_ok)(axis_encoding_size_in_bits > 0 && axis_encoding_size_in_bits <= 32);
+        (0, errors_1.assert_ok)(point.x < 1 << axis_encoding_size_in_bits);
+        (0, errors_1.assert_ok)(point.y < 1 << axis_encoding_size_in_bits);
+        (0, errors_1.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) {
+        (0, errors_1.assert_ok)(axis_encoding_size_in_bits.x > 0 && axis_encoding_size_in_bits.x <= 32);
+        (0, errors_1.assert_ok)(axis_encoding_size_in_bits.y > 0 && axis_encoding_size_in_bits.y <= 32);
+        (0, errors_1.assert_ok)(axis_encoding_size_in_bits.z > 0 && axis_encoding_size_in_bits.z <= 32);
+        (0, errors_1.assert_ok)(point.x >>> 0 < 1 << axis_encoding_size_in_bits.x);
+        (0, errors_1.assert_ok)(point.y >>> 0 < 1 << axis_encoding_size_in_bits.y);
+        (0, errors_1.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) {
+        (0, errors_1.assert_ok)(this.writing());
+        (0, errors_1.assert_ok)(max_string_size > 0);
+        const bytes = new TextEncoder().encode(char_string);
+        (0, errors_1.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) {
+        (0, errors_1.assert_ok)(this.writing());
+        (0, errors_1.assert_ok)(max_string_size > 0);
+        (0, errors_1.assert_ok)(char_string.length <= max_string_size);
+        for (const ch of char_string) {
+            const code = ch.codePointAt(0);
+            if (code > 0xff) {
+                throw new errors_1.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) {
+        (0, errors_1.assert_ok)(this.writing());
+        (0, errors_1.assert_ok)(max_string_size > 0);
+        (0, errors_1.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 enums_1.e_bitstream_byte_order._bitstream_byte_order_little_endian:
+                    view.setUint16(0, code, true);
+                    break;
+                case enums_1.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(enums_1.e_bitstream_state._bitstream_state_writing);
+    }
+    writing() {
+        return this.m_state === enums_1.e_bitstream_state._bitstream_state_writing;
+    }
+    finish_writing() {
+        this.m_state = enums_1.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() {
+        (0, errors_1.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 errors_1.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 enums_1.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 enums_1.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);
+    }
+}
+exports.c_bitstream_writer = c_bitstream_writer;

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./security_functions"), exports);

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.security_calculate_hash = security_calculate_hash;
+const js_sha1_1 = require("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;
+}
+function security_calculate_hash(data) {
+    const digest = js_sha1_1.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-cjs/blam/common/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cache"), exports);
+__exportStar(require("./memory"), exports);

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zlib_compress = zlib_compress;
+exports.runtime_data_compress = runtime_data_compress;
+exports.runtime_data_decompress = runtime_data_decompress;
+const pako_1 = require("pako");
+const error_1 = require("../../../error");
+/**
+ * Zlib (RFC 1950) compression matching blf_lib `runtime_data_compress`:
+ * `Compress::new_with_window_bits(Compression::new(9), true, 15)` via flate2+zlib.
+ */
+function zlib_compress(data) {
+    return (0, pako_1.deflate)(data, {
+        level: 9,
+        windowBits: 15,
+        memLevel: 8,
+    });
+}
+/** Reach runtime blob: BE `u32` uncompressed size + zlib payload. */
+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. */
+function runtime_data_decompress(source, big_endian = true) {
+    if (source.length < 4) {
+        throw new error_1.BlfError(`runtime_data_decompress needs at least 4 bytes, got ${source.length}`);
+    }
+    return (0, pako_1.inflate)(source.subarray(4));
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./data_compress"), exports);

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.c_game_engine_custom_variant = void 0;
+const error_1 = require("../../../../error");
+const c_game_engine_custom_variant_au1_settings_1 = require("./c_game_engine_custom_variant_au1_settings");
+const c_game_engine_default_1 = require("./c_game_engine_default");
+const c_game_engine_traits_1 = require("./c_game_engine_traits");
+const c_string_table_1 = require("./c_string_table");
+const c_megalogamengine_map_permissions_1 = require("./megalogamengine/c_megalogamengine_map_permissions");
+const s_custom_game_engine_definition_1 = require("./megalogamengine/s_custom_game_engine_definition");
+const s_game_engine_player_rating_parameters_1 = require("./megalogamengine/s_game_engine_player_rating_parameters");
+const s_user_defined_option_1 = require("./megalogamengine/s_user_defined_option");
+class c_game_engine_custom_variant {
+    m_encoding_version = 0;
+    m_build_number = 0;
+    m_base_variant = new c_game_engine_default_1.c_game_engine_base_variant();
+    m_player_traits = [];
+    m_user_defined_options = [];
+    m_script_strings = new c_string_table_1.c_string_table(112, 0x4c00, 15, 15, 7);
+    m_base_name_string_index = 0;
+    m_localized_name = new c_string_table_1.c_string_table(1, 0x180, 9, 9, 1);
+    m_localized_description = new c_string_table_1.c_string_table(1, 0xc00, 12, 12, 1);
+    m_localized_category = new c_string_table_1.c_string_table(1, 0x180, 9, 9, 1);
+    m_engine_icon = 0;
+    m_engine_category = 0;
+    m_map_permissions = new c_megalogamengine_map_permissions_1.c_megalogamengine_map_permissions();
+    m_player_ratings = new s_game_engine_player_rating_parameters_1.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_1.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 c_game_engine_traits_1.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_1.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_1.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 error_1.BlfError("Writing v107 gametypes (and higher) requires AU1 Options to be set.");
+            }
+            this.m_au1_settings.encode(bitstream);
+        }
+    }
+}
+exports.c_game_engine_custom_variant = c_game_engine_custom_variant;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.c_game_engine_custom_variant_au1_settings = void 0;
+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);
+    }
+}
+exports.c_game_engine_custom_variant_au1_settings = c_game_engine_custom_variant_au1_settings;