@blamnetwork/blf 1.0.0-alpha.4 → 1.0.0-beta.1

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

@@ -1,7 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.c_object_type_reference = exports.c_custom_timer_reference = exports.c_custom_variable_reference = exports.c_team_reference = exports.c_player_reference = exports.c_object_reference = exports.c_explicit_team = exports.c_explicit_object = exports.c_explicit_player = exports.e_custom_timer_type = void 0;
+exports.c_object_type_reference = exports.c_custom_timer_reference = exports.c_custom_variable_reference = exports.c_team_reference = exports.c_player_reference = exports.c_object_reference = exports.c_explicit_team = exports.c_explicit_object = exports.c_explicit_player = exports.e_custom_timer_type = exports.e_explicit_team_type = exports.e_explicit_player_type = exports.e_explicit_object_type = void 0;
 const error_1 = require("../../../../../error");
+const megalogamengine_explicit_object_1 = require("./megalogamengine_explicit_object");
+const megalogamengine_explicit_player_1 = require("./megalogamengine_explicit_player");
+const megalogamengine_explicit_team_1 = require("./megalogamengine_explicit_team");
+var megalogamengine_explicit_object_2 = require("./megalogamengine_explicit_object");
+Object.defineProperty(exports, "e_explicit_object_type", { enumerable: true, get: function () { return megalogamengine_explicit_object_2.e_explicit_object_type; } });
+var megalogamengine_explicit_player_2 = require("./megalogamengine_explicit_player");
+Object.defineProperty(exports, "e_explicit_player_type", { enumerable: true, get: function () { return megalogamengine_explicit_player_2.e_explicit_player_type; } });
+var megalogamengine_explicit_team_2 = require("./megalogamengine_explicit_team");
+Object.defineProperty(exports, "e_explicit_team_type", { enumerable: true, get: function () { return megalogamengine_explicit_team_2.e_explicit_team_type; } });
 function requireField(value, message) {
     if (value === undefined) {
         throw new error_1.BlfError(message);
@@ -19,32 +28,32 @@ var e_custom_timer_type;
     e_custom_timer_type[e_custom_timer_type["grace_period"] = 6] = "grace_period";
 })(e_custom_timer_type || (exports.e_custom_timer_type = e_custom_timer_type = {}));
 class c_explicit_player {
-    m_explicit_player_type = 0;
+    m_explicit_player_type = megalogamengine_explicit_player_1.e_explicit_player_type.no_player;
     decode(bitstream) {
-        this.m_explicit_player_type = bitstream.read_integer("explicit-player-type", 5);
+        this.m_explicit_player_type = bitstream.read_enum("explicit-player-type", 5, megalogamengine_explicit_player_1.e_explicit_player_type);
     }
     encode(bitstream) {
-        bitstream.write_integer(this.m_explicit_player_type, 5);
+        bitstream.write_enum(this.m_explicit_player_type, 5);
     }
 }
 exports.c_explicit_player = c_explicit_player;
 class c_explicit_object {
-    m_explicit_object_type = 0;
+    m_explicit_object_type = megalogamengine_explicit_object_1.e_explicit_object_type.no_object;
     decode(bitstream) {
-        this.m_explicit_object_type = bitstream.read_integer("explicit-object-type", 5);
+        this.m_explicit_object_type = bitstream.read_enum("explicit-object-type", 5, megalogamengine_explicit_object_1.e_explicit_object_type);
     }
     encode(bitstream) {
-        bitstream.write_integer(this.m_explicit_object_type, 5);
+        bitstream.write_enum(this.m_explicit_object_type, 5);
     }
 }
 exports.c_explicit_object = c_explicit_object;
 class c_explicit_team {
-    m_explicit_team_type = 0;
+    m_explicit_team_type = megalogamengine_explicit_team_1.e_explicit_team_type.no_team;
     decode(bitstream) {
-        this.m_explicit_team_type = bitstream.read_integer("explicit-team-type", 5);
+        this.m_explicit_team_type = bitstream.read_enum("explicit-team-type", 5, megalogamengine_explicit_team_1.e_explicit_team_type);
     }
     encode(bitstream) {
-        bitstream.write_integer(this.m_explicit_team_type, 5);
+        bitstream.write_enum(this.m_explicit_team_type, 5);
     }
 }
 exports.c_explicit_team = c_explicit_team;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.c_dynamic_string = exports.c_replaceable_token = exports.c_player_filter_modifier = void 0;
 const error_1 = require("../../../../../error");
