Merge pull request #82165 from ehughsbaird/activity-optional

Use optional/mandatory for activity type

Author: Maleclypse

src/activity_type.cpp

@@ -8,10 +8,8 @@
 
 #include "activity_actor.h"
 #include "activity_handlers.h"
-#include "assign.h"
 #include "debug.h"
 #include "enums.h"
-#include "flexbuffer_json.h"
 #include "generic_factory.h"
 #include "sounds.h"
 #include "string_formatter.h"
@@ -88,30 +86,28 @@ std::string enum_to_string<distraction_type>( distraction_type data )
 
 void activity_type::load( const JsonObject &jo )
 {
-    activity_type result;
+    mandatory( jo, was_loaded, "id", id_ );
+    optional( jo, was_loaded, "rooted", rooted_, false );
+    optional( jo, was_loaded, "verb", verb_, to_translation( "THIS IS A BUG" ) );
+    optional( jo, was_loaded, "interruptable", interruptable_, true );
+    optional( jo, was_loaded, "interruptable_with_kb", interruptable_with_kb_, true );
+    optional( jo, was_loaded, "can_resume", can_resume_, true );
+    optional( jo, was_loaded, "multi_activity", multi_activity_, false );
+    optional( jo, was_loaded, "refuel_fires", refuel_fires, false );
+    optional( jo, was_loaded, "auto_needs", auto_needs, false );
+    optional( jo, was_loaded, "completion_eoc", completion_EOC );
+    optional( jo, was_loaded, "do_turn_eoc", do_turn_EOC );
+    optional( jo, was_loaded, "ignored_distractions", default_ignored_distractions_ );
+    optional( jo, was_loaded, "based_on", based_on_ );
+    mandatory( jo, was_loaded, "activity_level", activity_level, activity_level_reader{} );
+}
 
-    result.id_ = activity_id( jo.get_string( "id" ) );
-    assign( jo, "rooted", result.rooted_, true );
-    assign( jo, "verb", result.verb_, true );
-    assign( jo, "interruptable", result.interruptable_, true );
-    assign( jo, "interruptable_with_kb", result.interruptable_with_kb_, true );
-    assign( jo, "can_resume", result.can_resume_, true );
-    assign( jo, "multi_activity", result.multi_activity_, false );
-    assign( jo, "refuel_fires", result.refuel_fires, false );
-    assign( jo, "auto_needs", result.auto_needs, false );
-    optional( jo, false, "completion_eoc", result.completion_EOC );
-    optional( jo, false, "do_turn_eoc", result.do_turn_EOC );
-    optional( jo, false, "ignored_distractions", result.default_ignored_distractions_ );
-    optional( jo, false, "based_on", result.based_on_ );
-
-    auto act_level_it = activity_levels_map.find( jo.get_string( "activity_level", "undefined" ) );
-    if( act_level_it == activity_levels_map.end() ) {
-        debugmsg( "activity_type '%s' has invalid activity_level '%s', defaulting to 'LIGHT_EXERCISE'",
-                  result.id().c_str() );
-        result.activity_level = activity_levels_map.at( "LIGHT_EXERCISE" );
-    } else {
-        result.activity_level = act_level_it->second;
-    }
+void activity_type::load_all( const JsonObject &jo )
+{
+    activity_type result;
+    result.load( jo );
+    // FIXME: use generic factory
+    result.was_loaded = true;
 
     if( activity_type_all.count( result.id_ ) ) {
         debugmsg( "Redefinition of %s", result.id_.c_str() );

src/activity_type.h

@@ -36,6 +36,8 @@ struct enum_traits<based_on_type> {
 class activity_type
 {
     private:
+        bool was_loaded = false;
+
         activity_id id_;
         bool rooted_ = false;
         translation verb_ = to_translation( "THIS IS A BUG" );
@@ -100,7 +102,8 @@ class activity_type
         bool call_finish( player_activity *, Character * ) const;
 
         /** JSON stuff */
-        static void load( const JsonObject &jo );
+        void load( const JsonObject &jo );
+        static void load_all( const JsonObject &jo );
         static void check_consistency();
         static void reset();
 };

src/construction.cpp

@@ -32,6 +32,7 @@
 #include "flexbuffer_json.h"
 #include "game.h"
 #include "game_constants.h"
+#include "generic_factory.h"
 #include "input.h"
 #include "input_context.h"
 #include "inventory.h"
@@ -2269,14 +2270,8 @@ void load_construction( const JsonObject &jo )
         con.post_is_furniture = true;
     }
 
-    std::string activity_level = jo.get_string( "activity_level", "MODERATE_EXERCISE" );
-    const auto activity_it = activity_levels_map.find( activity_level );
-    if( activity_it != activity_levels_map.end() ) {
-        con.activity_level = activity_it->second;
-    } else {
-        jo.throw_error( string_format( "Invalid activity level %s in construction %s", activity_level,
-                                       con.str_id.str() ) );
-    }
+    optional( jo, false/*con.was_loaded*/, "activity_level", con.activity_level,
+              activity_level_reader{}, MODERATE_EXERCISE );
 
     if( jo.has_member( "pre_flags" ) ) {
         con.pre_flags.clear();

src/generic_factory.cpp

@@ -1,6 +1,7 @@
 #include "generic_factory.h"
 
 #include "catacharset.h"
+#include "game_constants.h"
 #include "output.h"
 #include "wcwidth.h"
 
@@ -75,3 +76,15 @@ float read_proportional_entry( const JsonObject &jo, std::string_view key )
     }
     return 1.0f;
 }
+
+float activity_level_reader::get_next( const JsonValue &jv ) const
+{
+    if( !jv.test_string() ) {
+        jv.throw_error( "Invalid activity level" );
+    }
+    auto it = activity_levels_map.find( jv.get_string() );
+    if( it == activity_levels_map.end() ) {
+        jv.throw_error( "Invalid activity level" );
+    }
+    return it->second;
+}

src/generic_factory.h

@@ -1826,6 +1826,12 @@ class text_style_check_reader : public generic_typed_reader<text_style_check_rea
         allow_object object_allowed;
 };
 
