@blamnetwork/blf 1.0.0-alpha.1

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

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.c_player_traits = exports.c_player_trait_sensors = exports.c_player_trait_appearance = exports.c_player_trait_movement = exports.c_player_trait_weapons = exports.c_player_trait_shield_vitality = void 0;
+class c_player_trait_shield_vitality {
+    m_damage_resistance_percentage_setting = 0;
+    m_body_multiplier = 0;
+    m_body_recharge_rate = 0;
+    m_shield_multiplier = 0;
+    m_shield_recharge_rate = 0;
+    m_overshield_recharge_rate = 0;
+    m_headshot_immunity_setting = 0;
+    m_vampirism_percentage_setting = 0;
+    m_assasination_immunity = 0;
+    m_cannot_die_from_damage = 0;
+}
+exports.c_player_trait_shield_vitality = c_player_trait_shield_vitality;
+class c_player_trait_weapons {
+    m_damage_modifier_percentage_setting = 0;
+    m_melee_damage_modifier_percentage_setting = 0;
+    m_initial_primary_weapon_absolute_index = 0;
+    m_initial_secondary_weapon_absolute_index = 0;
+    m_initial_grenade_count_setting = 0;
+    m_infinite_ammo_setting = 0;
+    m_recharging_grenades_setting = 0;
+    m_weapon_pickup_setting = 0;
+    m_equipment_usage_setting = 0;
+    m_equipment_drop_on_death_setting = 0;
+    m_infinite_equipment_setting = 0;
+    m_initial_equipment_absolute_index = 0;
+}
+exports.c_player_trait_weapons = c_player_trait_weapons;
+class c_player_trait_movement {
+    m_speed_setting = 0;
+    m_gravity_setting = 0;
+    m_vehicle_usage_setting = 0;
+    m_double_jump_setting = 0;
+    m_jump_modifier = -1;
+}
+exports.c_player_trait_movement = c_player_trait_movement;
+class c_player_trait_appearance {
+    m_active_camo_setting = 0;
+    m_waypoint_setting = 0;
+    m_gamertag_setting = 0;
+    m_aura_setting = 0;
+    m_forced_change_color_setting = 0;
+}
+exports.c_player_trait_appearance = c_player_trait_appearance;
+class c_player_trait_sensors {
+    m_motion_tracker_setting = 0;
+    m_motion_tracker_range_setting = 0;
+    m_directional_damage_setting = 0;
+}
+exports.c_player_trait_sensors = c_player_trait_sensors;
+class c_player_traits {
+    m_shield_vitality_traits = new c_player_trait_shield_vitality();
+    m_weapon_traits = new c_player_trait_weapons();
+    m_movement_traits = new c_player_trait_movement();
+    m_appearance_traits = new c_player_trait_appearance();
+    m_sensor_traits = new c_player_trait_sensors();
+    decode(bitstream) {
+        const sv = this.m_shield_vitality_traits;
+        sv.m_damage_resistance_percentage_setting = bitstream.read_integer("damage-resistance", 4);
+        sv.m_body_multiplier = bitstream.read_integer("body-multiplier", 3);
+        sv.m_body_recharge_rate = bitstream.read_integer("body-recharge-rate", 4);
+        sv.m_shield_multiplier = bitstream.read_integer("shield-multiplier", 3);
+        sv.m_shield_recharge_rate = bitstream.read_integer("shield-recharge-rate", 4);
+        sv.m_overshield_recharge_rate = bitstream.read_integer("overshield-recharge-rate", 4);
+        sv.m_headshot_immunity_setting = bitstream.read_integer("headshot-immunity", 2);
+        sv.m_vampirism_percentage_setting = bitstream.read_integer("vampirism", 3);
+        sv.m_assasination_immunity = bitstream.read_integer("assasination-immunity", 2);
+        sv.m_cannot_die_from_damage = bitstream.read_integer("cannot-die-from-damage", 2);
+        const w = this.m_weapon_traits;
+        w.m_damage_modifier_percentage_setting = bitstream.read_integer("damage-modifier", 4);
+        w.m_melee_damage_modifier_percentage_setting = bitstream.read_integer("melee-damage-modifier", 4);
+        w.m_initial_primary_weapon_absolute_index = bitstream.read_signed_integer("player-trait-initial-primary-weapon", 8);
+        w.m_initial_secondary_weapon_absolute_index = bitstream.read_signed_integer("player-trait-initial-secondary-weapon", 8);
+        w.m_initial_grenade_count_setting = bitstream.read_integer("player-trait-initial-grenade-count", 4);
+        w.m_infinite_ammo_setting = bitstream.read_integer("player-traits-infinite-ammo-setting", 2);
+        w.m_recharging_grenades_setting = bitstream.read_integer("player-traits-recharging-grenades", 2);
+        w.m_weapon_pickup_setting = bitstream.read_integer("player-traits-weapon-pickup-allowed", 2);
+        w.m_equipment_usage_setting = bitstream.read_integer("player-traits-equipment-usage", 2);
+        w.m_equipment_drop_on_death_setting = bitstream.read_integer("player-traits-equipment-drop", 2);
+        w.m_infinite_equipment_setting = bitstream.read_integer("player-traits-infinite-equipment", 2);
+        w.m_initial_equipment_absolute_index = bitstream.read_signed_integer("player-trait-initial-equipment", 8);
+        const m = this.m_movement_traits;
+        m.m_speed_setting = bitstream.read_integer("player-speed", 5);
+        m.m_gravity_setting = bitstream.read_integer("player-gravity", 4);
+        m.m_vehicle_usage_setting = bitstream.read_integer("player-traits-movement-vehicle-usage", 4);
+        m.m_double_jump_setting = bitstream.read_integer("player-traits-movement-double-jump", 2);
+        if (bitstream.read_bool("player-traits-movement-jump-modifier-changed")) {
+            m.m_jump_modifier = bitstream.read_integer("player-traits-movement-jump-modifier", 9);
+        }
+        else {
+            m.m_jump_modifier = -1;
+        }
+        const a = this.m_appearance_traits;
+        a.m_active_camo_setting = bitstream.read_integer("player-traits-appearance-active-camo", 3);
+        a.m_waypoint_setting = bitstream.read_integer("player-traits-appearance-waypoint", 2);
+        a.m_gamertag_setting = bitstream.read_integer("player-traits-appearance-gamertag", 2);
+        a.m_aura_setting = bitstream.read_integer("player-traits-appearance-aura", 3);
+        a.m_forced_change_color_setting = bitstream.read_integer("player-traits-appearance-forced-change-color", 4);
+        const s = this.m_sensor_traits;
+        s.m_motion_tracker_setting = bitstream.read_integer("player-traits-sensors-motion-tracker", 3);
+        s.m_motion_tracker_range_setting = bitstream.read_integer("motion-tracker-range", 3);
+        s.m_directional_damage_setting = bitstream.read_integer("player-traits-sensors-directional-damage", 2);
+    }
+    encode(bitstream) {
+        bitstream.write_integer(this.m_shield_vitality_traits.m_damage_resistance_percentage_setting, 4);
+        bitstream.write_integer(this.m_shield_vitality_traits.m_body_multiplier, 3);
+        bitstream.write_integer(this.m_shield_vitality_traits.m_body_recharge_rate, 4);
+        bitstream.write_integer(this.m_shield_vitality_traits.m_shield_multiplier, 3);
+        bitstream.write_integer(this.m_shield_vitality_traits.m_shield_recharge_rate, 4);
+        bitstream.write_integer(this.m_shield_vitality_traits.m_overshield_recharge_rate, 4);
+        bitstream.write_integer(this.m_shield_vitality_traits.m_headshot_immunity_setting, 2);
+        bitstream.write_integer(this.m_shield_vitality_traits.m_vampirism_percentage_setting, 3);
+        bitstream.write_integer(this.m_shield_vitality_traits.m_assasination_immunity, 2);
+        bitstream.write_integer(this.m_shield_vitality_traits.m_cannot_die_from_damage, 2);
+        bitstream.write_integer(this.m_weapon_traits.m_damage_modifier_percentage_setting, 4);
+        bitstream.write_integer(this.m_weapon_traits.m_melee_damage_modifier_percentage_setting, 4);
+        bitstream.write_signed_integer(this.m_weapon_traits.m_initial_primary_weapon_absolute_index, 8);
+        bitstream.write_signed_integer(this.m_weapon_traits.m_initial_secondary_weapon_absolute_index, 8);
+        bitstream.write_integer(this.m_weapon_traits.m_initial_grenade_count_setting, 4);
+        bitstream.write_integer(this.m_weapon_traits.m_infinite_ammo_setting, 2);
+        bitstream.write_integer(this.m_weapon_traits.m_recharging_grenades_setting, 2);
+        bitstream.write_integer(this.m_weapon_traits.m_weapon_pickup_setting, 2);
+        bitstream.write_integer(this.m_weapon_traits.m_equipment_usage_setting, 2);
+        bitstream.write_integer(this.m_weapon_traits.m_equipment_drop_on_death_setting, 2);
+        bitstream.write_integer(this.m_weapon_traits.m_infinite_equipment_setting, 2);
+        bitstream.write_signed_integer(this.m_weapon_traits.m_initial_equipment_absolute_index, 8);
+        bitstream.write_integer(this.m_movement_traits.m_speed_setting, 5);
+        bitstream.write_integer(this.m_movement_traits.m_gravity_setting, 4);
+        bitstream.write_integer(this.m_movement_traits.m_vehicle_usage_setting, 4);
+        bitstream.write_integer(this.m_movement_traits.m_double_jump_setting, 2);
+        if (this.m_movement_traits.m_jump_modifier === -1) {
+            bitstream.write_bool(false);
+        }
+        else {
+            bitstream.write_bool(true);
+            bitstream.write_signed_integer(this.m_movement_traits.m_jump_modifier, 9);
+        }
+        bitstream.write_integer(this.m_appearance_traits.m_active_camo_setting, 3);
+        bitstream.write_integer(this.m_appearance_traits.m_waypoint_setting, 2);
+        bitstream.write_integer(this.m_appearance_traits.m_gamertag_setting, 2);
+        bitstream.write_integer(this.m_appearance_traits.m_aura_setting, 3);
+        bitstream.write_integer(this.m_appearance_traits.m_forced_change_color_setting, 4);
+        bitstream.write_integer(this.m_sensor_traits.m_motion_tracker_setting, 3);
+        bitstream.write_integer(this.m_sensor_traits.m_motion_tracker_range_setting, 3);
+        bitstream.write_integer(this.m_sensor_traits.m_directional_damage_setting, 2);
+    }
+}
+exports.c_player_traits = c_player_traits;

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

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.c_string_table = exports.c_single_language_string_table = exports.k_language_count = void 0;
+const bitstream_1 = require("../../../../bitstream");
+const data_compress_1 = require("../../../common/memory/data_compress");
+exports.k_language_count = 12;
+/** One wire byte per code unit (U+00–U+FF), matching blf_lib extended ASCII / NullString slots. */
+function read_null_terminated_string(data, offset) {
+    let end = offset;
+    while (end < data.length && data[end] !== 0) {
+        end++;
+    }
+    let out = "";
+    for (let i = offset; i < end; i++) {
+        out += String.fromCharCode(data[i]);
+    }
+    return out;
+}
+function write_null_terminated_string(writer, value, max_length) {
+    writer.write_string_extended_ascii(value, max_length);
+}
+/** Wire byte length (one byte per decoded code unit). */
+function string_byte_length(value) {
+    for (let i = 0; i < value.length; i++) {
+        if (value.charCodeAt(i) > 0xff) {
+            throw new Error(`String table entry U+${value.charCodeAt(i).toString(16)} cannot be encoded as Latin-1`);
+        }
+    }
+    return value.length;
+}
+function write_buffer_blob(bitstream, buffer, buffer_size_bit_length, is_compressed) {
+    bitstream.write_integer(buffer.length, buffer_size_bit_length);
+    if (is_compressed) {
+        const compressed = (0, data_compress_1.runtime_data_compress)(buffer, true);
+        bitstream.write_bool(true);
+        bitstream.write_integer(compressed.length, buffer_size_bit_length);
+        bitstream.write_raw_data(compressed, compressed.length * 8);
+    }
+    else {
+        bitstream.write_bool(false);
+        bitstream.write_raw_data(buffer, buffer.length * 8);
+    }
+}
+class c_single_language_string_table {
+    max_string_count;
+    max_string_length;
+    offset_bit_length;
+    buffer_size_bit_length;
+    count_bit_length;
+    strings = [];
+    m_buffer_is_compressed = true;
+    constructor(max_string_count, max_string_length, offset_bit_length, buffer_size_bit_length, count_bit_length) {
+        this.max_string_count = max_string_count;
+        this.max_string_length = max_string_length;
+        this.offset_bit_length = offset_bit_length;
+        this.buffer_size_bit_length = buffer_size_bit_length;
+        this.count_bit_length = count_bit_length;
+    }
+    decode(bitstream) {
+        this.strings = [];
+        const string_count = bitstream.read_integer("string-count", this.count_bit_length);
+        if (string_count === 0) {
+            return;
+        }
+        const offsets = [];
+        for (let i = 0; i < string_count; i++) {
+            if (bitstream.read_bool("exists")) {
+                offsets.push(bitstream.read_integer("offset", this.offset_bit_length));
+            }
+            else {
+                offsets.push(0);
+            }
+        }
+        const buffer_size = bitstream.read_integer("size", this.buffer_size_bit_length);
+        this.m_buffer_is_compressed = bitstream.read_bool("compressed");
+        const string_data = this.m_buffer_is_compressed
+            ? (0, data_compress_1.runtime_data_decompress)(bitstream.read_raw_data(bitstream.read_integer("compressed-buffer-size", this.buffer_size_bit_length) * 8))
+            : bitstream.read_raw_data(buffer_size * 8);
+        for (const offset of offsets) {
+            this.strings.push(read_null_terminated_string(string_data, offset));
+        }
+    }
+    encode(bitstream) {
+        bitstream.write_integer(this.strings.length, this.count_bit_length);
+        if (this.strings.length === 0) {
+            return;
+        }
+        const string_writer = bitstream_1.c_bitstream_writer.new_from_instance(this.max_string_count * this.max_string_length, bitstream);
+        string_writer.begin_writing();
+        let offset = 0;
+        for (const string of this.strings) {
+            bitstream.write_bool(true);
+            bitstream.write_integer(offset, this.offset_bit_length);
+            write_null_terminated_string(string_writer, string, this.max_string_length);
+            offset += string_byte_length(string) + 1;
+        }
+        string_writer.finish_writing();
+        const buffer = string_writer.get_data();
+        write_buffer_blob(bitstream, buffer, this.buffer_size_bit_length, this.m_buffer_is_compressed);
+    }
+}
+exports.c_single_language_string_table = c_single_language_string_table;
+class c_string_table {
+    max_string_count;
+    max_string_length;
+    offset_bit_length;
+    buffer_size_bit_length;
+    count_bit_length;
+    strings = Array.from({ length: exports.k_language_count }, () => []);
+    m_buffer_is_compressed = true;
+    constructor(max_string_count, max_string_length, offset_bit_length, buffer_size_bit_length, count_bit_length) {
+        this.max_string_count = max_string_count;
+        this.max_string_length = max_string_length;
+        this.offset_bit_length = offset_bit_length;
+        this.buffer_size_bit_length = buffer_size_bit_length;
+        this.count_bit_length = count_bit_length;
+    }
+    decode(bitstream) {
+        this.strings = Array.from({ length: exports.k_language_count }, () => []);
+        const string_count = bitstream.read_integer("string-count", this.count_bit_length);
+        if (string_count === 0) {
+            return;
+        }
+        const offsets = Array.from({ length: exports.k_language_count }, () => Array.from({ length: string_count }, () => -1));
+        for (let j = 0; j < string_count; j++) {
+            for (let i = 0; i < exports.k_language_count; i++) {
+                if (bitstream.read_bool("exists")) {
+                    offsets[i][j] = bitstream.read_integer("index", this.offset_bit_length);
+                }
+            }
+        }
+        const buffer_size = bitstream.read_integer("size", this.buffer_size_bit_length);
+        this.m_buffer_is_compressed = bitstream.read_bool("compressed");
+        const string_data = this.m_buffer_is_compressed
+            ? (0, data_compress_1.runtime_data_decompress)(bitstream.read_raw_data(bitstream.read_integer("compressed-buffer-size", this.buffer_size_bit_length) * 8))
+            : bitstream.read_raw_data(buffer_size * 8);
+        for (let i = 0; i < exports.k_language_count; i++) {
+            for (let j = 0; j < string_count; j++) {
+                const offset = offsets[i][j];
+                if (offset < 0) {
+                    this.strings[i].push(null);
+                }
+                else {
+                    this.strings[i].push(read_null_terminated_string(string_data, offset));
+                }
+            }
+        }
+    }
+    encode(bitstream) {
+        const string_count = this.strings[0]?.length ?? 0;
+        bitstream.write_integer(string_count, this.count_bit_length);
+        if (string_count === 0) {
+            return;
+        }
+        const string_writer = bitstream_1.c_bitstream_writer.new(exports.k_language_count * this.max_string_count * this.max_string_length, bitstream_1.e_bitstream_byte_order._bitstream_byte_order_big_endian);
+        string_writer.begin_writing();
+        let offset = 0;
+        for (let j = 0; j < string_count; j++) {
+            let deduplicate = true;
+            const reference = this.strings[0]?.[j] ?? null;
+            if (reference === null) {
+                deduplicate = false;
+            }
+            else {
+                for (let i = 1; i < exports.k_language_count; i++) {
+                    if (this.strings[i]?.[j] !== reference) {
+                        deduplicate = false;
+                        break;
+                    }
+                }
+            }
+            for (let i = 0; i < exports.k_language_count; i++) {
+                const string = this.strings[i]?.[j] ?? null;
+                if (string === null) {
+                    bitstream.write_bool(false);
+                    continue;
+                }
+                bitstream.write_bool(true);
+                bitstream.write_integer(offset, this.offset_bit_length);
+                if (!deduplicate) {
+                    write_null_terminated_string(string_writer, string, this.max_string_length);
+                    offset += string_byte_length(string) + 1;
+                }
+            }
+            if (deduplicate && reference !== null) {
+                write_null_terminated_string(string_writer, reference, this.max_string_length);
+                offset += string_byte_length(reference) + 1;
+            }
+        }
+        string_writer.finish_writing();
+        const buffer = string_writer.get_data();
+        write_buffer_blob(bitstream, buffer, this.buffer_size_bit_length, this.m_buffer_is_compressed);
+    }
+}
+exports.c_string_table = c_string_table;

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

