fix: decouple proc sword results from display names

Assisted-by: openai/gpt-5.4 on opencode
Co-authored-by: chatgpt-codex-connector[bot] <199175422+chatgpt-codex-connector[bot]@users.noreply.github.com>

Author: scarf005

data/json/procgen.lua

@@ -30,8 +30,8 @@ end
 
 function procgen.gear.make(params)
   local blob = params.blob or {}
-  local result = params.schema_res or "proc_sword_generic"
-  if params.schema_id == "sword" then result = sword_result_from_name(blob.name) end
+  local result = params.result_override or params.schema_res or "proc_sword_generic"
+  if params.schema_id == "sword" and not params.result_override then result = sword_result_from_name(blob.name) end
   return {
     result = result,
     name = blob.name,

src/proc_builder.cpp

@@ -441,6 +441,43 @@ auto picked_facts_for_role( const proc::schema &sch, const std::vector<proc::par
     return ret;
 }
 
+struct sword_variant_data {
+    std::string name;
+    itype_id result = itype_id::NULL_ID();
+};
+
+auto sword_variant( const proc::schema &sch, const std::vector<proc::part_fact> &facts,
+                    const std::vector<proc::craft_pick> &picks ) -> sword_variant_data
+{
+    const auto blade_facts = picked_facts_for_role( sch, facts, picks, "blade" );
+    const auto reinforcement_facts = picked_facts_for_role( sch, facts, picks, "reinforcement" );
+
+    if( has_itype( reinforcement_facts, itype_id( "nail" ) ) ) {
+        return { .name = "nail sword", .result = itype_id( "sword_nail" ) };
+    }
+    if( has_itype( reinforcement_facts, itype_id( "scrap" ) ) ||
+        has_itype( blade_facts, itype_id( "scrap" ) ) ) {
+        return { .name = "crude sword", .result = itype_id( "sword_crude" ) };
+    }
+    if( std::ranges::any_of( blade_facts, [&]( const proc::part_fact & fact ) {
+    return has_material( fact, material_id( "steel" ) ) || has_material( fact,
+                material_id( "iron" ) );
+    } ) ) {
+        return { .name = "hand-forged sword", .result = itype_id( "sword_metal" ) };
+    }
+    if( std::ranges::any_of( blade_facts, [&]( const proc::part_fact & fact ) {
+    return has_material( fact, material_id( "bone" ) );
+    } ) ) {
+        return { .name = "bone sword", .result = itype_id( "sword_bone" ) };
+    }
+    if( std::ranges::any_of( blade_facts, [&]( const proc::part_fact & fact ) {
+    return has_material( fact, material_id( "wood" ) );
+    } ) ) {
+        return { .name = "2-by-sword", .result = itype_id( "sword_wood" ) };
+    }
+    return { .name = "sword", .result = itype_id( "proc_sword_generic" ) };
+}
+
 auto sandwich_condiment_name( const std::vector<proc::part_fact> &facts ) -> std::string
 {
     if( !facts_have_tag( facts, "cond" ) ) {
@@ -520,32 +557,7 @@ auto sandwich_vegetable_name( const std::vector<proc::part_fact> &facts ) -> std
 auto sword_name( const proc::schema &sch, const std::vector<proc::part_fact> &facts,
                  const std::vector<proc::craft_pick> &picks ) -> std::string
 {
-    const auto blade_facts = picked_facts_for_role( sch, facts, picks, "blade" );
-    const auto reinforcement_facts = picked_facts_for_role( sch, facts, picks, "reinforcement" );
-
-    if( has_itype( reinforcement_facts, itype_id( "nail" ) ) ) {
-        return "nail sword";
-    }
-    if( has_itype( reinforcement_facts, itype_id( "scrap" ) ) ||
-        has_itype( blade_facts, itype_id( "scrap" ) ) ) {
-        return "crude sword";
-    }
-    if( std::ranges::any_of( blade_facts, [&]( const proc::part_fact & fact ) {
-    return has_material( fact, material_id( "steel" ) ) || has_material( fact, material_id( "iron" ) );
-    } ) ) {
-        return "hand-forged sword";
-    }
-    if( std::ranges::any_of( blade_facts, [&]( const proc::part_fact & fact ) {
-    return has_material( fact, material_id( "bone" ) );
-    } ) ) {
-        return "bone sword";
-    }
-    if( std::ranges::any_of( blade_facts, [&]( const proc::part_fact & fact ) {
-    return has_material( fact, material_id( "wood" ) );
-    } ) ) {
-        return "2-by-sword";
-    }
-    return "sword";
+    return sword_variant( sch, facts, picks ).name;
 }
 
 auto sword_description( const proc::schema &sch, const std::vector<proc::part_fact> &facts,
@@ -915,6 +927,15 @@ auto proc::rebuild_fast( const builder_state &state ) -> fast_blob
     return preview_blob( state.sch, facts, selected_picks( state, state.sch ) );
 }
 
+auto proc::preview_result_override( const schema &sch, const std::vector<part_fact> &facts,
+                                    const std::vector<craft_pick> &picks ) -> std::optional<itype_id>
+{
+    if( sch.id != schema_id( "sword" ) ) {
+        return std::nullopt;
+    }
+    return sword_variant( sch, facts, picks ).result;
+}
+
 auto proc::debug_part_fact( const schema &sch, const item &it,
                             const part_ix ix ) -> std::optional<part_fact>
 {

src/proc_builder.h

@@ -48,6 +48,8 @@ auto remove_last_pick( builder_state &state, const slot_id &slot ) -> bool;
 auto selected_picks( const builder_state &state, const schema &sch ) -> std::vector<craft_pick>;
 auto selected_facts( const builder_state &state ) -> std::vector<part_fact>;
 auto rebuild_fast( const builder_state &state ) -> fast_blob;
+auto preview_result_override( const schema &sch, const std::vector<part_fact> &facts,
+                              const std::vector<craft_pick> &picks ) -> std::optional<itype_id>;
 auto debug_part_fact( const schema &sch, const item &it,
                       part_ix ix ) -> std::optional<part_fact>;
 auto fast_fp( const schema &sch, const fast_blob &blob,

src/proc_item.cpp

@@ -478,7 +478,8 @@ auto blob_table( sol::state &lua, const proc::fast_blob &blob ) -> sol::table
 
 auto call_lua_blob( const std::string &path, const proc::schema &sch,
                     const std::vector<proc::part_fact> &facts, const proc::fast_blob &blob,
-                    cata::lua_state *state ) -> std::optional<sol::table>
+                    cata::lua_state *state,
+                    const std::optional<itype_id> &result_override = std::nullopt ) -> std::optional<sol::table>
 {
     auto *active = active_lua_state( state );
     if( active == nullptr ) {
@@ -493,6 +494,9 @@ auto call_lua_blob( const std::string &path, const proc::schema &sch,
     auto params = lua.create_table();
     params["schema_id"] = sch.id.str();
     params["schema_res"] = sch.res.str();
+    if( result_override.has_value() ) {
+        params["result_override"] = result_override->str();
+    }
     params["blob"] = blob_table( lua, blob );
 
     auto facts_tbl = lua.create_table();
@@ -1058,12 +1062,15 @@ auto proc::make_item( const schema &sch, const std::vector<part_fact> &facts,
                       const make_opts &opts ) -> detached_ptr<item>
 {
     auto preview = fast_blob{};
+    auto result_override = std::optional<itype_id> {};
     if( !opts.slots.empty() ) {
         auto state = build_state( sch, facts );
         const auto count = std::min( facts.size(), opts.slots.size() );
         std::ranges::for_each( std::views::iota( size_t{ 0 }, count ), [&]( const size_t idx ) {
             state.chosen[opts.slots[idx]].push_back( facts[idx].ix );
         } );
+        const auto picks = selected_picks( state, sch );
+        result_override = proc::preview_result_override( sch, facts, picks );
         preview = rebuild_fast( state );
     } else {
         std::ranges::for_each( facts, [&]( const part_fact & fact ) {
@@ -1079,7 +1086,8 @@ auto proc::make_item( const schema &sch, const std::vector<part_fact> &facts,
     auto mode = opts.mode;
     auto result = item::spawn( sch.res, calendar::turn );
 
-    if( const auto tbl = call_lua_blob( sch.lua.make, sch, facts, full.data, opts.state ) ) {
+    if( const auto tbl = call_lua_blob( sch.lua.make, sch, facts, full.data, opts.state,
+                                        result_override ) ) {
         parse_blob_into( full.data, *tbl );
         const auto result_id = tbl->get_or<std::string>( "result", "" );
         if( !result_id.empty() ) {

tests/proc_weapon_make_test.cpp

@@ -147,4 +147,23 @@ TEST_CASE( "proc_make_item_converts_proc_swords_to_legacy_variants", "[proc][mak
         CHECK( made->typeId() == itype_id( "sword_bone" ) );
         CHECK( made->type_name() == "bone sword" );
     }
+
+    SECTION( "result variant does not depend on localized sword names" ) {
+        state.lua.script( R"(
+            procgen.test = procgen.test or {}
+            function procgen.test.rename(params)
+              local blob = params.blob or {}
+              blob.name = "mystery sword"
+              return blob
+            end
+        )" );
+
+        auto renamed = sch;
+        renamed.lua.full = "procgen.test.rename";
+
+        opts.slots = { proc::slot_id( "blade" ), proc::slot_id( "handle" ), proc::slot_id( "grip" ) };
+        const auto made = proc::make_item( renamed, { steel_blade, handle, grip }, opts );
+        CHECK( made->typeId() == itype_id( "sword_metal" ) );
+        CHECK( made->type_name() == "mystery sword" );
+    }
 }