feat: add furniture multicooker

data/json/construction/construct_workshop.json

@@ -259,6 +259,19 @@
     "pre_special": "check_empty",
     "post_furniture": "f_oven"
   },
+  {
+    "type": "construction",
+    "id": "constr_multicooker",
+    "group": "install_multicooker",
+    "category": "WORKSHOP",
+    "required_skills": [  ],
+    "time": "10 m",
+    "qualities": [  ],
+    "components": [ [ [ "multi_cooker", 1 ] ] ],
+    "pre_note": "Will only work if constructed in/on a building that has an electric grid with a mounted battery.",
+    "pre_special": "check_empty",
+    "post_furniture": "f_multicooker"
+  },
   {
     "type": "construction",
     "id": "constr_gridfridge",

data/json/construction_group.json

@@ -1009,6 +1009,11 @@
     "id": "install_oven",
     "name": "Plug In Oven"
   },
+  {
+    "type": "construction_group",
+    "id": "install_multicooker",
+    "name": "Plug In Multi Cooker"
+  },
   {
     "type": "construction_group",
     "id": "install_refrigerator",

data/json/furniture_and_terrain/furniture-appliances.json

@@ -682,6 +682,45 @@
       "ranged": { "reduction": [ 4, 8 ], "destroy_threshold": 30, "block_unaimed_chance": "50%" }
     }
   },
+  {
+    "type": "furniture",
+    "id": "f_multicooker",
+    "name": "multi cooker",
+    "looks_like": "f_oven",
+    "symbol": "#",
+    "description": "Used for automatic cooking food with electricity.",
+    "color": "dark_gray",
+    "move_cost_mod": 2,
+    "coverage": 60,
+    "required_str": 10,
+    "crafting_pseudo_item": "fake_oven",
+    "flags": [ "PLACE_ITEM", "TRANSPARENT", "FIRE_CONTAINER", "CONTAINER", "BLOCKSDOOR", "MOUNTABLE", "EASY_DECONSTRUCT" ],
+    "examine_action": "multicooker",
+    "deconstruct": { "items": [ { "item": "multi_cooker", "count": 1 } ] },
+    "max_volume": "40 L",
+    "bash": {
+      "str_min": 8,
+      "str_max": 30,
+      "sound": "metal screeching!",
+      "sound_fail": "clang!",
+      "items": [
+        { "item": "sheet_metal", "count": [ 1, 4 ] },
+        { "item": "sheet_metal_small", "count": [ 8, 12 ] },
+        { "item": "steel_chunk", "count": [ 0, 3 ] },
+        { "item": "scrap", "count": [ 0, 6 ] },
+        { "item": "element", "count": [ 1, 3 ] },
+        { "item": "cable", "charges": [ 1, 3 ] },
+        { "item": "pilot_light", "count": 1 }
+      ],
+      "//": "Variable reduction since might hit more or less material.",
+      "ranged": { "reduction": [ 4, 8 ], "destroy_threshold": 30, "block_unaimed_chance": "50%" }
+    },
+    "default_vars": {
+      "CATEGORYIDS": "[ \"CSC_FOOD_MEAT\", \"CSC_FOOD_VEGGI\", \"CSC_FOOD_PASTA\" ]",
+      "CHARGE_PER_MIN": "10",
+      "CHARGE_START": "10"
+    }
+  },
   {
     "type": "furniture",
     "id": "f_rvoven",

docs/en/mod/json/reference/tiles/furn_and_terrain.md

@@ -41,6 +41,12 @@ title: Furniture and Terrain
     "message": "The safe is hacksawed open!",
     "sound": "Gachunk!",
     "byproducts": [{ "item": "scrap", "count": 13 }]
+  },
+  "default_vars": {
+    "CATEGORYIDS": "[ \"CSC_FOOD_MEAT\", \"CSC_FOOD_VEGGI\", \"CSC_FOOD_PASTA\" ]",
+    "CHARGE_PER_MIN": "5",
+    "CHARGE_START": "100",
+    "CRAFTSPEEDMULT": "1.0"
   }
 }
 ```
@@ -171,6 +177,17 @@ it for the purpose of surgery.
 (Optional) Dispenses infinite amounts of specified liquid item when interacted. Must be used with
 `"examine_action": "liquid_source"` to work.
 
+#### `default_vars`
+
+(Optional) Default string variables for objects, always a string string pair; Can be used to store arbitrary data or for some data for iuses such as
+
+- Multicooker
+  - "CATEGORYIDS"; String is a json array of categories for applicable recipes
+  - "RECIPEIDS": String is a json array of valid recipes
+  - "CHARGE_PER_MIN": Charges consumed per minute
+  - "CHARGE_START": Charges consumed at start
+  - "CRAFTSPEEDMULT": Multiplier on craft speed
+
 ### Terrain
 
 ```json

