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

package/dist-cjs/helpers/automap.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Stage-3 `@AutoMap` for Reach gametype classes.
+ * Compatible with `@craftycodie/cstruct` field decorators in the same project.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTOMAP_PROPERTIES_METADATA_KEY = void 0;
+exports.AutoMap = AutoMap;
+exports.stage3AutoMapMetadata = stage3AutoMapMetadata;
+const classes_1 = require("@automapper/classes");
+var classes_2 = require("@automapper/classes");
+Object.defineProperty(exports, "AUTOMAP_PROPERTIES_METADATA_KEY", { enumerable: true, get: function () { return classes_2.AUTOMAP_PROPERTIES_METADATA_KEY; } });
+function resolveOptions(typeFnOrOptions) {
+    if (typeFnOrOptions === undefined) {
+        throw new Error("@AutoMap requires an explicit type, e.g. @AutoMap(() => MyType)");
+    }
+    if (typeof typeFnOrOptions === "function") {
+        return {
+            type: typeFnOrOptions,
+            depth: 1,
+        };
+    }
+    return { depth: 1, ...typeFnOrOptions };
+}
+function AutoMap(typeFnOrOptions) {
+    const options = resolveOptions(typeFnOrOptions);
+    return (_value, context) => {
+        if (context.kind !== "field") {
+            return;
+        }
+        const metadata = context.metadata;
+        const list = metadata[classes_1.AUTOMAP_PROPERTIES_METADATA_KEY] ?? [];
+        list.push([String(context.name), options]);
+        metadata[classes_1.AUTOMAP_PROPERTIES_METADATA_KEY] = list;
+    };
+}
+function stage3AutoMapMetadata(ctor) {
+    const classMetadata = ctor[Symbol.metadata];
+    return classMetadata?.[classes_1.AUTOMAP_PROPERTIES_METADATA_KEY] ?? [];
+}

package/dist-cjs/helpers/convert_reach_gametype.js