+class activity_level_reader : public generic_typed_reader<activity_level_reader>
+{
+    public:
+        float get_next( const JsonValue &jv ) const;
+};
+
 struct dbl_or_var;
 
 class dbl_or_var_reader : public generic_typed_reader<dbl_or_var>

src/init.cpp

@@ -278,7 +278,7 @@ void DynamicDataLoader::initialize()
     add( "ammo_effect", &ammo_effects::load );
     add( "emit", &emit::load_emit );
     add( "help", &help::load );
-    add( "activity_type", &activity_type::load );
+    add( "activity_type", &activity_type::load_all );
     add( "addiction_type", &add_type::load_add_types );
     add( "movement_mode", &move_mode::load_move_mode );
     add( "vitamin", &vitamin::load_vitamin );

src/move_mode.cpp

@@ -8,7 +8,6 @@
 #include "assign.h"
 #include "debug.h"
 #include "flexbuffer_json.h"
-#include "game_constants.h"
 #include "generic_factory.h"
 #include "translations.h"
 
@@ -57,11 +56,7 @@ void move_mode::load( const JsonObject &jo, std::string_view/*src*/ )
     assign( jo, "panel_color", _panel_color );
     assign( jo, "symbol_color", _symbol_color );
 
-    std::string exert = jo.get_string( "exertion_level" );
-    if( !activity_levels_map.count( exert ) ) {
-        jo.throw_error_at( id.str(), "Invalid activity level for move mode " + id.str() );
-    }
-    _exertion_level = activity_levels_map.at( exert );
+    mandatory( jo, was_loaded, "exertion_level", _exertion_level, activity_level_reader{} );
 
     mandatory( jo, was_loaded, "change_good_none", change_messages_success[steed_type::NONE] );
     mandatory( jo, was_loaded, "change_good_animal", change_messages_success[steed_type::ANIMAL] );
@@ -230,4 +225,4 @@ void move_mode::set_cycle( const move_mode_id &mode ) const
 void move_mode::set_cycle_back( const move_mode_id &mode ) const
 {
     cycle_back = mode;
-}
+}

src/recipe.cpp

@@ -283,19 +283,7 @@ void recipe::load( const JsonObject &jo, const std::string &src )
     }
 
     // Mandatory: This recipe's exertion level
-    mandatory( jo, was_loaded, "activity_level", exertion_str );
-    // Remove after 0.H
-    if( exertion_str == "fake" ) {
-        debugmsg( "Depreciated activity level \"fake\" found in recipe %s from source %s. Setting activity level to MODERATE_EXERCISE.",
-                  id.c_str(), src );
-        exertion_str = "MODERATE_EXERCISE";
-    }
-    const auto it = activity_levels_map.find( exertion_str );
-    if( it == activity_levels_map.end() ) {
-        jo.throw_error_at(
-            "activity_level", string_format( "Invalid activity level %s", exertion_str ) );
-    }
-    exertion = it->second;
+    mandatory( jo, was_loaded, "activity_level", exertion, activity_level_reader{} );
 
     // Never let the player have a debug or NPC recipe
     if( jo.has_bool( "never_learn" ) ) {