@blamnetwork/blf 1.0.0-alpha.5 → 1.0.0-beta.2

package/dist-cjs/blam/haloreach_mcc/v_untracked_25_08_19_1352/game/megalogamengine/s_custom_game_engine_definition.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.s_custom_game_engine_definition = void 0;
+const c_megalo_game_statistic_1 = require("./c_megalo_game_statistic");
+const c_object_filter_1 = require("./c_object_filter");
+const c_trigger_1 = require("./c_trigger");
+const megalogamengine_actions_1 = require("./megalogamengine_actions");
+const megalogamengine_conditions_1 = require("./megalogamengine_conditions");
+const s_variable_metadata_1 = require("./s_variable_metadata");
+class s_custom_game_engine_definition {
+    m_conditions = [];
+    m_actions = [];
+    m_triggers = [];
+    m_statistics = [];
+    m_global_variable_metadata = (0, s_variable_metadata_1.s_variable_metadata_global)();
+    m_player_variable_metadata = (0, s_variable_metadata_1.s_variable_metadata_player)();
+    m_object_variable_metadata = (0, s_variable_metadata_1.s_variable_metadata_object)();
+    m_team_variable_metadata = (0, s_variable_metadata_1.s_variable_metadata_team)();
+    m_hud_widgets = [];
+    m_initialization_trigger_index = 0;
+    m_local_initialization_trigger_index = 0;
+    m_host_migration_trigger_index = 0;
+    m_double_migration_trigger_index = 0;
+    m_object_death_event_trigger_index = 0;
+    m_local_trigger_index = 0;
+    m_pregame_trigger_index = 0;
+    m_objects_used = Array.from({ length: 2048 }, () => false);
+    m_object_filters = [];
+    decode(bitstream) {
+        const condition_count = bitstream.read_integer("condition-count", 10);
+        for (let i = 0; i < condition_count; i++) {
+            const condition = new megalogamengine_conditions_1.c_condition();
+            condition.decode(bitstream);
+            this.m_conditions.push(condition);
+        }
+        const action_count = bitstream.read_integer("action-count", 11);
+        for (let i = 0; i < action_count; i++) {
+            const action = new megalogamengine_actions_1.c_action();
+            action.decode(bitstream);
+            this.m_actions.push(action);
+        }
+        const trigger_count = bitstream.read_integer("trigger-count", 9);
+        for (let i = 0; i < trigger_count; i++) {
+            const trigger = new c_trigger_1.c_trigger();
+            trigger.decode(bitstream);
+            this.m_triggers.push(trigger);
+        }
+        const statistic_count = bitstream.read_integer("game-statistic-count", 3);
+        for (let i = 0; i < statistic_count; i++) {
+            const statistic = new c_megalo_game_statistic_1.c_megalo_game_statistic();
+            statistic.decode(bitstream);
+            this.m_statistics.push(statistic);
+        }
+        this.m_global_variable_metadata.decode(bitstream);
+        this.m_player_variable_metadata.decode(bitstream);
+        this.m_object_variable_metadata.decode(bitstream);
+        this.m_team_variable_metadata.decode(bitstream);
+        const widget_count = bitstream.read_integer("hud-widget-count", 3);
+        for (let i = 0; i < widget_count; i++) {
+            this.m_hud_widgets.push(bitstream.read_integer("position", 4));
+        }
+        this.m_initialization_trigger_index = bitstream.read_integer("initial-trigger-index", 9);
+        this.m_local_initialization_trigger_index = bitstream.read_integer("local-initialization-trigger-index", 9);
+        this.m_host_migration_trigger_index = bitstream.read_integer("host-migration-trigger-index", 9);
+        this.m_double_migration_trigger_index = bitstream.read_integer("double-migration-trigger-index", 9);
+        this.m_object_death_event_trigger_index = bitstream.read_integer("death-event-trigger-index", 9);
+        this.m_local_trigger_index = bitstream.read_integer("local-trigger-index", 9);
+        this.m_pregame_trigger_index = bitstream.read_integer("pregame-trigger-index", 9);
+        for (let i = 0; i < 2048; i++) {
+            this.m_objects_used[i] = bitstream.read_bool("object-types-used");
+        }
+        const object_filter_count = bitstream.read_integer("object-filter-count", 5);
+        for (let i = 0; i < object_filter_count; i++) {
+            const filter = new c_object_filter_1.c_object_filter();
+            filter.decode(bitstream);
+            this.m_object_filters.push(filter);
+        }
+    }
+    encode(bitstream) {
+        bitstream.write_integer(this.m_conditions.length, 10);
+        for (const condition of this.m_conditions) {
+            condition.encode(bitstream);
+        }
+        bitstream.write_integer(this.m_actions.length, 11);
+        for (const action of this.m_actions) {
+            action.encode(bitstream);
+        }
+        bitstream.write_integer(this.m_triggers.length, 9);
+        for (const trigger of this.m_triggers) {
+            trigger.encode(bitstream);
+        }
+        bitstream.write_integer(this.m_statistics.length, 3);
+        for (const statistic of this.m_statistics) {
+            statistic.encode(bitstream);
+        }
+        this.m_global_variable_metadata.encode(bitstream);
+        this.m_player_variable_metadata.encode(bitstream);
+        this.m_object_variable_metadata.encode(bitstream);
+        this.m_team_variable_metadata.encode(bitstream);
+        bitstream.write_integer(this.m_hud_widgets.length, 3);
+        for (const widget of this.m_hud_widgets) {
+            bitstream.write_integer(widget, 4);
+        }
+        bitstream.write_integer(this.m_initialization_trigger_index, 9);
+        bitstream.write_integer(this.m_local_initialization_trigger_index, 9);
+        bitstream.write_integer(this.m_host_migration_trigger_index, 9);
+        bitstream.write_integer(this.m_double_migration_trigger_index, 9);
+        bitstream.write_integer(this.m_object_death_event_trigger_index, 9);
+        bitstream.write_integer(this.m_local_trigger_index, 9);
+        bitstream.write_integer(this.m_pregame_trigger_index, 9);
+        for (const used of this.m_objects_used) {
+            bitstream.write_bool(used);
+        }
+        bitstream.write_integer(this.m_object_filters.length, 5);
+        for (const filter of this.m_object_filters) {
+            filter.encode(bitstream);
+        }
+    }
+}
+exports.s_custom_game_engine_definition = s_custom_game_engine_definition;