@@ -0,0 +1,25 @@
+"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("./c_game_engine_custom_variant"), exports);
+__exportStar(require("./c_game_engine_custom_variant_au1_settings"), exports);
+__exportStar(require("./c_game_engine_default"), exports);
+__exportStar(require("./c_game_engine_survival_variant"), exports);
+__exportStar(require("./c_game_engine_traits"), exports);
+__exportStar(require("./c_game_variant"), exports);
+__exportStar(require("./c_player_traits"), exports);
+__exportStar(require("./c_string_table"), exports);
+__exportStar(require("./megalogamengine"), exports);

package/dist-cjs/blam/haloreach/v12065_11_08_24_1738_tu1actual/game/megalogamengine/c_megalo_game_statistic.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.c_megalo_game_statistic = void 0;
+class c_megalo_game_statistic {
+    m_name_string_index = 0;
+    m_format = 0;
+    m_sort_order = 0;
+    m_growuping = 0;
+    decode(bitstream) {
+        this.m_name_string_index = bitstream.read_integer("name-string-index", 7);
+        this.m_format = bitstream.read_integer("format", 2);
+        this.m_sort_order = bitstream.read_integer("sort-order", 2);
+        this.m_growuping = bitstream.read_integer("groupingt", 1);
+    }
+    encode(bitstream) {
+        bitstream.write_integer(this.m_name_string_index, 7);
+        bitstream.write_integer(this.m_format, 2);
+        bitstream.write_integer(this.m_sort_order, 2);
+        bitstream.write_integer(this.m_growuping, 1);
+    }
+}
+exports.c_megalo_game_statistic = c_megalo_game_statistic;

