feat: add proc builder payload flow

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/main.lua

@@ -2,6 +2,7 @@ local voltmeter = require("./voltmeter")
 local slimepit = require("./slimepit")
 local artifact_analyzer = require("./artifact_analyzer")
 local lua_traits = require("./lua_traits")
+local procgen = require("./proc")
 
 local mod = game.mod_runtime[game.current_mod]
 local storage = game.mod_storage[game.current_mod]
@@ -11,3 +12,4 @@ mod.slimepit = slimepit
 mod.artifact_analyzer = artifact_analyzer
 mod.lua_traits = lua_traits
 lua_traits.register(mod)
+mod.procgen = procgen

data/json/proc.lua

@@ -0,0 +1,65 @@
+local proc = {}
+proc.food = {}
+
+local function sum_parts(parts, key)
+  local total = 0
+  for _, part in ipairs(parts) do
+    total = total + (part[key] or 0)
+  end
+  return total
+end
+
+local function sum_vitamins(parts)
+  local total = {}
+  for _, part in ipairs(parts) do
+    for id, value in pairs(part.vit or {}) do
+      total[id] = (total[id] or 0) + value
+    end
+  end
+  return total
+end
+
+local function has_tag(parts, needle)
+  for _, part in ipairs(parts) do
+    for _, tag in ipairs(part.tag or {}) do
+      if tag == needle then return true end
+    end
+  end
+  return false
+end
+
+function proc.food.full(params)
+  local facts = params.facts or {}
+  local mass_g = sum_parts(facts, "mass_g")
+  local volume_ml = sum_parts(facts, "volume_ml")
+  local kcal = sum_parts(facts, "kcal")
+  local vit = sum_vitamins(facts)
+  local name = "sandwich"
+  if has_tag(facts, "meat") then
+    name = "meat sandwich"
+  elseif has_tag(facts, "cheese") then
+    name = "cheese sandwich"
+  elseif has_tag(facts, "veg") then
+    name = "veggy sandwich"
+  end
+  return {
+    mass_g = mass_g,
+    volume_ml = volume_ml,
+    kcal = kcal,
+    vit = vit,
+    name = name,
+  }
+end
+
+function proc.food.make(params)
+  local blob = params.blob or {}
+  return {
+    name = blob.name,
+    kcal = blob.kcal,
+    mass_g = blob.mass_g,
+    volume_ml = blob.volume_ml,
+    mode = "none",
+  }
+end
+
+return proc

data/json/proc/sandwich.json

@@ -0,0 +1,24 @@
+[
+  {
+    "type": "PROC",
+    "id": "sandwich",
+    "cat": "food",
+    "res": "sandwich_generic",
+    "hist": {
+      "def": "none",
+      "ok": [ "none", "compact", "full" ]
+    },
+    "slot": [
+      { "id": "top", "role": "bread", "min": 1, "max": 1, "ok": [ "itype:bread", "itype:bread_garlic" ] },
+      { "id": "bot", "role": "bread", "min": 1, "max": 1, "ok": [ "itype:bread", "itype:bread_garlic" ] },
+      { "id": "veg", "role": "veg", "min": 0, "max": 4, "rep": true, "ok": [ "itype:lettuce", "itype:tomato" ] },
+      { "id": "cheese", "role": "cheese", "min": 0, "max": 2, "rep": true, "ok": [ "itype:cheese", "itype:cheese_fresh", "itype:cheese_hard" ] },
+      { "id": "cond", "role": "cond", "min": 0, "max": 2, "rep": true, "ok": [ "itype:mustard" ] },
+      { "id": "meat", "role": "meat", "min": 0, "max": 3, "rep": true, "ok": [ "itype:meat_cooked", "itype:meat_cooked_seasoned" ] }
+    ],
+    "lua": {
+      "full": "proc.food.full",
+      "make": "proc.food.make"
+    }
+  }
+]

data/json/recipes/food/proc_sandwich.json

@@ -0,0 +1,18 @@
+[
+  {
+    "type": "recipe",
+    "result": "sandwich_generic",
+    "category": "CC_FOOD",
+    "subcategory": "CSC_FOOD_MEAT",
+    "skill_used": "cooking",
+    "difficulty": 1,
+    "time": 100,
+    "proc": true,
+    "proc_id": "sandwich",
+    "builder_name": { "str": "Sandwich" },
+    "builder_desc": { "str": "Pick bread and fillings." },
+    "qualities": [],
+    "tools": [],
+    "components": []
+  }
+]

src/consumption.cpp

@@ -37,6 +37,7 @@
 #include "mutation.h"
 #include "options.h"
 #include "pldata.h"
+#include "proc_item.h"
 #include "recipe.h"
 #include "recipe_dictionary.h"
 #include "requirements.h"