package/dist-cjs/blam/haloreach_mcc/v_untracked_25_08_19_1352/game/megalogamengine/s_game_engine_player_rating_parameters.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.s_game_engine_player_rating_parameters = void 0;
+class s_game_engine_player_rating_parameters {
+    m_rating_scale = 0;
+    m_kill_weight = 0;
+    m_assist_weight = 0;
+    m_betrayal_weight = 0;
+    m_death_weight = 0;
+    m_normalize_by_max_kills = 0;
+    m_base = 0;
+    m_range = 0;
+    m_loss_scalar = 0;
+    m_custom_stat_0 = 0;
+    m_custom_stat_1 = 0;
+    m_custom_stat_2 = 0;
+    m_custom_stat_3 = 0;
+    m_expansion_0 = 0;
+    m_expansion_1 = 0;
+    m_show_in_scoreboard = false;
+    decode(bitstream) {
+        this.m_rating_scale = bitstream.read_float("player-rating-parameter", 32);
+        this.m_kill_weight = bitstream.read_float("player-rating-parameter", 32);
+        this.m_assist_weight = bitstream.read_float("player-rating-parameter", 32);
+        this.m_betrayal_weight = bitstream.read_float("player-rating-parameter", 32);
+        this.m_death_weight = bitstream.read_float("player-rating-parameter", 32);
+        this.m_normalize_by_max_kills = bitstream.read_float("player-rating-parameter", 32);
+        this.m_base = bitstream.read_float("player-rating-parameter", 32);
+        this.m_range = bitstream.read_float("player-rating-parameter", 32);
+        this.m_loss_scalar = bitstream.read_float("player-rating-parameter", 32);
+        this.m_custom_stat_0 = bitstream.read_float("player-rating-parameter", 32);
+        this.m_custom_stat_1 = bitstream.read_float("player-rating-parameter", 32);
+        this.m_custom_stat_2 = bitstream.read_float("player-rating-parameter", 32);
+        this.m_custom_stat_3 = bitstream.read_float("player-rating-parameter", 32);
+        this.m_expansion_0 = bitstream.read_float("player-rating-parameter", 32);
+        this.m_expansion_1 = bitstream.read_float("player-rating-parameter", 32);
+        this.m_show_in_scoreboard = bitstream.read_bool("flags");
+    }
+    encode(bitstream) {
+        bitstream.write_float(this.m_rating_scale, 32);
+        bitstream.write_float(this.m_kill_weight, 32);
+        bitstream.write_float(this.m_assist_weight, 32);
+        bitstream.write_float(this.m_betrayal_weight, 32);
+        bitstream.write_float(this.m_death_weight, 32);
+        bitstream.write_float(this.m_normalize_by_max_kills, 32);
+        bitstream.write_float(this.m_base, 32);
+        bitstream.write_float(this.m_range, 32);
+        bitstream.write_float(this.m_loss_scalar, 32);
+        bitstream.write_float(this.m_custom_stat_0, 32);
+        bitstream.write_float(this.m_custom_stat_1, 32);
+        bitstream.write_float(this.m_custom_stat_2, 32);
+        bitstream.write_float(this.m_custom_stat_3, 32);
+        bitstream.write_float(this.m_expansion_0, 32);
+        bitstream.write_float(this.m_expansion_1, 32);
+        bitstream.write_bool(this.m_show_in_scoreboard);
+    }
+}
+exports.s_game_engine_player_rating_parameters = s_game_engine_player_rating_parameters;

