fix: scale proc food servings and migrate sandwich recipe ids

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

src/proc_item.cpp

@@ -67,7 +67,7 @@ auto payload_servings( const item &it, const proc::payload &data ) -> int
     if( data.servings > 0 ) {
         return data.servings;
     }
-    return it.count_by_charges() ? default_stack_servings( it.typeId() ) : 1;
+    return it.is_comestible() && it.count_by_charges() ? default_stack_servings( it.typeId() ) : 0;
 }
 
 auto scaled_payload_total( const item &it, const proc::payload &data, const int total ) -> int
@@ -1084,15 +1084,16 @@ auto proc::make_item( const schema &sch, const std::vector<part_fact> &facts,
         full.data.name = !sch.cat.empty() ? sch.cat + " " + sch.id.str() : sch.id.str();
     }
 
-    if( result->count_by_charges() ) {
+    if( result->is_comestible() && result->count_by_charges() ) {
         result->charges = scaled_food_servings( *result, full.data );
     }
 
     auto out_payload = payload{};
     out_payload.id = sch.id;
     out_payload.mode = mode;
     out_payload.blob = full.data;
-    out_payload.servings = result->count_by_charges() ? std::max( result->charges, 1 ) : 1;
+    out_payload.servings = result->is_comestible() && result->count_by_charges() ?
+                           std::max( result->charges, 1 ) : 0;
     out_payload.fp = fast_fp( sch, full.data, facts );
     if( mode == hist::compact ) {
         out_payload.parts = !opts.slots.empty() ? make_compact_parts( facts, opts.slots ) :

src/recipe_dictionary.cpp

@@ -56,7 +56,7 @@ static DynamicDataLoader::deferred_json deferred;
 template<>
 const recipe &string_id<recipe>::obj() const
 {
-    const auto iter = recipe_dict.recipes.find( *this );
+    const auto iter = recipe_dict.recipes.find( recipe_dictionary::migrate_id( *this ) );
     if( iter != recipe_dict.recipes.end() ) {
         if( iter->second.obsolete ) {
             return null_recipe;
@@ -72,7 +72,27 @@ const recipe &string_id<recipe>::obj() const
 template<>
 bool string_id<recipe>::is_valid() const
 {
-    return recipe_dict.recipes.contains( *this );
+    return recipe_dict.recipes.contains( recipe_dictionary::migrate_id( *this ) );
+}
+
+auto recipe_dictionary::migrate_id( const recipe_id &id ) -> recipe_id
+{
+    if( id.is_null() || item_controller == nullptr ) {
+        return id;
+    }
+
+    if( const auto iter = recipe_dict.recipes.find( id ); iter != recipe_dict.recipes.end() ) {
+        if( !iter->second.obsolete ) {
+            return id;
+        }
+        const auto migrated_result_id = item_controller->migrate_id( iter->second.result() );
+        const auto migrated_result_recipe_id = recipe_id( migrated_result_id.str() );
+        return recipe_dict.recipes.contains( migrated_result_recipe_id ) ? migrated_result_recipe_id : id;
+    }
+
+    const auto migrated_item_id = item_controller->migrate_id( itype_id( id.str() ) );
+    const auto migrated_id = recipe_id( migrated_item_id.str() );
+    return recipe_dict.recipes.contains( migrated_id ) ? migrated_id : id;
 }
 
 const recipe &recipe_dictionary::get_uncraft( const itype_id &id )

src/recipe_dictionary.h

@@ -40,6 +40,7 @@ class recipe_dictionary
 
         /** Returns disassembly recipe (or null recipe if no match) */
         static const recipe &get_uncraft( const itype_id &id );
+        static auto migrate_id( const recipe_id &id ) -> recipe_id;
 
         static void load_recipe( const JsonObject &jo, const std::string &src );
         static void load_uncraft( const JsonObject &jo, const std::string &src );
@@ -186,4 +187,3 @@ class recipe_subset
 void serialize( const recipe_subset &value, JsonOut &jsout );
 void deserialize( recipe_subset &value, JsonIn &jsin );
 
-

tests/proc_make_test.cpp

@@ -161,6 +161,57 @@ TEST_CASE( "proc_food_remaining_size_tracks_servings", "[proc][make][food]" )
     CHECK( proc::blob_kcal( *made ) == starting_kcal );
 }
 
+TEST_CASE( "proc_make_item_scales_stew_servings_with_total_size", "[proc][make][food]" )
+{
+    auto sch = proc::schema{};
+    sch.id = proc::schema_id( "stew" );
+    sch.cat = "food";
+    sch.res = itype_id( "stew_generic" );
+    sch.slots = {
+        proc::slot_data{ .id = proc::slot_id( "base" ), .role = "base", .min = 1, .max = 1, .ok = {}, .no = {} },
+        proc::slot_data{ .id = proc::slot_id( "veg" ), .role = "veg", .min = 1, .max = 4, .rep = true, .ok = {}, .no = {} }
+    };
+
+    auto broth = proc::part_fact{};
+    broth.ix = 1;
+    broth.id = itype_id( "broth" );
+    broth.kcal = 600;
+    broth.mass_g = 2200;
+    broth.volume_ml = 2200;
+
+    auto carrot = proc::part_fact{};
+    carrot.ix = 2;
+    carrot.id = itype_id( "carrot" );
+    carrot.kcal = 300;
+    carrot.mass_g = 1800;
+    carrot.volume_ml = 1800;
+
+    auto opts = proc::make_opts{};
+    opts.mode = proc::hist::none;
+    opts.slots = { proc::slot_id( "base" ), proc::slot_id( "veg" ) };
+    const auto made = proc::make_item( sch, { broth, carrot }, opts );
+
+    const auto base = item( "stew_generic", calendar::turn );
+    const auto ceil_div = []( const int value, const int divisor ) {
+        return value <= 0 ? 0 : ( value + divisor - 1 ) / divisor;
+    };
+    const auto base_servings = std::max( base.charges, 1 );
+    const auto expected_servings = std::max( {
+        base_servings,
+        ceil_div( ( broth.mass_g + carrot.mass_g ) * base_servings,
+                  std::max( units::to_gram( base.weight() ), 1L ) ),
+        ceil_div( ( broth.volume_ml + carrot.volume_ml ) * base_servings,
+                  std::max( units::to_milliliter( base.volume() ), 1 ) )
+    } );
+
+    REQUIRE( proc::read_payload( *made ) );
+    CHECK( made->charges == expected_servings );
+    CHECK( proc::read_payload( *made )->servings == expected_servings );
+    CHECK( made->charges > base_servings );
+    CHECK( made->weight() == units::from_gram( 4000 ) );
+    CHECK( made->volume() == units::from_milliliter( 4000 ) );
+}
+
 TEST_CASE( "proc_food_uses_blob_nutrition_and_component_hash", "[proc][make][food]" )
 {
     auto sch = proc::schema{};

tests/proc_payload_test.cpp

@@ -290,6 +290,36 @@ TEST_CASE( "legacy_sandwiches_gain_proc_payload_on_save_load", "[proc][payload][
     } );
 }
 
+TEST_CASE( "legacy_sandwich_recipe_ids_migrate_to_proc_recipe", "[proc][payload][migration]" )
+{
+    const auto proc_recipe = recipe_id( "sandwich_generic" );
+    REQUIRE( proc_recipe.is_valid() );
+
+    for( const auto &legacy_id : {
+             recipe_id( "blt" ),
+             recipe_id( "sandwich_t" ),
+             recipe_id( "sandwich_veggy" ),
+             recipe_id( "sandwich_cheese" ),
+             recipe_id( "sandwich_sauce" ),
+             recipe_id( "sandwich_honey" ),
+             recipe_id( "sandwich_jam" ),
+             recipe_id( "sandwich_pb" ),
+             recipe_id( "sandwich_pbj" ),
+             recipe_id( "sandwich_pbh" ),
+             recipe_id( "sandwich_pbm" ),
+             recipe_id( "sandwich_deluxe" ),
+             recipe_id( "sandwich_okay" ),
+             recipe_id( "sandwich_deluxe_nocheese" ),
+             recipe_id( "fish_sandwich" ),
+             recipe_id( "sandwich_cucumber" ),
+         } ) {
+        INFO( legacy_id.str() );
+        CHECK( legacy_id.is_valid() );
+        CHECK( legacy_id.obj().ident() == proc_recipe );
+        CHECK( legacy_id.obj().result() == itype_id( "sandwich_generic" ) );
+    }
+}
+
 TEST_CASE( "legacy_sandwiches_migrate_to_proc_sandwich_items", "[proc][payload][migration]" )
 {
     const auto cases = std::vector<itype_id> {