src/assign.cpp

@@ -1,5 +1,5 @@
 #include "assign.h"
-
+#include "data_vars.h"
 #include <algorithm>
 
 void report_strict_violation( const JsonObject &jo, const std::string &message,
@@ -695,3 +695,15 @@
         }
     }
 }
+
+bool assign( const JsonObject &jo,
+             const std::string &name,
+             data_vars::data_set &val,
+             const bool strict )
+{
+    for( const JsonMember member : jo.get_object( name ) ) {
+        val[member.name()] = member.get_string();
+    }
+    return true;
+}
+

src/assign.h

@@ -17,7 +17,7 @@
 #include "units.h"
 #include "units_serde.h"
 #include "concepts_utility.h"
-
+#include "data_vars.h"
 namespace detail
 {
 template<typename ...T>
@@ -424,6 +424,11 @@ bool assign( const JsonObject &jo,
              nc_color &val,
              const bool strict = false );
 
+bool assign( const JsonObject &jo,
+             const std::string &name,
+             data_vars::data_set &val,
+             const bool strict = false );
+
 class time_duration;
 
 template<typename T>

src/catalua_bindings_item.cpp

@@ -525,24 +525,33 @@ void reg_item( sol::state &lua )
         SET_FX( convert );
 
         DOC( "Get variable as string" );
-        luna::set_fx( ut, "get_var_str",
-                      sol::resolve<std::string( const std::string &, const std::string & ) const>
-                      ( &item::get_var ) );
+        luna::set_fx( ut, "get_var_str", []( const UT_CLASS & c, const std::string & name, const std::string & def_val )
+        {
+            return c.get_var( name, def_val );
+        } );
         DOC( "Get variable as float number" );
-        luna::set_fx( ut, "get_var_num",
-                      sol::resolve<double( const std::string &, double ) const>( &item::get_var ) );
+        luna::set_fx( ut, "get_var_num", []( const UT_CLASS & c, const std::string & name, const double & def_val )
+        {
+            return c.get_var( name, def_val );
+        } );
         DOC( "Get variable as tripoint" );
-        luna::set_fx( ut, "get_var_tri",
-                      sol::resolve<tripoint( const std::string &, const tripoint & ) const>
-                      ( &item::get_var ) );
-
-        luna::set_fx( ut, "set_var_str", sol::resolve<void( const std::string &, const std::string & )>
-                      ( &item::set_var ) );
-        luna::set_fx( ut, "set_var_num",
-                      sol::resolve<void( const std::string &, double )>( &item::set_var ) );
-        luna::set_fx( ut, "set_var_tri",
-                      sol::resolve<void( const std::string &, const tripoint & )>( &item::set_var ) );
+        luna::set_fx( ut, "get_var_tri", []( const UT_CLASS & c, const std::string & name, const tripoint & def_val )
+        {
+            return c.get_var( name, def_val );
+        } );
 
+        luna::set_fx( ut, "set_var_str", []( UT_CLASS & c, const std::string & name, const std::string & val )
+        {
+            c.set_var( name, val );
+        } );
+        luna::set_fx( ut, "set_var_num", []( UT_CLASS & c, const std::string & name, const double & val )
+        {
+            c.set_var( name, val );
+        } );
+        luna::set_fx( ut, "set_var_tri", []( UT_CLASS & c, const std::string & name, const tripoint & val )
+        {
+            c.set_var( name, val );
+        } );
         SET_FX( attack_cost );
         SET_FX( stamina_cost );
 

src/data_vars.h

@@ -0,0 +1,117 @@
+#pragma once
+
+#include <map>
+#include <string>
+
+#include "data_vars_cvt.h"
+
+namespace data_vars
+{
+
+template<typename T>
+struct type_converter;
+
+template<typename T>
+using type_converter_t = typename type_converter<T>::type;
+
+class data_set
+{
+    public:
+        using storage = std::map<std::string, std::string>;
+        using key_type = storage::key_type;
+        using value_type = storage::value_type;
+        using mapped_type = storage::mapped_type;
+        using iterator = storage::iterator;
+        using const_iterator = storage::const_iterator;
+
+        template<typename Value, typename Conv = type_converter_t<Value>>
+        bool try_get( const std::string &key, Value &out_val, const Conv &converter = {} ) const {
+            const auto it = _data.find( key );
+            if( it == _data.end() ) {
+                return false;
+            }
+            return converter( it->second, out_val );
+        }
+
+        template <typename Value, typename Conv = type_converter_t<Value>>
+        Value get( const std::string &key, const Value &default_value = {}, const Conv &converter = {} )
+        const {
+            Value val;
+            if( !data_set::try_get<Value>( key, val, converter ) ) {
+                return default_value;
+            }
+            return val;
+        }
+
+        template <typename Value, typename Conv = type_converter_t<Value>>
+        void set( const key_type &name, const Value &value, const Conv &converter = {} ) {
+            std::string str;
+            if( !converter( value, str ) ) {
+                throw std::runtime_error( "failed to convert value to string" );
+            }
+            _data[name] = str;
+        }
+
+        bool try_get( const std::string &key, mapped_type &out_val ) const {
+            const auto it = _data.find( key );
+            if( it == _data.end() ) {
+                return false;
+            }
+            out_val = it->second;
+            return true;
+        }
+
+        mapped_type get( const std::string &key, const mapped_type &default_value = {} ) const {
+            std::string val;
+            if( !try_get( key, val ) ) {
+                return default_value;
+            }
+            return val;
+        }
+
+        void set( const key_type &name, const mapped_type &value ) {
+            _data[name] = value;
+        }
+
+        std::string get( const std::string &key, const char *default_value ) const {
+            std::string val;
+            if( !try_get( key, val ) ) {
+                return default_value;
+            }
+            return val;
+        }
+
+        void set( const key_type &name, const char *value ) {
+            _data[name] = std::string{value};
+        }
+
+        void merge( const data_set &other, bool skip_existing = false ) {
+            for( const auto &[key, value] : other ) {
+                if( skip_existing && contains( key ) ) {
+                    continue;
+                }
+                set( key, value );
+            }
+        }
+
+        bool operator==( const data_set &other ) const { return ( _data ) == other._data; }
+        mapped_type &operator[]( const key_type &name ) { return _data[name]; }
+
+        bool empty() const { return _data.empty(); }
+        bool contains( const key_type &key ) const { return _data.contains( key ); }
+        iterator begin() { return _data.begin(); }
+        const_iterator begin() const { return _data.begin(); }
+        iterator end() { return _data.end(); }
+        const_iterator end() const { return _data.end(); }
+        iterator find( const key_type &key ) { return _data.find( key ); }
+        const_iterator find( const key_type &key ) const { return _data.find( key ); }
+
+        void clear() { _data.clear(); }
+        void erase( const key_type &name ) { _data.erase( name ); }
+        void erase( const iterator it ) { _data.erase( it ); }
+
+    private:
+        storage _data;
+};
+
+} // namespace data_vars

src/data_vars_cvt.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <sstream>
+#include <iomanip>
+
+#include "point.h"
+#include "json.h"
+#include "cata_utility.h"
+
+namespace data_vars
+{
+
+template<typename T>
+struct json_converter {
+    using value_type = T;
+
+    // Need a try-catch blocks because JsonIn/Out
+    // Doesn't care if you ask it to not throw on error
+    // And may just do so anyway
+
+    bool operator()( const T &in_val, std::string &out_val ) const {
+        try {
+            std::ostringstream os;
+            JsonOut jsout{os};
+            jsout.write( in_val );
+            out_val = os.str();
+            return true;
+        } catch( JsonError &e ) {
+            debugmsg( "Error writing value: %s", e.what() );
+            return false;
+        }
+    }
+
+    bool operator()( const std::string &in_val, T &out_val ) const {
+        try {
+            std::istringstream is{in_val};
+            JsonIn jsin{is};
+            return jsin.read( out_val, false );
+        } catch( JsonError &e ) {
+            debugmsg( "Error reading value '%s': %s", in_val, e.what() );
+            return false;
+        }
+    }
+};
+
+template<typename T>
+struct type_converter {
+    using type = json_converter<T>;
+};
+
+} // namespace data_vars