package/dist-cjs/blam/haloreach/v12065_11_08_24_1738_tu1actual/game/megalogamengine/c_megalogamengine_map_permissions.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.c_megalogamengine_map_permissions = void 0;
+class c_megalogamengine_map_permissions {
+    m_except_map_ids = [];
+    m_allow_by_default = false;
+    decode(bitstream) {
+        const map_id_count = bitstream.read_integer("exception-count", 6);
+        for (let i = 0; i < map_id_count; i++) {
+            this.m_except_map_ids.push(bitstream.read_integer("map-id", 16));
+        }
+        this.m_allow_by_default = bitstream.read_bool("default-permission");
+    }
+    encode(bitstream) {
+        bitstream.write_integer(this.m_except_map_ids.length, 6);
+        for (const map_id of this.m_except_map_ids) {
+            bitstream.write_integer(map_id, 16);
+        }
+        bitstream.write_bool(this.m_allow_by_default);
+    }
+}
+exports.c_megalogamengine_map_permissions = c_megalogamengine_map_permissions;

package/dist-cjs/blam/haloreach/v12065_11_08_24_1738_tu1actual/game/megalogamengine/c_object_filter.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.c_object_filter = void 0;
+const megalogamengine_references_1 = require("./megalogamengine_references");
+class c_object_filter {
+    m_label_string_index = 0;
+    m_valid_parameters = 0;
+    m_object_type;
+    m_team;
+    m_user_data;
+    m_min = 0;
+    decode(bitstream) {
+        this.m_label_string_index = bitstream.read_integer("label-string-index", 7);
+        this.m_valid_parameters = bitstream.read_integer("valid-parameters", 3);
+        if ((this.m_valid_parameters & 1) !== 0) {
+            const object_type = new megalogamengine_references_1.c_object_type_reference();
+            object_type.decode(bitstream);
+            this.m_object_type = object_type;
+        }
+        if ((this.m_valid_parameters & 2) !== 0) {
+            this.m_team = bitstream.read_integer("team", 4);
+        }
+        if ((this.m_valid_parameters & 4) !== 0) {
+            this.m_user_data = bitstream.read_signed_integer("user-data", 16);
+        }
+        this.m_min = bitstream.read_integer("min", 7);
+    }
+    encode(bitstream) {
+        bitstream.write_integer(this.m_label_string_index, 7);
+        bitstream.write_integer(this.m_valid_parameters, 3);
+        if ((this.m_valid_parameters & 1) !== 0) {
+            this.m_object_type.encode(bitstream);
+        }
+        if ((this.m_valid_parameters & 2) !== 0) {
+            bitstream.write_integer(this.m_team, 4);
+        }
+        if ((this.m_valid_parameters & 4) !== 0) {
+            bitstream.write_signed_integer(this.m_user_data, 16);
+        }
+        bitstream.write_integer(this.m_min, 7);
+    }
+}
+exports.c_object_filter = c_object_filter;