@@ -1,50 +1,55 @@
 "use strict";
 /**
- * Convert game variants between Halo Reach TU1 and MCC builds.
+ * Convert game variants between Halo: Reach TU1 (Xbox 360) and MCC.
  *
- * JSON-clone the variant, reject MCC-only megalo features, remap what moved
- * between builds, then write the four top-level fields onto `to`.
+ * Cross-build conversion uses AutoMapper (`@automapper/core` + `@automapper/classes`)
+ * with profiles registered from the source instance graph, then applies build-specific
+ * remaps in place on the mapped target instances.
  *
- * Differences handled here:
- * - MCC-only: temporary explicit refs, `<<=`, `>>=`
- * - `set_to_absolute` exists in both builds but moved (TU1 = 10, MCC = 12)
- * - Survival: unrelated fields — MCC→TU1 sets `m_campaign_difficulty_level` to 1;
- *   TU1→MCC sets `m_encoding_version` to 2; `m_additional_flags` only on MCC
+ * TU1 → MCC is always possible for supported variant kinds (custom / survival).
+ * MCC → TU1 rejects MCC-only megalo features and fails when temporary object,
+ * player, or team references cannot be mapped onto free global slots.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.e_reach_gametype_conversion_error = void 0;
 exports.convert_reach_gametype = convert_reach_gametype;
 const c_game_variant_1 = require("../blam/haloreach/v12065_11_08_24_1738_tu1actual/game/c_game_variant");
-const megalogamengine_actions_1 = require("../blam/haloreach/v12065_11_08_24_1738_tu1actual/game/megalogamengine/megalogamengine_actions");
-const c_game_variant_2 = require("../blam/haloreach_mcc/v_untracked_25_08_19_1352/game/c_game_variant");
-const megalogamengine_actions_2 = require("../blam/haloreach_mcc/v_untracked_25_08_19_1352/game/megalogamengine/megalogamengine_actions");
-const megalogamengine_explicit_object_1 = require("../blam/haloreach_mcc/v_untracked_25_08_19_1352/game/megalogamengine/megalogamengine_explicit_object");
-const megalogamengine_explicit_player_1 = require("../blam/haloreach_mcc/v_untracked_25_08_19_1352/game/megalogamengine/megalogamengine_explicit_player");
-const megalogamengine_explicit_team_1 = require("../blam/haloreach_mcc/v_untracked_25_08_19_1352/game/megalogamengine/megalogamengine_explicit_team");
+const megalogamengine_explicit_object_1 = require("../blam/haloreach/v12065_11_08_24_1738_tu1actual/game/megalogamengine/megalogamengine_explicit_object");
+const megalogamengine_explicit_player_1 = require("../blam/haloreach/v12065_11_08_24_1738_tu1actual/game/megalogamengine/megalogamengine_explicit_player");
+const megalogamengine_explicit_team_1 = require("../blam/haloreach/v12065_11_08_24_1738_tu1actual/game/megalogamengine/megalogamengine_explicit_team");
+const megalogamengine_references_1 = require("../blam/haloreach/v12065_11_08_24_1738_tu1actual/game/megalogamengine/megalogamengine_references");
+const c_game_variant_2 = require("../blam/haloreach_mcc/v_untracked_25_08_16_1352/game/c_game_variant");
+const megalogamengine_actions_1 = require("../blam/haloreach_mcc/v_untracked_25_08_16_1352/game/megalogamengine/megalogamengine_actions");
+const megalogamengine_explicit_object_2 = require("../blam/haloreach_mcc/v_untracked_25_08_16_1352/game/megalogamengine/megalogamengine_explicit_object");
+const megalogamengine_explicit_player_2 = require("../blam/haloreach_mcc/v_untracked_25_08_16_1352/game/megalogamengine/megalogamengine_explicit_player");
+const megalogamengine_explicit_team_2 = require("../blam/haloreach_mcc/v_untracked_25_08_16_1352/game/megalogamengine/megalogamengine_explicit_team");
+const megalogamengine_references_2 = require("../blam/haloreach_mcc/v_untracked_25_08_16_1352/game/megalogamengine/megalogamengine_references");
 const error_1 = require("../error");
-/** MCC math ops with no TU1 equivalent (`<<=`, `>>=`). */
+const reach_gametype_automap_1 = require("./reach_gametype_automap");
+const reach_gametype_automapper_1 = require("./reach_gametype_automapper");
+const reach_gametype_conversion_error_1 = require("./reach_gametype_conversion_error");
+var reach_gametype_conversion_error_2 = require("./reach_gametype_conversion_error");
+Object.defineProperty(exports, "e_reach_gametype_conversion_error", { enumerable: true, get: function () { return reach_gametype_conversion_error_2.e_reach_gametype_conversion_error; } });
 const MCC_ONLY_MATH_OPS = [
-    megalogamengine_actions_2.e_math_operation.shift_left_with,
-    megalogamengine_actions_2.e_math_operation.shift_right_with,
+    megalogamengine_actions_1.e_math_operation.shift_left_with,
+    megalogamengine_actions_1.e_math_operation.shift_right_with,
+];
+const MCC_ONLY_ACTION_TYPES = [
+    megalogamengine_actions_1.e_action_type.begin,
+    megalogamengine_actions_1.e_action_type.hs_function_call,
+    megalogamengine_actions_1.e_action_type.get_button_time,
+    megalogamengine_actions_1.e_action_type.team_set_vehicle_spawning,
+    megalogamengine_actions_1.e_action_type.player_set_vehicle_spawning,
+    megalogamengine_actions_1.e_action_type.set_player_respawn_vehicle,
+    megalogamengine_actions_1.e_action_type.set_team_respawn_vehicle,
+    megalogamengine_actions_1.e_action_type.hide_object,
 ];
-/** TU1 survival `m_campaign_difficulty_level` when converting from MCC. */
 const TU1_SURVIVAL_CAMPAIGN_DIFFICULTY = 1;
-/** MCC survival `m_encoding_version` when converting from TU1. */
 const MCC_SURVIVAL_ENCODING_VERSION = 2;
