feat: add procedural sword descriptions

/home/scarf/.local/bin/assisted-by "openai/gpt-5.4" "opencode"

Author: scarf005

src/proc_builder.cpp

@@ -293,6 +293,127 @@ auto facts_have_tag( const std::vector<proc::part_fact> &facts, const std::strin
     } );
 }
 
+auto join_sentences( const std::vector<std::string> &sentences ) -> std::string
+{
+    auto ret = std::string {};
+    std::ranges::for_each( sentences, [&]( const std::string & sentence ) {
+        if( sentence.empty() ) {
+            return;
+        }
+        if( !ret.empty() ) {
+            ret += ' ';
+        }
+        ret += sentence;
+    } );
+    return ret;
+}
+
+auto primary_material_name( const std::vector<proc::part_fact> &facts ) -> std::string
+{
+    if( std::ranges::any_of( facts, [&]( const proc::part_fact & fact ) {
+    return has_material( fact, material_id( "steel" ) ) || has_material( fact, material_id( "iron" ) );
+    } ) ) {
+        return "metal";
+    }
+    if( std::ranges::any_of( facts, [&]( const proc::part_fact & fact ) {
+    return has_material( fact, material_id( "bone" ) );
+    } ) ) {
+        return "bone";
+    }
+    if( std::ranges::any_of( facts, [&]( const proc::part_fact & fact ) {
+    return has_material( fact, material_id( "wood" ) );
+    } ) ) {
+        return "wooden";
+    }
+    return "simple";
+}
+
+auto sword_base_description( const std::string &name ) -> std::string
+{
+    if( name == "nail sword" ) {
+        return "A rough wooden sword stiffened with driven nails.";
+    }
+    if( name == "crude sword" ) {
+        return "A crude sword pieced together from wood and scavenged scrap.";
+    }
+    if( name == "hand-forged sword" ) {
+        return "A serviceable sword built around a forged metal blade.";
+    }
+    if( name == "bone sword" ) {
+        return "A rough sword built around a sharpened bone blade.";
+    }
+    if( name == "2-by-sword" ) {
+        return "A club-like sword carved from a sturdy length of wood.";
+    }
+    return "A makeshift sword assembled from scavenged parts.";
+}
+
+auto sword_guard_phrase( const std::vector<proc::part_fact> &guard_facts ) -> std::string
+{
+    if( guard_facts.empty() ) {
+        return "no guard";
+    }
+    const auto material = primary_material_name( guard_facts );
+    if( material == "metal" ) {
+        return "a metal guard";
+    }
+    if( material == "bone" ) {
+        return "a bone guard";
+    }
+    if( material == "wooden" ) {
+        return "a wooden guard";
+    }
+    return "a simple guard";
+}
+
+auto sword_grip_phrase( const std::vector<proc::part_fact> &grip_facts ) -> std::string
+{
+    if( grip_facts.empty() ) {
+        return {};
+    }
+    if( has_itype( grip_facts, itype_id( "leather" ) ) || std::ranges::any_of( grip_facts,
+    [&]( const proc::part_fact & fact ) {
+    return has_material( fact, material_id( "leather" ) );
+    } ) ) {
+        return "a leather-wrapped grip";
+    }
+    if( has_itype( grip_facts, itype_id( "rag" ) ) || std::ranges::any_of( grip_facts,
+    [&]( const proc::part_fact & fact ) {
+    return has_material( fact, material_id( "cotton" ) );
+    } ) ) {
+        return "a rag-wrapped grip";
+    }
+    return "a wrapped grip";
+}
+
+auto sword_hilt_sentence( const std::vector<proc::part_fact> &guard_facts,
+                          const std::vector<proc::part_fact> &grip_facts ) -> std::string
+{
+    const auto guard_phrase = sword_guard_phrase( guard_facts );
+    const auto grip_phrase = sword_grip_phrase( grip_facts );
+    if( grip_phrase.empty() ) {
+        return string_format( "The hilt uses %s.", guard_phrase );
+    }
+    return string_format( "The hilt uses %s and %s.", guard_phrase, grip_phrase );
+}
+
+auto sword_reinforcement_sentence( const std::vector<proc::part_fact> &reinforcement_facts ) ->
+std::string
+{
+    const auto has_nails = has_itype( reinforcement_facts, itype_id( "nail" ) );
+    const auto has_scrap = has_itype( reinforcement_facts, itype_id( "scrap" ) );
+    if( has_nails && has_scrap ) {
+        return "Driven nails and scrap reinforcement add stiffness at the cost of weight.";
+    }
+    if( has_nails ) {
+        return "Driven nails add stiffness and a little puncturing power.";
+    }
+    if( has_scrap ) {
+        return "Scrap reinforcement adds weight and stiffness.";
+    }
+    return {};
+}
+
 auto matching_slot_uses( const proc::schema &sch, const proc::part_fact &fact ) -> int
 {
     auto uses = 0;
@@ -427,6 +548,20 @@ auto sword_name( const proc::schema &sch, const std::vector<proc::part_fact> &fa
     return "sword";
 }
 
+auto sword_description( const proc::schema &sch, const std::vector<proc::part_fact> &facts,
+                        const std::vector<proc::craft_pick> &picks,
+                        const std::string &name ) -> std::string
+{
+    const auto guard_facts = picked_facts_for_role( sch, facts, picks, "guard" );
+    const auto grip_facts = picked_facts_for_role( sch, facts, picks, "grip" );
+    const auto reinforcement_facts = picked_facts_for_role( sch, facts, picks, "reinforcement" );
+    return join_sentences( {
+        sword_base_description( name ),
+        sword_hilt_sentence( guard_facts, grip_facts ),
+        sword_reinforcement_sentence( reinforcement_facts ),
+    } );
+}
+
 auto sandwich_name( const proc::schema &sch, const std::vector<proc::part_fact> &facts,
                     const std::vector<proc::craft_pick> &picks ) -> std::string
 {
@@ -577,6 +712,7 @@ auto sword_preview( const proc::schema &sch, const std::vector<proc::part_fact>
     blob.melee.to_hit = std::clamp( ( edge_score + bash_score ) / 18 - blob.mass_g / 900, -2, 4 );
     blob.melee.dur = std::max( 1, dur_score + blob.mass_g / 250 );
     blob.name = sword_name( sch, facts, picks );
+    blob.description = sword_description( sch, facts, picks, blob.name );
     return blob;
 }
 

src/proc_item.cpp

@@ -135,6 +135,7 @@ auto default_food_blob( const item &it,
                                        static_cast<double>( current_charges ) /
                                        static_cast<double>( sample_charges ) ) );
     blob.name = sample->type_name();
+    blob.description = sample->type->description.translated();
     if( !sample->is_comestible() ) {
         return blob;
     }
@@ -168,6 +169,7 @@ auto default_weapon_blob( const itype_id &source_id ) -> proc::fast_blob
     blob.mass_g = units::to_gram( source.weight() );
     blob.volume_ml = units::to_milliliter( source.volume() );
     blob.name = source.type_name();
+    blob.description = source.type->description.translated();
     blob.melee.bash = source.damage_melee( DT_BASH );
     blob.melee.cut = source.damage_melee( DT_CUT );
     blob.melee.stab = source.damage_melee( DT_STAB );
@@ -456,6 +458,7 @@ auto blob_table( sol::state &lua, const proc::fast_blob &blob ) -> sol::table
     tbl["volume_ml"] = blob.volume_ml;
     tbl["kcal"] = blob.kcal;
     tbl["name"] = blob.name;
+    tbl["description"] = blob.description;
 
     auto vit_tbl = lua.create_table();
     std::ranges::for_each( blob.vit, [&]( const std::pair<const vitamin_id, int> &entry ) {
@@ -517,6 +520,7 @@ auto parse_blob_into( proc::fast_blob &blob, const sol::table &tbl ) -> void
     blob.volume_ml = tbl.get_or( "volume_ml", blob.volume_ml );
     blob.kcal = tbl.get_or( "kcal", blob.kcal );
     blob.name = tbl.get_or<std::string>( "name", blob.name );
+    blob.description = tbl.get_or<std::string>( "description", blob.description );
     const auto vit_obj = tbl.get_or<sol::object>( "vit", sol::lua_nil );
     if( vit_obj != sol::lua_nil && vit_obj.is<sol::table>() ) {
         blob.vit.clear();
@@ -696,6 +700,9 @@ auto proc::to_json( JsonOut &jsout, const payload &data ) -> void
     jsout.member( "volume_ml", data.blob.volume_ml );
     jsout.member( "kcal", data.blob.kcal );
     jsout.member( "name", data.blob.name );
+    if( !data.blob.description.empty() ) {
+        jsout.member( "description", data.blob.description );
+    }
     jsout.member( "melee" );
     jsout.start_object();
     jsout.member( "bash", data.blob.melee.bash );
@@ -734,6 +741,7 @@ auto proc::from_json( JsonIn &jsin, payload &data ) -> void
         blob_jo.read( "volume_ml", data.blob.volume_ml );
         blob_jo.read( "kcal", data.blob.kcal );
         blob_jo.read( "name", data.blob.name );
+        blob_jo.read( "description", data.blob.description );
         if( blob_jo.has_object( "melee" ) ) {
             const auto melee_jo = blob_jo.get_object( "melee" );
             melee_jo.read( "bash", data.blob.melee.bash );
@@ -863,6 +871,9 @@ auto proc::write_payload( item &it, const payload &data ) -> void
     if( !data.blob.name.empty() ) {
         it.set_var( "name", data.blob.name );
     }
+    if( !data.blob.description.empty() ) {
+        it.set_var( "description", data.blob.description );
+    }
     if( it.is_comestible() && !data.blob.empty() ) {
         it.set_flag( flag_NUTRIENT_OVERRIDE );
     }

src/proc_types.h

@@ -96,10 +96,11 @@ struct fast_blob {
     std::map<vitamin_id, int> vit;
     melee_blob melee;
     std::string name;
+    std::string description;
 
     auto empty() const -> bool {
         return mass_g == 0 && volume_ml == 0 && kcal == 0 && vit.empty() && melee.empty() &&
-               name.empty();
+               name.empty() && description.empty();
     }
 
     auto operator==( const fast_blob & ) const -> bool = default;

tests/proc_builder_test.cpp

@@ -825,17 +825,28 @@ TEST_CASE( "proc_builder_supports_sword_reinforcements_and_legacy_like_names",
 
     const auto plain = base_state();
     CHECK( plain.fast.name == "2-by-sword" );
+    CHECK( plain.fast.description ==
+           "A club-like sword carved from a sturdy length of wood. "
+           "The hilt uses no guard and a rag-wrapped grip." );
 
     auto nailed = base_state();
     REQUIRE( proc::add_pick( nailed, sch, proc::slot_id( "reinforcement" ), 4 ) );
     REQUIRE( proc::add_pick( nailed, sch, proc::slot_id( "reinforcement" ), 4 ) );
     CHECK( nailed.fast.name == "nail sword" );
+    CHECK( nailed.fast.description ==
+           "A rough wooden sword stiffened with driven nails. "
+           "The hilt uses no guard and a rag-wrapped grip. "
+           "Driven nails add stiffness and a little puncturing power." );
     CHECK( nailed.fast.melee.cut > plain.fast.melee.cut );
     CHECK( nailed.fast.melee.dur >= plain.fast.melee.dur );
 
     auto crude = base_state();
     REQUIRE( proc::add_pick( crude, sch, proc::slot_id( "reinforcement" ), 5 ) );
     CHECK( crude.fast.name == "crude sword" );
+    CHECK( crude.fast.description ==
+           "A crude sword pieced together from wood and scavenged scrap. "
+           "The hilt uses no guard and a rag-wrapped grip. "
+           "Scrap reinforcement adds weight and stiffness." );
     CHECK( crude.fast.melee.cut > plain.fast.melee.cut );
     CHECK( crude.fast.mass_g > plain.fast.mass_g );
 }

tests/proc_lua_test.cpp

@@ -20,6 +20,7 @@ TEST_CASE( "proc_lua_full_bridge_reads_named_function", "[proc][lua]" )
         mass_g = 333,
         volume_ml = 222,
         name = "lua sandwich",
+        description = "lua description",
         vit = { vitC = 12 }
       }
     end,
@@ -49,6 +50,7 @@ TEST_CASE( "proc_lua_full_bridge_reads_named_function", "[proc][lua]" )
     CHECK( full.data.mass_g == 333 );
     CHECK( full.data.volume_ml == 222 );
     CHECK( full.data.name == "lua sandwich" );
+    CHECK( full.data.description == "lua description" );
     CHECK( full.data.vit.at( vitamin_id( "vitC" ) ) == 12 );
 
     auto opts = proc::make_opts{};
@@ -76,10 +78,12 @@ TEST_CASE( "proc_lua_missing_runtime_keeps_preview_blob", "[proc][lua]" )
     preview.mass_g = 60;
     preview.volume_ml = 125;
     preview.name = "fallback sandwich";
+    preview.description = "fallback description";
 
     const auto full = proc::run_full( sch, { fact }, preview );
     CHECK( full.data.kcal == 90 );
     CHECK( full.data.mass_g == 60 );
     CHECK( full.data.volume_ml == 125 );
     CHECK( full.data.name == "fallback sandwich" );
+    CHECK( full.data.description == "fallback description" );
 }

tests/proc_make_test.cpp

@@ -309,6 +309,12 @@ TEST_CASE( "proc_make_item_applies_weapon_blob_to_item", "[proc][make][weapon]"
     CHECK( proc::blob_melee( *made )->bash > 0 );
     CHECK( made->damage_melee( DT_STAB ) == proc::blob_melee( *made )->stab );
     CHECK( made->type_name() == "hand-forged sword" );
+    CHECK( proc::read_payload( *made )->blob.description ==
+           "A serviceable sword built around a forged metal blade. "
+           "The hilt uses no guard and a rag-wrapped grip." );
+    CHECK( made->get_var( "description" ) ==
+           "A serviceable sword built around a forged metal blade. "
+           "The hilt uses no guard and a rag-wrapped grip." );
     REQUIRE( proc::read_payload( *made )->parts.size() == 3 );
     CHECK( proc::read_payload( *made )->parts[0].role == "blade" );
 }

tests/proc_payload_test.cpp

@@ -72,6 +72,7 @@ TEST_CASE( "proc_payload_round_trips_through_item_save", "[proc][payload]" )
     payload.blob.mass_g = 220;
     payload.blob.volume_ml = 330;
     payload.blob.name = "meat sandwich";
+    payload.blob.description = "A sandwich payload used for save testing.";
     payload.blob.melee.stab = 9;
     payload.servings = 6;
     auto part = proc::compact_part{};
@@ -269,6 +270,7 @@ TEST_CASE( "legacy_sandwiches_gain_proc_payload_on_save_load", "[proc][payload][
         CHECK( restored->typeId() == itype_id( "sandwich_generic" ) );
         CHECK( restored->type_name() == legacy.type_name() );
         CHECK( payload->blob.name == legacy.type_name() );
+        CHECK( payload->blob.description == legacy.type->description.translated() );
         CHECK( payload->blob.mass_g == units::to_gram( legacy.weight() ) );
         CHECK( payload->blob.volume_ml == units::to_milliliter( legacy.volume() ) );
         CHECK( payload->servings == std::max( legacy.charges, 1 ) );
@@ -391,6 +393,7 @@ TEST_CASE( "legacy_swords_gain_proc_payload_on_save_load", "[proc][payload][migr
         CHECK( restored->typeId() == itype_id( "proc_sword_generic" ) );
         CHECK( restored->type_name() == legacy.type_name() );
         CHECK( payload->blob.name == legacy.type_name() );
+        CHECK( payload->blob.description == legacy.type->description.translated() );
         CHECK( payload->blob.mass_g == units::to_gram( legacy.weight() ) );
         CHECK( payload->blob.volume_ml == units::to_milliliter( legacy.volume() ) );
         CHECK( units::to_gram( restored->weight() ) == units::to_gram( legacy.weight() ) );