package/dist-cjs/blam/haloreach_mcc/v_untracked_25_08_19_1352/game/megalogamengine/s_user_defined_option.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.s_user_defined_option = exports.s_user_defined_option_value = void 0;
+class s_user_defined_option_value {
+    m_value = 0;
+    m_name_string_index;
+    m_description_string_index;
+    decode(bitstream, is_range) {
+        this.m_value = bitstream.read_signed_integer("value", 10);
+        if (is_range) {
+            this.m_name_string_index = -1;
+            this.m_description_string_index = -1;
+        }
+        else {
+            this.m_name_string_index = bitstream.read_integer("name-string-index", 7);
+            this.m_description_string_index = bitstream.read_integer("description-string-index", 7);
+        }
+    }
+    encode(bitstream, is_range) {
+        bitstream.write_signed_integer(this.m_value, 10);
+        if (!is_range) {
+            bitstream.write_integer(this.m_name_string_index, 7);
+            bitstream.write_integer(this.m_description_string_index, 7);
+        }
+    }
+}
+exports.s_user_defined_option_value = s_user_defined_option_value;
+class s_user_defined_option {
+    m_name_string_index = 0;
+    m_description_string_index = 0;
+    m_range_default_value;
+    m_range_min_value;
+    m_range_max_value;
+    m_range_current_value;
+    m_default_value_index;
+    m_values;
+    m_current_value_index;
+    decode(bitstream) {
+        this.m_name_string_index = bitstream.read_integer("name-string-index", 7);
+        this.m_description_string_index = bitstream.read_integer("description-string-index", 7);
+        if (bitstream.read_bool("is-ranged-option")) {
+            const range_default = new s_user_defined_option_value();
+            const range_min = new s_user_defined_option_value();
+            const range_max = new s_user_defined_option_value();
+            range_default.decode(bitstream, true);
+            range_min.decode(bitstream, true);
+            range_max.decode(bitstream, true);
+            this.m_range_default_value = range_default;
+            this.m_range_min_value = range_min;
+            this.m_range_max_value = range_max;
+            this.m_range_current_value = bitstream.read_signed_integer("user-defined-option-value", 10);
+        }
+        else {
+            this.m_default_value_index = bitstream.read_integer("default-value-index", 3);
+            const value_count = bitstream.read_integer("value-count", 4);
+            const values = [];
+            for (let i = 0; i < value_count; i++) {
+                const value = new s_user_defined_option_value();
+                value.decode(bitstream, false);
+                values.push(value);
+            }
+            this.m_values = values;
+            this.m_current_value_index = bitstream.read_integer("current-value-index", 3);
+        }
+    }
+    encode(bitstream) {
+        bitstream.write_integer(this.m_name_string_index, 7);
+        bitstream.write_integer(this.m_description_string_index, 7);
+        if (this.m_range_default_value === undefined) {
+            bitstream.write_bool(false);
+            bitstream.write_integer(this.m_default_value_index, 3);
+            bitstream.write_integer(this.m_values.length, 4);
+            for (const value of this.m_values) {
+                value.encode(bitstream, false);
+            }
+            bitstream.write_integer(this.m_current_value_index, 3);
+        }
+        else {
+            bitstream.write_bool(true);
+            this.m_range_default_value.encode(bitstream, true);
+            this.m_range_min_value.encode(bitstream, true);
+            this.m_range_max_value.encode(bitstream, true);
+            bitstream.write_signed_integer(this.m_range_current_value, 10);
+        }
+    }
+}
+exports.s_user_defined_option = s_user_defined_option;