-// ---------------------------------------------------------------------------
-// JSON helpers
-// ---------------------------------------------------------------------------
-function json_clone(value) {
-    return JSON.parse(JSON.stringify(value));
-}
-function write_game_variant_json(to, data) {
-    to.m_game_engine = data.m_game_engine;
-    to.m_campaign_variant = data.m_campaign_variant;
-    to.m_custom_variant = data.m_custom_variant;
-    to.m_survival_variant = data.m_survival_variant;
-}
-// ---------------------------------------------------------------------------
-// Tree walk
-// ---------------------------------------------------------------------------
+const HR_GVAR_PREFIX = "$hr_gvar_";
+const MAX_OBJECT_GLOBALS = 16;
+const MAX_PLAYER_GLOBALS = 8;
+const MAX_TEAM_GLOBALS = 8;
 function visit_object_tree(root, fn) {
     if (root === null || typeof root !== "object") {
         return;
@@ -61,133 +66,424 @@ function visit_object_tree(root, fn) {
         visit_object_tree(value, fn);
     }
 }
-function remap_set_to_absolute_mcc_to_tu1(root) {
+function remap_temporary_explicit_refs(root, maps) {
     visit_object_tree(root, (obj) => {
-        if (obj.m_operation === megalogamengine_actions_2.e_math_operation.set_to_absolute) {
-            obj.m_operation = megalogamengine_actions_1.e_math_operation.set_to_absolute;
+        const objectType = obj.m_explicit_object_type;
+        if (typeof objectType === "number" &&
+            objectType >= megalogamengine_explicit_object_2.e_explicit_object_type.temporary_0 &&
+            objectType <= megalogamengine_explicit_object_2.e_explicit_object_type.temporary_7) {
+            const temporaryIndex = objectType - megalogamengine_explicit_object_2.e_explicit_object_type.temporary_0;
+            const globalIndex = maps.object.get(temporaryIndex);
+            if (globalIndex !== undefined) {
+                obj.m_explicit_object_type =
+                    megalogamengine_explicit_object_1.e_explicit_object_type.global_0 + globalIndex;
+            }
+        }
+        const playerType = obj.m_explicit_player_type;
+        if (typeof playerType === "number" &&
+            playerType >= megalogamengine_explicit_player_2.e_explicit_player_type.temporary_0 &&
+            playerType <= megalogamengine_explicit_player_2.e_explicit_player_type.temporary_2) {
+            const temporaryIndex = playerType - megalogamengine_explicit_player_2.e_explicit_player_type.temporary_0;
+            const globalIndex = maps.player.get(temporaryIndex);
+            if (globalIndex !== undefined) {
+                obj.m_explicit_player_type =
+                    megalogamengine_explicit_player_1.e_explicit_player_type.global_0 + globalIndex;
+            }
         }
-        if (obj.m_math_operation === megalogamengine_actions_2.e_math_operation.set_to_absolute) {
-            obj.m_math_operation = megalogamengine_actions_1.e_math_operation.set_to_absolute;
+        const teamType = obj.m_explicit_team_type;
+        if (typeof teamType === "number" &&
+            teamType >= megalogamengine_explicit_team_2.e_explicit_team_type.temporary_0 &&
+            teamType <= megalogamengine_explicit_team_2.e_explicit_team_type.temporary_5) {
+            const temporaryIndex = teamType - megalogamengine_explicit_team_2.e_explicit_team_type.temporary_0;
+            const globalIndex = maps.team.get(temporaryIndex);
+            if (globalIndex !== undefined) {
+                obj.m_explicit_team_type =
+                    megalogamengine_explicit_team_1.e_explicit_team_type.global_0 + globalIndex;
+            }
         }
     });
 }
-function remap_set_to_absolute_tu1_to_mcc(root) {
-    visit_object_tree(root, (obj) => {
-        if (obj.m_operation === megalogamengine_actions_1.e_math_operation.set_to_absolute) {
-            obj.m_operation = megalogamengine_actions_2.e_math_operation.set_to_absolute;
+function extend_global_metadata(metadata, maps) {
+    const maxObjectGlobal = Math.max(0, ...maps.object.values());
+    while (metadata.m_object_variables.length <= maxObjectGlobal) {
+        metadata.m_object_variables.push(0);
+    }
+    const maxPlayerGlobal = Math.max(0, ...maps.player.values());
+    while (metadata.m_player_variables.length <= maxPlayerGlobal) {
+        metadata.m_player_variables.push(0);
+    }
+    const maxTeamGlobal = Math.max(0, ...maps.team.values());
+    while (metadata.m_team_variables.length <= maxTeamGlobal) {
+        metadata.m_team_variables.push([0, 0]);
+    }
+}
+function apply_survival_mcc_to_tu1(survival) {
+    if (survival === undefined) {
+        return;
+    }
+    survival.m_campaign_difficulty_level = TU1_SURVIVAL_CAMPAIGN_DIFFICULTY;
+    delete survival.m_encoding_version;
+    delete survival.m_additional_flags;
+}
+function apply_survival_tu1_to_mcc(survival) {
+    if (survival === undefined) {
+        return;
+    }
+    survival.m_encoding_version = MCC_SURVIVAL_ENCODING_VERSION;
+    survival.m_additional_flags = 0;
+    delete survival.m_campaign_difficulty_level;
+}
+function first_localized_string(table) {
+    const value = table?.strings[0]?.[0];
+    if (value === null || value === undefined || value.length === 0) {
+        return;
+    }
+    return value;
+}
+function resolve_hr_gvar_name(value, localized_name) {
+    if (value === undefined || !value.startsWith(HR_GVAR_PREFIX)) {
+        return value ?? "";
+    }
+    const localized = first_localized_string(localized_name);
+    if (localized !== undefined) {
+        return localized;
+    }
+    return value.slice(HR_GVAR_PREFIX.length).replaceAll("_", " ");
+}
+function resolve_hr_gvar_description(value, localized_description) {
+    if (value === undefined || !value.startsWith(HR_GVAR_PREFIX)) {
+        return value ?? "";
+    }
+    return first_localized_string(localized_description) ?? "";
+}
+function apply_mcc_to_tu1_name_description(from, to) {
+    const mccCustom = from.m_custom_variant;
+    const tu1Custom = to.m_custom_variant;
+    if (mccCustom === undefined || tu1Custom === undefined) {
+        return;
+    }
+    const metadata = tu1Custom.m_base_variant.m_metadata;
+    metadata.name = resolve_hr_gvar_name(mccCustom.m_base_variant.m_metadata.name, mccCustom.m_localized_name);
+    metadata.description = resolve_hr_gvar_description(mccCustom.m_base_variant.m_metadata.description, mccCustom.m_localized_description);
+}
+function object_global_index(value) {
+    if (value >= megalogamengine_explicit_object_1.e_explicit_object_type.global_0 &&
+        value <= megalogamengine_explicit_object_1.e_explicit_object_type.global_15) {
+        return value - megalogamengine_explicit_object_1.e_explicit_object_type.global_0;
+    }
+    return;
+}
+function object_temporary_index(value) {
+    if (value >= megalogamengine_explicit_object_2.e_explicit_object_type.temporary_0 &&
+        value <= megalogamengine_explicit_object_2.e_explicit_object_type.temporary_7) {
+        return value - megalogamengine_explicit_object_2.e_explicit_object_type.temporary_0;
+    }
+    return;
+}
+function player_global_index(value) {
+    if (value >= megalogamengine_explicit_player_1.e_explicit_player_type.global_0 &&
+        value <= megalogamengine_explicit_player_1.e_explicit_player_type.global_7) {
+        return value - megalogamengine_explicit_player_1.e_explicit_player_type.global_0;
+    }
+    return;
+}
+function player_temporary_index(value) {
+    if (value >= megalogamengine_explicit_player_2.e_explicit_player_type.temporary_0 &&
+        value <= megalogamengine_explicit_player_2.e_explicit_player_type.temporary_2) {
+        return value - megalogamengine_explicit_player_2.e_explicit_player_type.temporary_0;
+    }
+    return;
+}
+function team_global_index(value) {
+    if (value >= megalogamengine_explicit_team_1.e_explicit_team_type.global_0 &&
+        value <= megalogamengine_explicit_team_1.e_explicit_team_type.global_7) {
+        return value - megalogamengine_explicit_team_1.e_explicit_team_type.global_0;
+    }
+    return;
+}
+function team_temporary_index(value) {
+    if (value >= megalogamengine_explicit_team_2.e_explicit_team_type.temporary_0 &&
+        value <= megalogamengine_explicit_team_2.e_explicit_team_type.temporary_5) {
+        return value - megalogamengine_explicit_team_2.e_explicit_team_type.temporary_0;
+    }
+    return;
+}
+function reserve_metadata_slots(usage, metadata) {
+    for (let i = 0; i < metadata.m_object_variables.length; i++) {
+        usage.object.add(i);
+    }
+    for (let i = 0; i < metadata.m_player_variables.length; i++) {
+        usage.player.add(i);
+    }
+    for (let i = 0; i < metadata.m_team_variables.length; i++) {
+        usage.team.add(i);
+    }
+    for (let i = 0; i < metadata.m_numeric_variables.length; i++) {
+        usage.numeric.add(i);
+    }
+}
+function collect_slot_usage_from_object(obj, globals, temporaries) {
+    const objectType = obj.m_explicit_object_type;
+    if (typeof objectType === "number") {
+        const globalIndex = object_global_index(objectType);
+        if (globalIndex !== undefined) {
+            globals.object.add(globalIndex);
         }
-        if (obj.m_math_operation === megalogamengine_actions_1.e_math_operation.set_to_absolute) {
-            obj.m_math_operation = megalogamengine_actions_2.e_math_operation.set_to_absolute;
+        const temporaryIndex = object_temporary_index(objectType);
+        if (temporaryIndex !== undefined) {
+            temporaries.object.add(temporaryIndex);
         }
-    });
+    }
+    const playerType = obj.m_explicit_player_type;
+    if (typeof playerType === "number") {
+        const globalIndex = player_global_index(playerType);
+        if (globalIndex !== undefined) {
+            globals.player.add(globalIndex);
+        }
+        const temporaryIndex = player_temporary_index(playerType);
+        if (temporaryIndex !== undefined) {
+            temporaries.player.add(temporaryIndex);
+        }
+    }
+    const teamType = obj.m_explicit_team_type;
+    if (typeof teamType === "number") {
+        const globalIndex = team_global_index(teamType);
+        if (globalIndex !== undefined) {
+            globals.team.add(globalIndex);
+        }
+        const temporaryIndex = team_temporary_index(teamType);
+        if (temporaryIndex !== undefined) {
+            temporaries.team.add(temporaryIndex);
+        }
+    }
+    if (obj.m_type === 4 && typeof obj.m_variable_index === "number") {
+        globals.numeric.add(obj.m_variable_index);
+    }
 }
-// ---------------------------------------------------------------------------
-// MCC → TU1 compatibility checks
-// ---------------------------------------------------------------------------
-function variant_uses_temporary_explicit_refs(variant) {
-    let found = false;
-    visit_object_tree(variant, (obj) => {
-        if (found) {
+function collect_slot_usage(root) {
+    const globals = {
+        object: new Set(),
+        player: new Set(),
+        team: new Set(),
+        numeric: new Set(),
+    };
+    const temporaries = {
+        object: new Set(),
+        player: new Set(),
+        team: new Set(),
+    };
+    visit_object_tree(root, (obj) => collect_slot_usage_from_object(obj, globals, temporaries));
+    return { globals, temporaries };
+}
+function allocate_global_slot(used, max) {
+    for (let index = 0; index < max; index++) {
+        if (!used.has(index)) {
+            used.add(index);
+            return index;
+        }
+    }
+    return;
+}
+function build_temporary_to_global_maps(globals, temporaries) {
+    const maps = {
+        object: new Map(),
+        player: new Map(),
+        team: new Map(),
+    };
+    for (const temporaryIndex of [...temporaries.object].sort((a, b) => a - b)) {
+        const globalIndex = allocate_global_slot(globals.object, MAX_OBJECT_GLOBALS);
+        if (globalIndex === undefined) {
             return;
         }
-        const team = obj.m_explicit_team_type;
-        if (typeof team === "number" &&
-            team >= megalogamengine_explicit_team_1.e_explicit_team_type.temporary_0 &&
-            team <= megalogamengine_explicit_team_1.e_explicit_team_type.temporary_5) {
-            found = true;
+        maps.object.set(temporaryIndex, globalIndex);
+    }
+    for (const temporaryIndex of [...temporaries.player].sort((a, b) => a - b)) {
+        const globalIndex = allocate_global_slot(globals.player, MAX_PLAYER_GLOBALS);
+        if (globalIndex === undefined) {
             return;
         }
-        const player = obj.m_explicit_player_type;
-        if (typeof player === "number" &&
-            player >= megalogamengine_explicit_player_1.e_explicit_player_type.temporary_0 &&
-            player <= megalogamengine_explicit_player_1.e_explicit_player_type.temporary_2) {
-            found = true;
+        maps.player.set(temporaryIndex, globalIndex);
+    }
+    for (const temporaryIndex of [...temporaries.team].sort((a, b) => a - b)) {
+        const globalIndex = allocate_global_slot(globals.team, MAX_TEAM_GLOBALS);
+        if (globalIndex === undefined) {
             return;
         }
-        const object = obj.m_explicit_object_type;
-        if (typeof object === "number" &&
-            object >= megalogamengine_explicit_object_1.e_explicit_object_type.temporary_0 &&
-            object <= megalogamengine_explicit_object_1.e_explicit_object_type.temporary_7) {
+        maps.team.set(temporaryIndex, globalIndex);
+    }
+    return maps;
+}
+function get_custom_engine_tu1(variant) {
+    return variant.m_custom_variant?.m_game_engine;
+}
+function copy_variable_metadata_mcc_to_tu1(from, to) {
+    to.m_numeric_variables = from.m_numeric_variables.map(([ref, state]) => [
+        reach_gametype_automap_1.mccToTu1Mapper.map(ref, megalogamengine_references_2.c_custom_variable_reference, megalogamengine_references_1.c_custom_variable_reference),
+        state,
+    ]);
+    to.m_timer_variables = from.m_timer_variables.map((ref) => reach_gametype_automap_1.mccToTu1Mapper.map(ref, megalogamengine_references_2.c_custom_variable_reference, megalogamengine_references_1.c_custom_variable_reference));
+    to.m_team_variables = from.m_team_variables.map(([value, state]) => [
+        value,
+        state,
+    ]);
+    to.m_player_variables = [...from.m_player_variables];
+    to.m_object_variables = [...from.m_object_variables];
+}
+function copy_variable_metadata_tu1_to_mcc(from, to) {
+    to.m_numeric_variables = from.m_numeric_variables.map(([ref, state]) => [
+        reach_gametype_automap_1.tu1ToMccMapper.map(ref, megalogamengine_references_1.c_custom_variable_reference, megalogamengine_references_2.c_custom_variable_reference),
+        state,
+    ]);
+    to.m_timer_variables = from.m_timer_variables.map((ref) => reach_gametype_automap_1.tu1ToMccMapper.map(ref, megalogamengine_references_1.c_custom_variable_reference, megalogamengine_references_2.c_custom_variable_reference));
+    to.m_team_variables = from.m_team_variables.map(([value, state]) => [
+        value,
+        state,
+    ]);
+    to.m_player_variables = [...from.m_player_variables];
+    to.m_object_variables = [...from.m_object_variables];
+}
+function copy_engine_variable_metadata_mcc_to_tu1(from, to) {
+    copy_variable_metadata_mcc_to_tu1(from.m_global_variable_metadata, to.m_global_variable_metadata);
+    copy_variable_metadata_mcc_to_tu1(from.m_player_variable_metadata, to.m_player_variable_metadata);
+    copy_variable_metadata_mcc_to_tu1(from.m_object_variable_metadata, to.m_object_variable_metadata);
+    copy_variable_metadata_mcc_to_tu1(from.m_team_variable_metadata, to.m_team_variable_metadata);
+}
+function copy_engine_variable_metadata_tu1_to_mcc(from, to) {
+    copy_variable_metadata_tu1_to_mcc(from.m_global_variable_metadata, to.m_global_variable_metadata);
+    copy_variable_metadata_tu1_to_mcc(from.m_player_variable_metadata, to.m_player_variable_metadata);
+    copy_variable_metadata_tu1_to_mcc(from.m_object_variable_metadata, to.m_object_variable_metadata);
+    copy_variable_metadata_tu1_to_mcc(from.m_team_variable_metadata, to.m_team_variable_metadata);
+}
+function get_custom_engine(variant) {
+    return variant.m_custom_variant?.m_game_engine;
+}
+function apply_mcc_to_tu1_megalo_remapping(variant, maps) {
+    const engine = variant.m_custom_variant?.m_game_engine;
+    if (!engine) {
+        return;
+    }
+    remap_temporary_explicit_refs(engine, maps);
+    extend_global_metadata(engine.m_global_variable_metadata, maps);
+}
+function variant_uses_mcc_only_math_ops(variant) {
+    let found = false;
+    visit_object_tree(variant, (obj) => {
+        if (found) {
+            return;
+        }
+        const op = obj.m_operation ?? obj.m_math_operation;
+        if (typeof op === "number" && MCC_ONLY_MATH_OPS.includes(op)) {
             found = true;
         }
     });
     return found;
 }
-function variant_uses_mcc_only_math_ops(variant) {
+function variant_uses_mcc_only_action_types(variant) {
     let found = false;
     visit_object_tree(variant, (obj) => {
         if (found) {
             return;
         }
-        const op = obj.m_operation ?? obj.m_math_operation;
-        if (typeof op === "number" && MCC_ONLY_MATH_OPS.includes(op)) {
+        const actionType = obj.m_type;
+        if (typeof actionType === "number" &&
+            MCC_ONLY_ACTION_TYPES.includes(actionType)) {
             found = true;
         }
     });
     return found;
 }
-/** Returns false when MCC features cannot be represented in TU1. */
-function can_convert_mcc_game_variant_to_tu1(from) {
+function plan_temporary_relocation(variant) {
+    const engine = get_custom_engine(variant);
+    if (!engine) {
+        return { object: new Map(), player: new Map(), team: new Map() };
+    }
+    const { globals, temporaries } = collect_slot_usage(engine);
+    reserve_metadata_slots(globals, engine.m_global_variable_metadata);
+    if (temporaries.object.size === 0 &&
+        temporaries.player.size === 0 &&
+        temporaries.team.size === 0) {
+        return { object: new Map(), player: new Map(), team: new Map() };
+    }
+    return build_temporary_to_global_maps(globals, temporaries);
+}
+function check_mcc_game_variant_to_tu1(from) {
+    if (from.m_game_engine === c_game_variant_2.e_game_mode.sandbox) {
+        return reach_gametype_conversion_error_1.e_reach_gametype_conversion_error.forge_variant;
+    }
+    if (from.m_game_engine === c_game_variant_2.e_game_mode.campaign) {
+        return reach_gametype_conversion_error_1.e_reach_gametype_conversion_error.campaign_variant;
+    }
     if (from.m_game_engine === c_game_variant_2.e_game_mode.survival &&
         from.m_survival_variant !== undefined &&
         from.m_survival_variant.m_additional_flags !== 0) {
-        return false;
+        return reach_gametype_conversion_error_1.e_reach_gametype_conversion_error.mcc_survival_additional_flags;
     }
-    if (variant_uses_temporary_explicit_refs(from)) {
-        return false;
+    if (variant_uses_mcc_only_action_types(from)) {
+        return reach_gametype_conversion_error_1.e_reach_gametype_conversion_error.mcc_exclusive_action;
     }
     if (variant_uses_mcc_only_math_ops(from)) {
-        return false;
+        return reach_gametype_conversion_error_1.e_reach_gametype_conversion_error.mcc_exclusive_math_operator;
     }
-    return true;
-}
-// ---------------------------------------------------------------------------
-// Survival (MCC and TU1 use different field names for unrelated data)
-// ---------------------------------------------------------------------------
-function survival_json_mcc_to_tu1(survival) {
-    survival.m_campaign_difficulty_level = TU1_SURVIVAL_CAMPAIGN_DIFFICULTY;
-    survival.m_encoding_version = undefined;
-    survival.m_additional_flags = undefined;
+    if (plan_temporary_relocation(from) === undefined) {
+        return reach_gametype_conversion_error_1.e_reach_gametype_conversion_error.insufficient_global_slots;
+    }
+    return reach_gametype_conversion_error_1.e_reach_gametype_conversion_error.ok;
 }
-function survival_json_tu1_to_mcc(survival) {
-    survival.m_encoding_version = MCC_SURVIVAL_ENCODING_VERSION;
-    survival.m_campaign_difficulty_level = undefined;
-    survival.m_additional_flags = 0;
+function check_tu1_game_variant_to_mcc(from) {
+    if (from.m_game_engine === c_game_variant_1.e_game_mode.sandbox) {
+        return reach_gametype_conversion_error_1.e_reach_gametype_conversion_error.forge_variant;
+    }
+    if (from.m_game_engine === c_game_variant_1.e_game_mode.campaign) {
+        return reach_gametype_conversion_error_1.e_reach_gametype_conversion_error.campaign_variant;
+    }
+    return reach_gametype_conversion_error_1.e_reach_gametype_conversion_error.ok;
 }
-// ---------------------------------------------------------------------------
-// Conversion (cross-version only)
-// ---------------------------------------------------------------------------
 function convert_mcc_to_tu1(from, to) {
-    if (!can_convert_mcc_game_variant_to_tu1(from)) {
-        return false;
+    const error = check_mcc_game_variant_to_tu1(from);
+    if (error !== reach_gametype_conversion_error_1.e_reach_gametype_conversion_error.ok) {
+        return error;
+    }
+    const maps = plan_temporary_relocation(from);
+    if (maps === undefined) {
+        return reach_gametype_conversion_error_1.e_reach_gametype_conversion_error.insufficient_global_slots;
     }
-    const data = json_clone(from);
-    remap_set_to_absolute_mcc_to_tu1(data);
-    if (data.m_survival_variant !== undefined) {
-        survival_json_mcc_to_tu1(data.m_survival_variant);
+    const converted = (0, reach_gametype_automapper_1.map_reach_gametype_mcc_to_tu1)(from);
+    const sourceEngine = get_custom_engine(from);
+    const targetEngine = converted.m_custom_variant?.m_game_engine;
+    if (sourceEngine !== undefined && targetEngine !== undefined) {
+        copy_engine_variable_metadata_mcc_to_tu1(sourceEngine, targetEngine);
     }
-    write_game_variant_json(to, data);
-    return true;
+    apply_mcc_to_tu1_megalo_remapping(converted, maps);
+    apply_mcc_to_tu1_name_description(from, converted);
+    apply_survival_mcc_to_tu1(converted.m_survival_variant);
+    Object.assign(to, converted);
+    return reach_gametype_conversion_error_1.e_reach_gametype_conversion_error.ok;
 }
 function convert_tu1_to_mcc(from, to) {
-    const data = json_clone(from);
-    remap_set_to_absolute_tu1_to_mcc(data);
-    if (data.m_survival_variant !== undefined) {
-        survival_json_tu1_to_mcc(data.m_survival_variant);
+    const error = check_tu1_game_variant_to_mcc(from);
+    if (error !== reach_gametype_conversion_error_1.e_reach_gametype_conversion_error.ok) {
+        return error;
     }
-    write_game_variant_json(to, data);
-    return true;
-}
-function convert_reach_gametype(from, to) {
-    if (from.m_game_engine === c_game_variant_1.e_game_mode.sandbox) {
-        throw new error_1.BlfError("Forge game variants are not supported. Where did you even get this?");
+    const converted = (0, reach_gametype_automapper_1.map_reach_gametype_tu1_to_mcc)(from);
+    const sourceEngine = get_custom_engine_tu1(from);
+    const targetEngine = converted.m_custom_variant?.m_game_engine;
+    if (sourceEngine !== undefined && targetEngine !== undefined) {
+        copy_engine_variable_metadata_tu1_to_mcc(sourceEngine, targetEngine);
     }
+    apply_survival_tu1_to_mcc(converted.m_survival_variant);
+    Object.assign(to, converted);
+    return reach_gametype_conversion_error_1.e_reach_gametype_conversion_error.ok;
+}
+function assert_cross_version(from, to) {
     const from_is_mcc = from instanceof c_game_variant_2.c_game_variant;
     const to_is_mcc = to instanceof c_game_variant_2.c_game_variant;
     if (from_is_mcc === to_is_mcc) {
         throw new error_1.BlfError("convert_reach_gametype only supports cross-version conversion between Reach TU1 and Reach MCC");
     }
-    if (from_is_mcc) {
+}
+function convert_reach_gametype(from, to) {
+    assert_cross_version(from, to);
+    if (from instanceof c_game_variant_2.c_game_variant) {
         return convert_mcc_to_tu1(from, to);
     }
     return convert_tu1_to_mcc(from, to);