package/dist-cjs/blam/haloreach/v12065_11_08_24_1738_tu1actual/game/megalogamengine/c_trigger.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.c_trigger = exports.e_trigger_type = exports.e_trigger_execution_mode = void 0;
+var e_trigger_execution_mode;
+(function (e_trigger_execution_mode) {
+    e_trigger_execution_mode[e_trigger_execution_mode["normal"] = 0] = "normal";
+    e_trigger_execution_mode[e_trigger_execution_mode["for_each_player"] = 1] = "for_each_player";
+    e_trigger_execution_mode[e_trigger_execution_mode["for_each_player_randomly"] = 2] = "for_each_player_randomly";
+    e_trigger_execution_mode[e_trigger_execution_mode["for_each_team"] = 3] = "for_each_team";
+    e_trigger_execution_mode[e_trigger_execution_mode["for_each_object"] = 4] = "for_each_object";
+    e_trigger_execution_mode[e_trigger_execution_mode["for_each_object_with_label"] = 5] = "for_each_object_with_label";
+    e_trigger_execution_mode[e_trigger_execution_mode["unknown6"] = 6] = "unknown6";
+    e_trigger_execution_mode[e_trigger_execution_mode["unknown7"] = 7] = "unknown7";
+})(e_trigger_execution_mode || (exports.e_trigger_execution_mode = e_trigger_execution_mode = {}));
+var e_trigger_type;
+(function (e_trigger_type) {
+    e_trigger_type[e_trigger_type["normal"] = 0] = "normal";
+    e_trigger_type[e_trigger_type["subroutine"] = 1] = "subroutine";
+    e_trigger_type[e_trigger_type["on_init"] = 2] = "on_init";
+    e_trigger_type[e_trigger_type["on_local_init"] = 3] = "on_local_init";
+    e_trigger_type[e_trigger_type["on_host_migration"] = 4] = "on_host_migration";
+    e_trigger_type[e_trigger_type["on_object_death"] = 5] = "on_object_death";
+    e_trigger_type[e_trigger_type["local"] = 6] = "local";
+    e_trigger_type[e_trigger_type["pregame"] = 7] = "pregame";
+    e_trigger_type[e_trigger_type["incident"] = 8] = "incident";
+})(e_trigger_type || (exports.e_trigger_type = e_trigger_type = {}));
+class c_trigger {
+    m_execution_mode = e_trigger_execution_mode.normal;
+    m_trigger_type = e_trigger_type.normal;
+    m_object_filter_index = -1;
+    m_first_condition = 0;
+    m_condition_count = 0;
+    m_first_action = 0;
+    m_action_count = 0;
+    decode(bitstream) {
+        this.m_execution_mode = bitstream.read_enum("execution-mode", 3, e_trigger_execution_mode, { within_bits: true });
+        this.m_trigger_type = bitstream.read_enum("trigger-type", 3, e_trigger_type, { within_bits: true });
+        if (this.m_execution_mode ===
+            e_trigger_execution_mode.for_each_object_with_label) {
+            this.m_object_filter_index = bitstream.read_index("object-filter-index", 16, 4);
+        }
+        else {
+            this.m_object_filter_index = -1;
+        }
+        this.m_first_condition = bitstream.read_integer("first-condition", 9);
+        this.m_condition_count = bitstream.read_integer("condition-count", 10);
+        this.m_first_action = bitstream.read_integer("first-action", 10);
+        this.m_action_count = bitstream.read_integer("action-count", 11);
+    }
+    encode(bitstream) {
+        bitstream.write_enum(this.m_execution_mode, 3);
+        bitstream.write_enum(this.m_trigger_type, 3);
+        if (this.m_execution_mode ===
+            e_trigger_execution_mode.for_each_object_with_label) {
+            bitstream.write_index(this.m_object_filter_index, 16, 4);
+        }
+        bitstream.write_integer(this.m_first_condition, 9);
+        bitstream.write_integer(this.m_condition_count, 10);
+        bitstream.write_integer(this.m_first_action, 10);
+        bitstream.write_integer(this.m_action_count, 11);
+    }
+}
+exports.c_trigger = c_trigger;

package/dist-cjs/blam/haloreach/v12065_11_08_24_1738_tu1actual/game/megalogamengine/index.js

@@ -0,0 +1,29 @@
+"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("./c_megalo_game_statistic"), exports);
+__exportStar(require("./c_megalogamengine_map_permissions"), exports);
+__exportStar(require("./c_object_filter"), exports);
+__exportStar(require("./c_trigger"), exports);
+__exportStar(require("./megalogamengine_actions"), exports);
+__exportStar(require("./megalogamengine_conditions"), exports);
+__exportStar(require("./megalogamengine_references"), exports);
+__exportStar(require("./megalogamengine_text"), exports);
+__exportStar(require("./s_custom_game_engine_definition"), exports);
+__exportStar(require("./s_game_engine_player_rating_parameters"), exports);
+__exportStar(require("./s_user_defined_option"), exports);
+__exportStar(require("./s_variable_metadata"), exports);
+__exportStar(require("./s_variant_variable"), exports);