package/dist-cjs/blam/haloreach_mcc/v_untracked_25_08_19_1352/game/megalogamengine/s_variable_metadata.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.s_variable_metadata = void 0;
+exports.s_variable_metadata_global = s_variable_metadata_global;
+exports.s_variable_metadata_player = s_variable_metadata_player;
+exports.s_variable_metadata_object = s_variable_metadata_object;
+exports.s_variable_metadata_team = s_variable_metadata_team;
+const megalogamengine_references_1 = require("./megalogamengine_references");
+class s_variable_metadata {
+    numeric_variable_count_bits;
+    timer_variable_count_bits;
+    team_variable_count_bits;
+    player_variable_count_bits;
+    object_variable_count_bits;
+    m_numeric_variables = [];
+    m_timer_variables = [];
+    m_team_variables = [];
+    m_player_variables = [];
+    m_object_variables = [];
+    constructor(numeric_variable_count_bits, timer_variable_count_bits, team_variable_count_bits, player_variable_count_bits, object_variable_count_bits) {
+        this.numeric_variable_count_bits = numeric_variable_count_bits;
+        this.timer_variable_count_bits = timer_variable_count_bits;
+        this.team_variable_count_bits = team_variable_count_bits;
+        this.player_variable_count_bits = player_variable_count_bits;
+        this.object_variable_count_bits = object_variable_count_bits;
+    }
+    decode(bitstream) {
+        const numeric_variable_count = bitstream.read_integer("numeric-variable-count", this.numeric_variable_count_bits);
+        for (let i = 0; i < numeric_variable_count; i++) {
+            const numeric_variable = new megalogamengine_references_1.c_custom_variable_reference();
+            numeric_variable.decode(bitstream);
+            const network_state = bitstream.read_integer("network-state", 2);
+            this.m_numeric_variables.push([numeric_variable, network_state]);
+        }
+        const timer_variable_count = bitstream.read_integer("timer-variable-count", this.timer_variable_count_bits);
+        for (let i = 0; i < timer_variable_count; i++) {
+            const timer_variable = new megalogamengine_references_1.c_custom_variable_reference();
+            timer_variable.decode(bitstream);
+            this.m_timer_variables.push(timer_variable);
+        }
+        const team_variable_count = bitstream.read_integer("team-variable-count", this.team_variable_count_bits);
+        for (let i = 0; i < team_variable_count; i++) {
+            const team_variable_value = bitstream.read_integer("team-variable-value", 4);
+            const network_state = bitstream.read_integer("network-state", 2);
+            this.m_team_variables.push([team_variable_value, network_state]);
+        }
+        const player_variable_count = bitstream.read_integer("player-variable-count", this.player_variable_count_bits);
+        for (let i = 0; i < player_variable_count; i++) {
+            this.m_player_variables.push(bitstream.read_integer("network-state", 2));
+        }
+        const object_variable_count = bitstream.read_integer("object-variable-count", this.object_variable_count_bits);
+        for (let i = 0; i < object_variable_count; i++) {
+            this.m_object_variables.push(bitstream.read_integer("network-state", 2));
+        }
+    }
+    encode(bitstream) {
+        bitstream.write_integer(this.m_numeric_variables.length, this.numeric_variable_count_bits);
+        for (const [numeric_variable, network_state] of this.m_numeric_variables) {
+            numeric_variable.encode(bitstream);
+            bitstream.write_integer(network_state, 2);
+        }
+        bitstream.write_integer(this.m_timer_variables.length, this.timer_variable_count_bits);
+        for (const timer_variable of this.m_timer_variables) {
+            timer_variable.encode(bitstream);
+        }
+        bitstream.write_integer(this.m_team_variables.length, this.team_variable_count_bits);
+        for (const [team_variable, network_state] of this.m_team_variables) {
+            bitstream.write_integer(team_variable, 4);
+            bitstream.write_integer(network_state, 2);
+        }
+        bitstream.write_integer(this.m_player_variables.length, this.player_variable_count_bits);
+        for (const network_state of this.m_player_variables) {
+            bitstream.write_integer(network_state, 2);
+        }
+        bitstream.write_integer(this.m_object_variables.length, this.object_variable_count_bits);
+        for (const network_state of this.m_object_variables) {
+            bitstream.write_integer(network_state, 2);
+        }
+    }
+}
+exports.s_variable_metadata = s_variable_metadata;
+function s_variable_metadata_global() {
+    return new s_variable_metadata(4, 4, 4, 4, 5);
+}
+function s_variable_metadata_player() {
+    return new s_variable_metadata(4, 3, 3, 3, 3);
+}
+function s_variable_metadata_object() {
+    return new s_variable_metadata(4, 3, 2, 3, 3);
+}
+function s_variable_metadata_team() {
+    return new s_variable_metadata(4, 3, 3, 3, 3);
+}