+const megalogamengine_actions_1 = require("./megalogamengine_actions");
 const megalogamengine_references_1 = require("./megalogamengine_references");
 function requireField(value, message) {
     if (value === undefined) {
@@ -10,12 +11,12 @@ function requireField(value, message) {
     return value;
 }
 class c_player_filter_modifier {
-    m_type = 0;
+    m_type = megalogamengine_actions_1.e_player_filter_type.no_one;
     m_player;
     m_variable;
     decode(bitstream) {
-        this.m_type = bitstream.read_integer("type", 3);
-        if (this.m_type === 4) {
+        this.m_type = bitstream.read_enum("type", 3, megalogamengine_actions_1.e_player_filter_type);
+        if (this.m_type === megalogamengine_actions_1.e_player_filter_type.specific_player) {
             const player = new megalogamengine_references_1.c_player_reference();
             const variable = new megalogamengine_references_1.c_custom_variable_reference();
             player.decode(bitstream);
@@ -25,8 +26,8 @@ class c_player_filter_modifier {
         }
     }
     encode(bitstream) {
-        bitstream.write_integer(this.m_type, 3);
-        if (this.m_type === 4) {
+        bitstream.write_enum(this.m_type, 3);
+        if (this.m_type === megalogamengine_actions_1.e_player_filter_type.specific_player) {
             requireField(this.m_player, "m_player does not exist.").encode(bitstream);
             requireField(this.m_variable, "m_variable does not exist.").encode(bitstream);
         }

package/dist-cjs/blam/haloreach_mcc/v_untracked_25_08_19_1352/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_mcc/v_untracked_25_08_19_1352/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;

package/dist-cjs/blam/haloreach_mcc/v_untracked_25_08_19_1352/game/c_game_engine_default.js

@@ -0,0 +1,305 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.c_game_engine_base_variant = exports.c_game_engine_loadout_traits = exports.c_loadout_palette_traits = exports.c_loadout_traits = exports.c_game_engine_team_options = exports.c_game_engine_team_options_team = exports.k_game_variant_team_count = exports.c_game_engine_map_override_options = exports.c_game_engine_social_options = exports.c_game_engine_respawn_options = exports.c_game_engine_miscellaneous_options = void 0;
+const saved_game_files_1 = require("../saved_games/saved_game_files");
+const c_player_traits_1 = require("./c_player_traits");
+const c_string_table_1 = require("./c_string_table");
+class c_game_engine_miscellaneous_options {
+    m_teams_enabled = false;
+    m_round_reset_players = false;
+    m_round_reset_map = false;
+    m_perfection_enabled = false;
+    m_round_time_limit_minutes = 0;
+    m_round_limit = 0;
+    m_early_victory_win_count = 0;
+    m_sudden_death_time = 0;
+    m_grace_period = 0;
+    decode(bitstream) {
+        this.m_teams_enabled = bitstream.read_bool("miscellaneous-options-teams");
+        this.m_round_reset_players = bitstream.read_bool("miscellaneous-options-round-reset-players");
+        this.m_round_reset_map = bitstream.read_bool("miscellaneous-options-round-reset-map");
+        this.m_perfection_enabled = bitstream.read_bool("miscellaneous-options-perfection-enabled");
+        this.m_round_time_limit_minutes = bitstream.read_integer("miscellaneous-options-round-time-limit-minutes", 8);
+        this.m_round_limit = bitstream.read_integer("miscellaneous-options-round-limit", 5);
+        this.m_early_victory_win_count = bitstream.read_integer("miscellaneous-options-early-victory-win-count", 4);
+        this.m_sudden_death_time = bitstream.read_integer("sudden-death-time-limit", 7);
+        this.m_grace_period = bitstream.read_integer("grace-period", 5);
+    }
+    encode(bitstream) {
+        bitstream.write_bool(this.m_teams_enabled);
+        bitstream.write_bool(this.m_round_reset_players);
+        bitstream.write_bool(this.m_round_reset_map);
+        bitstream.write_bool(this.m_perfection_enabled);
+        bitstream.write_integer(this.m_round_time_limit_minutes, 8);
+        bitstream.write_integer(this.m_round_limit, 5);
+        bitstream.write_integer(this.m_early_victory_win_count, 4);
+        bitstream.write_integer(this.m_sudden_death_time, 7);
+        bitstream.write_integer(this.m_grace_period, 5);
+    }
+}
+exports.c_game_engine_miscellaneous_options = c_game_engine_miscellaneous_options;
+class c_game_engine_respawn_options {
+    m_inherit_respawn_time = false;
+    m_respawn_with_teammate = false;
+    m_respawn_at_location = false;
+    m_respawn_on_kills = false;
+    m_lives_per_round = 0;
+    m_team_lives_per_round = 0;
+    m_respawn_time_seconds = 0;
+    m_suicide_penalty_seconds = 0;
+    m_betrayal_penalty_seconds = 0;
+    m_respawn_growth_seconds = 0;
+    m_loadout_cam_time = 0;
+    m_respawn_player_traits_duration_seconds = 0;
+    m_respawn_player_traits = new c_player_traits_1.c_player_traits();
+    decode(bitstream) {
+        this.m_inherit_respawn_time = bitstream.read_bool("respawn-options-inherit-respawn-time");
+        this.m_respawn_with_teammate = bitstream.read_bool("respawn-options-respawn-with-teammate");
+        this.m_respawn_at_location = bitstream.read_bool("respawn-options-respawn-at-location");
+        this.m_respawn_on_kills = bitstream.read_bool("respawn-options-respawn-on-kills");
+        this.m_lives_per_round = bitstream.read_integer("respawn-options-lives-per-round", 6);
+        this.m_team_lives_per_round = bitstream.read_integer("respawn-options-team-lives-per-round", 7);
+        this.m_respawn_time_seconds = bitstream.read_integer("respawn-options-respawn-time", 8);
+        this.m_suicide_penalty_seconds = bitstream.read_integer("respawn-options-suicide-time", 8);
+        this.m_betrayal_penalty_seconds = bitstream.read_integer("respawn-options-betrayal-time", 8);
+        this.m_respawn_growth_seconds = bitstream.read_integer("respawn-options-respawn-growth-time", 4);
+        this.m_loadout_cam_time = bitstream.read_integer("respawn-options-initial-loadout-selection-time", 4);
+        this.m_respawn_player_traits_duration_seconds = bitstream.read_integer("respawn-options-player-traits-duration", 6);
+        this.m_respawn_player_traits.decode(bitstream);
+    }
+    encode(bitstream) {
+        bitstream.write_bool(this.m_inherit_respawn_time);
+        bitstream.write_bool(this.m_respawn_with_teammate);
+        bitstream.write_bool(this.m_respawn_at_location);
+        bitstream.write_bool(this.m_respawn_on_kills);
+        bitstream.write_integer(this.m_lives_per_round, 6);
+        bitstream.write_integer(this.m_team_lives_per_round, 7);
+        bitstream.write_integer(this.m_respawn_time_seconds, 8);
+        bitstream.write_integer(this.m_suicide_penalty_seconds, 8);
+        bitstream.write_integer(this.m_betrayal_penalty_seconds, 8);
+        bitstream.write_integer(this.m_respawn_growth_seconds, 4);
+        bitstream.write_integer(this.m_loadout_cam_time, 4);
+        bitstream.write_integer(this.m_respawn_player_traits_duration_seconds, 6);
+        this.m_respawn_player_traits.encode(bitstream);
+    }
+}
+exports.c_game_engine_respawn_options = c_game_engine_respawn_options;
+class c_game_engine_social_options {
+    m_flags = 0;
+    m_team_changing = 0;
+    m_observers_enabled = false;
+    decode(bitstream) {
+        this.m_observers_enabled = bitstream.read_bool("observers-enabled");
+        this.m_team_changing = bitstream.read_integer("team-changing", 2);
+        for (let i = 0; i < 5; i++) {
+            if (bitstream.read_bool(`social-flag-${i}`)) {
+                this.m_flags |= 1 << i;
+            }
+        }
+    }
+    encode(bitstream) {
+        bitstream.write_bool(this.m_observers_enabled);
+        bitstream.write_integer(this.m_team_changing, 2);
+        for (let i = 0; i < 5; i++) {
+            bitstream.write_bool(((this.m_flags >> i) & 1) !== 0);
+        }
+    }
+}
+exports.c_game_engine_social_options = c_game_engine_social_options;
+class c_game_engine_map_override_options {
+    m_flags = 0;
+    m_base_player_traits = new c_player_traits_1.c_player_traits();
+    m_weapon_set_absolute_index = 0;
+    m_vehicle_set_absolute_index = 0;
+    m_red_powerup_traits = new c_player_traits_1.c_player_traits();
+    m_blue_powerup_traits = new c_player_traits_1.c_player_traits();
+    m_yellow_powerup_traits = new c_player_traits_1.c_player_traits();
+    m_red_powerup_duration_seconds = 0;
+    m_blue_powerup_duration_seconds = 0;
+    m_yellow_powerup_duration_seconds = 0;
+    decode(bitstream) {
+        this.m_flags = bitstream.read_integer("flags", 6);
+        this.m_base_player_traits.decode(bitstream);
+        this.m_weapon_set_absolute_index = bitstream.read_signed_integer("map-override-weapon-set", 8);
+        this.m_vehicle_set_absolute_index = bitstream.read_signed_integer("map-override-vehicle-set", 8);
+        this.m_red_powerup_traits.decode(bitstream);
+        this.m_blue_powerup_traits.decode(bitstream);
+        this.m_yellow_powerup_traits.decode(bitstream);
+        this.m_red_powerup_duration_seconds = bitstream.read_integer("map-override-red-powerup-duration", 7);
+        this.m_blue_powerup_duration_seconds = bitstream.read_integer("map-override-blue-powerup-duration", 7);
+        this.m_yellow_powerup_duration_seconds = bitstream.read_integer("map-override-yellow-powerup-duration", 7);
+    }
+    encode(bitstream) {
+        bitstream.write_integer(this.m_flags, 6);
+        this.m_base_player_traits.encode(bitstream);
+        bitstream.write_signed_integer(this.m_weapon_set_absolute_index, 8);
+        bitstream.write_signed_integer(this.m_vehicle_set_absolute_index, 8);
+        this.m_red_powerup_traits.encode(bitstream);
+        this.m_blue_powerup_traits.encode(bitstream);
+        this.m_yellow_powerup_traits.encode(bitstream);
+        bitstream.write_integer(this.m_red_powerup_duration_seconds, 7);
+        bitstream.write_integer(this.m_blue_powerup_duration_seconds, 7);
+        bitstream.write_integer(this.m_yellow_powerup_duration_seconds, 7);
+    }
+}
+exports.c_game_engine_map_override_options = c_game_engine_map_override_options;
+exports.k_game_variant_team_count = 8;
+class c_game_engine_team_options_team {
+    m_team_enabled = false;
+    m_override_color_armour = false;
+    m_override_color_ui_text = false;
+    m_override_color_ui_bitmap = false;
+    m_name = new c_string_table_1.c_string_table(1, 32, 5, 6, 1);
+    m_team_initial_designator = 0;
+    m_model_override = 0;
+    m_team_color_override = 0;
+    m_team_ui_text_tint_color_override = 0;
+    m_team_ui_bitmap_tint_color_override = 0;
+    m_fireteam_count = 0;
+    decode(bitstream) {
+        this.m_override_color_ui_bitmap = bitstream.read_bool("team-override-ui-bitmap-color");
+        this.m_override_color_ui_text = bitstream.read_bool("team-override-ui-text-color");
+        this.m_override_color_armour = bitstream.read_bool("team-override-armour-color");
+        this.m_team_enabled = bitstream.read_bool("team-enabled");
+        this.m_name.decode(bitstream);
+        this.m_team_initial_designator = bitstream.read_integer("team-initial-designator", 4);
+        this.m_model_override = bitstream.read_integer("team-model-override", 1);
+        this.m_team_color_override = bitstream.read_integer("team-color-override", 32);
+        this.m_team_ui_text_tint_color_override = bitstream.read_integer("team-ui-text-tint-color-override", 32);
+        this.m_team_ui_bitmap_tint_color_override = bitstream.read_integer("team-ui-bitmap-tint-color-override", 32);
+        this.m_fireteam_count = bitstream.read_integer("fireteam-count", 5);
+    }
+    encode(bitstream) {
+        bitstream.write_bool(this.m_override_color_ui_bitmap);
+        bitstream.write_bool(this.m_override_color_ui_text);
+        bitstream.write_bool(this.m_override_color_armour);
+        bitstream.write_bool(this.m_team_enabled);
+        this.m_name.encode(bitstream);
+        bitstream.write_integer(this.m_team_initial_designator, 4);
+        bitstream.write_integer(this.m_model_override, 1);
+        bitstream.write_integer(this.m_team_color_override, 32);
+        bitstream.write_integer(this.m_team_ui_text_tint_color_override, 32);
+        bitstream.write_integer(this.m_team_ui_bitmap_tint_color_override, 32);
+        bitstream.write_integer(this.m_fireteam_count, 5);
+    }
+}
+exports.c_game_engine_team_options_team = c_game_engine_team_options_team;
+class c_game_engine_team_options {
+    m_model_override = 0;
+    m_designator_switch_type = 0;
+    m_teams = Array.from({ length: exports.k_game_variant_team_count }, () => new c_game_engine_team_options_team());
+    decode(bitstream) {
+        this.m_model_override = bitstream.read_integer("model-override", 3);
+        this.m_designator_switch_type = bitstream.read_integer("designator-switch-type", 2);
+        for (const team of this.m_teams) {
+            team.decode(bitstream);
+        }
+    }
+    encode(bitstream) {
+        bitstream.write_integer(this.m_model_override, 3);
+        bitstream.write_integer(this.m_designator_switch_type, 2);
+        for (const team of this.m_teams) {
+            team.encode(bitstream);
+        }
+    }
+}
+exports.c_game_engine_team_options = c_game_engine_team_options;
+class c_loadout_traits {
+    m_visible = false;
+    m_name = 0;
+    m_initial_primary_weapon_absolute_index = 0;
+    m_initial_secondary_weapon_absolute_index = 0;
+    m_initial_equipment_absolute_index = 0;
+    m_initial_grenade_count_setting = 0;
+    decode(bitstream) {
+        this.m_visible = bitstream.read_bool("flags");
+        this.m_name = bitstream.read_index("name", 128, 7);
+        this.m_initial_primary_weapon_absolute_index =
+            bitstream.read_signed_integer("initial-primary-weapon", 8);
+        this.m_initial_secondary_weapon_absolute_index =
+            bitstream.read_signed_integer("initial-secondary-weapon", 8);
+        this.m_initial_equipment_absolute_index = bitstream.read_signed_integer("initial-equipment", 8);
+        this.m_initial_grenade_count_setting = bitstream.read_integer("initial-grenade-count", 4);
+    }
+    encode(bitstream) {
+        bitstream.write_bool(this.m_visible);
+        bitstream.write_index(this.m_name, 128, 7);
+        bitstream.write_signed_integer(this.m_initial_primary_weapon_absolute_index, 8);
+        bitstream.write_signed_integer(this.m_initial_secondary_weapon_absolute_index, 8);
+        bitstream.write_signed_integer(this.m_initial_equipment_absolute_index, 8);
+        bitstream.write_integer(this.m_initial_grenade_count_setting, 4);
+    }
+}
+exports.c_loadout_traits = c_loadout_traits;
+class c_loadout_palette_traits {
+    m_loadouts = Array.from({ length: 5 }, () => new c_loadout_traits());
+    decode(bitstream) {
+        for (const loadout of this.m_loadouts) {
+            loadout.decode(bitstream);
+        }
+    }
+    encode(bitstream) {
+        for (const loadout of this.m_loadouts) {
+            loadout.encode(bitstream);
+        }
+    }
+}
+exports.c_loadout_palette_traits = c_loadout_palette_traits;
+class c_game_engine_loadout_traits {
+    m_flags = 0;
+    m_loadout_palettes = Array.from({ length: 6 }, () => new c_loadout_palette_traits());
+    decode(bitstream) {
+        this.m_flags = bitstream.read_integer("loadout-flags", 2);
+        for (const palette of this.m_loadout_palettes) {
+            palette.decode(bitstream);
+        }
+    }
+    encode(bitstream) {
+        bitstream.write_integer(this.m_flags, 2);
+        for (const palette of this.m_loadout_palettes) {
+            palette.encode(bitstream);
+        }
+    }
+}
+exports.c_game_engine_loadout_traits = c_game_engine_loadout_traits;
+class c_game_engine_base_variant {
+    m_metadata = (() => {
+        const metadata = new saved_game_files_1.s_content_item_metadata();
+        metadata.general = new saved_game_files_1.s_content_item_general_metadata();
+        metadata.display = new saved_game_files_1.s_content_item_display_metadata();
+        metadata.creation_history = new saved_game_files_1.s_content_item_history();
+        metadata.modification_history = new saved_game_files_1.s_content_item_history();
+        return metadata;
+    })();
+    m_built_in = false;
+    m_miscellaneous_options = new c_game_engine_miscellaneous_options();
+    m_respawn_options = new c_game_engine_respawn_options();
+    m_social_options = new c_game_engine_social_options();
+    m_map_override_options = new c_game_engine_map_override_options();
+    m_team_scoring_method = 0;
+    m_team_options = new c_game_engine_team_options();
+    m_loadouts = new c_game_engine_loadout_traits();
+    decode(bitstream) {
+        (0, saved_game_files_1.content_item_metadata_decode)(bitstream, this.m_metadata);
+        this.m_built_in = bitstream.read_bool("variant-built-in");
+        this.m_miscellaneous_options.decode(bitstream);
+        this.m_respawn_options.decode(bitstream);
+        this.m_social_options.decode(bitstream);
+        this.m_map_override_options.decode(bitstream);
+        this.m_team_scoring_method = bitstream.read_integer("team-scoring-method", 3);
+        this.m_team_options.decode(bitstream);
+        this.m_loadouts.decode(bitstream);
+    }
+    encode(bitstream) {
+        (0, saved_game_files_1.content_item_metadata_encode)(bitstream, this.m_metadata);
+        bitstream.write_bool(this.m_built_in);
+        this.m_miscellaneous_options.encode(bitstream);
+        this.m_respawn_options.encode(bitstream);
+        this.m_social_options.encode(bitstream);
+        this.m_map_override_options.encode(bitstream);
+        bitstream.write_integer(this.m_team_scoring_method, 3);
+        this.m_team_options.encode(bitstream);
+        this.m_loadouts.encode(bitstream);
+    }
+}
+exports.c_game_engine_base_variant = c_game_engine_base_variant;