@@ -310,6 +311,15 @@ static std::map<vitamin_id, int> compute_default_effective_vitamins(
 static nutrients compute_default_effective_nutrients( const item &comest,
         const Character &you, const cata::flat_set<flag_id> &extra_flags = {} )
 {
+    if( const auto kcal = proc::blob_kcal( comest ) ) {
+        auto ret = nutrients{};
+        ret.kcal = *kcal;
+        if( const auto vit = proc::blob_vitamins( comest ) ) {
+            ret.vitamins = *vit;
+        }
+        return ret;
+    }
+
     return { compute_default_effective_kcal( comest, you, extra_flags ),
              compute_default_effective_vitamins( comest, you ) };
 }

src/crafting.cpp

@@ -55,6 +55,8 @@
 #include "pimpl.h"
 #include "player.h"
 #include "player_activity.h"
+#include "proc_item.h"
+#include "popup.h"
 #include "point.h"
 #include "recipe.h"
 #include "recipe_dictionary.h"
@@ -605,6 +607,12 @@ void Character::make_craft_with_command( const recipe_id &id_to_make, int batch_
         return;
     }
 
+    if( recipe_to_make.is_proc() ) {
+        popup( _( "Procedural builder stub for %s" ), recipe_to_make.builder_name().translated().empty() ?
+               recipe_to_make.result_name() : recipe_to_make.builder_name().translated() );
+        return;
+    }
+
     *last_craft = craft_command( &recipe_to_make, batch_size, is_long, this, loc );
     last_craft->execute();
 }
@@ -2209,6 +2217,14 @@ void crafting::complete_disassemble( Character &who, const iuse_location &target
     // Even if the best-fit recipe does not involve those items
     location_vector<item> &components = dis_item.get_components();
 
+    if( const auto payload = proc::read_payload( dis_item ); payload &&
+        payload->mode == proc::hist::compact ) {
+        auto restored = proc::restore_parts( *payload );
+        std::ranges::for_each( restored, [&]( detached_ptr<item> &entry ) {
+            components.push_back( std::move( entry ) );
+        } );
+    }
+
     // If the components are empty, item is the default kind and made of default components
     if( components.empty() ) {
         const bool uncraft_liquids_contained = dis.has_flag( flag_UNCRAFT_LIQUIDS_CONTAINED );

src/item.cpp

@@ -85,6 +85,7 @@
 #include "overmapbuffer.h"
 #include "pimpl.h"
 #include "player.h"
+#include "proc_item.h"
 #include "player_activity.h"
 #include "pldata.h"
 #include "point.h"
@@ -4956,6 +4957,7 @@ void item::on_contents_changed()
 
 void item::on_damage( int qty, damage_type )
 {
+    proc::apply_on_damage( *this, qty );
     if( is_corpse() && qty + damage_ >= max_damage() ) {
         set_flag( flag_PULPED );
     }
@@ -5467,6 +5469,14 @@ units::mass item::weight( bool include_contents, bool integral ) const
         return ret;
     }
 
+    if( const auto mass = proc::blob_mass( *this ) ) {
+        auto ret = units::from_gram( *mass );
+        if( include_contents ) {
+            ret += contents.item_weight_modifier();
+        }
+        return ret;
+    }
+
     units::mass ret;
     std::string local_str_mass = integral ? get_var( "integral_weight" ) : get_var( "weight" );
     if( local_str_mass.empty() ) {
@@ -5594,6 +5604,10 @@ units::volume item::base_volume() const
         }
     }
 
+    if( const auto proc_volume = proc::blob_volume( *this ) ) {
+        return units::from_milliliter( *proc_volume );
+    }
+
     return type->volume;
 }
 
@@ -5615,6 +5629,10 @@ units::volume item::volume( bool integral ) const
         return ret;
     }
 
+    if( const auto proc_volume = proc::blob_volume( *this ) ) {
+        return units::from_milliliter( *proc_volume );
+    }
+
     const int local_volume = get_var( "volume", -1 );
     units::volume ret;
     if( local_volume >= 0 ) {
@@ -10015,6 +10033,10 @@ std::string item::components_to_string() const
 
 uint64_t item::make_component_hash() const
 {
+    if( const auto hash = proc::component_hash( *this ) ) {
+        return *hash;
+    }
+
     // First we need to sort the IDs so that identical ingredients give identical hashes.
     std::multiset<std::string> id_set;
     for( const item * const &it : components ) {
@@ -11322,6 +11344,21 @@ int item::get_min_str() const
 std::vector<item_comp> item::get_uncraft_components() const
 {
     std::vector<item_comp> ret;
+    if( const auto payload = proc::read_payload( *this ); payload &&
+        payload->mode == proc::hist::compact ) {
+        std::ranges::for_each( payload->parts, [&]( const proc::compact_part & part ) {
+            auto iter = std::ranges::find_if( ret, [&]( item_comp & obj ) {
+                return obj.type == part.id;
+            } );
+            if( iter != ret.end() ) {
+                iter->count += part.n;
+            } else {
+                ret.emplace_back( part.id, part.n );
+            }
+        } );
+        return ret;
+    }
+
     if( components.empty() ) {
         //If item wasn't crafted with specific components use default recipe
         std::vector<std::vector<item_comp>> recipe = recipe_dictionary::get_uncraft(