package/dist-cjs/blam/haloreach_mcc/v_untracked_25_08_19_1352/game/megalogamengine/s_variant_variable.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.s_variant_variable = void 0;
+const error_1 = require("../../../../../error");
+const megalogamengine_references_1 = require("./megalogamengine_references");
+function requireField(value, message) {
+    if (value === undefined) {
+        throw new error_1.BlfError(message);
+    }
+    return value;
+}
+class s_variant_variable {
+    m_type = 0;
+    m_player;
+    m_object;
+    m_team;
+    m_custom_timer;
+    m_custom_variable;
+    decode(bitstream) {
+        this.m_type = bitstream.read_integer("type", 3);
+        switch (this.m_type) {
+            case 0: {
+                const custom_variable = new megalogamengine_references_1.c_custom_variable_reference();
+                custom_variable.decode(bitstream);
+                this.m_custom_variable = custom_variable;
+                break;
+            }
+            case 1: {
+                const player = new megalogamengine_references_1.c_player_reference();
+                player.decode(bitstream);
+                this.m_player = player;
+                break;
+            }
+            case 2: {
+                const object = new megalogamengine_references_1.c_object_reference();
+                object.decode(bitstream);
+                this.m_object = object;
+                break;
+            }
+            case 3: {
+                const team = new megalogamengine_references_1.c_team_reference();
+                team.decode(bitstream);
+                this.m_team = team;
+                break;
+            }
+            case 4: {
+                const custom_timer = new megalogamengine_references_1.c_custom_timer_reference();
+                custom_timer.decode(bitstream);
+                this.m_custom_timer = custom_timer;
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    encode(bitstream) {
+        bitstream.write_integer(this.m_type, 3);
+        switch (this.m_type) {
+            case 0:
+                requireField(this.m_custom_variable, "m_custom_variable does not exist.").encode(bitstream);
+                break;
+            case 1:
+                requireField(this.m_player, "m_player does not exist.").encode(bitstream);
+                break;
+            case 2:
+                requireField(this.m_object, "m_object does not exist.").encode(bitstream);
+                break;
+            case 3:
+                requireField(this.m_team, "m_team does not exist.").encode(bitstream);
+                break;
+            case 4:
+                requireField(this.m_custom_timer, "m_custom_timer does not exist.").encode(bitstream);
+                break;
+            default:
+                throw new error_1.BlfError(`Invalid s_variant_variable: type ${this.m_type}`);
+        }
+    }
+}
+exports.s_variant_variable = s_variant_variable;

package/dist-cjs/blam/haloreach_mcc/v_untracked_25_08_19_1352/index.js

@@ -0,0 +1,19 @@
+"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("../../common"), exports);
+__exportStar(require("./game"), exports);
+__exportStar(require("./saved_games"), exports);

package/dist-cjs/blam/haloreach_mcc/v_untracked_25_08_19_1352/saved_games/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("./saved_game_files"), exports);