Use optional/mandatory for vpart_info and vpart_reqs. (#82634)

* Get mods lists in length order

This means that more mods will be tested sooner, exposing errors faster.

* weighted_string_id_reader can require weights

It makes sense for formats to be able to require a value

* vpart_info easy optional/mandatory conversion

* vpart_reqs to optional/mandatory

Author: Maleclypse

build-scripts/get_all_mods.py

@@ -10,6 +10,7 @@
 import os
 
 mods_this_time = []
+mods_lists = []
 
 exclusions = [
     # Tuple of (mod_id, mod_id) - these two mods will be incompatible
@@ -49,7 +50,7 @@ def add_mods(mods):
 
 
 def print_modlist(modlist, master_list):
-    print(','.join(modlist))
+    mods_lists.append(','.join(modlist))
     master_list -= set(modlist)
     modlist.clear()
 
@@ -92,7 +93,7 @@ def print_modlist(modlist, master_list):
         if ident in obsolete_mods:
             continue
         mods_this_time.append(os.path.basename(mod.path))
-    print(','.join(mods_this_time))
+    mods_lists.append(','.join(mods_this_time))
     mods_this_time.clear()
 
 mods_remaining = set(all_mod_dependencies)
@@ -107,3 +108,6 @@ def print_modlist(modlist, master_list):
         raise RuntimeError(
             'mods remain ({}) but none could be added'.format(mods_remaining))
     print_modlist(mods_this_time, mods_remaining)
+
+for list in sorted(mods_lists, key=len, reverse=True):
+    print(list)

src/generic_factory.h

@@ -9,6 +9,7 @@
 #include <limits>
 #include <list>
 #include <map>
+#include <optional>
 #include <set>
 #include <string>
 #include <string_view>
@@ -1843,20 +1844,21 @@ class weighted_string_id_reader : public generic_typed_reader<weighted_string_id
 public:
     static constexpr bool read_objects = true;
 
-    V default_weight;
-    explicit weighted_string_id_reader( V default_weight ) : default_weight( default_weight ) {};
+    std::optional<V> default_weight;
+    explicit weighted_string_id_reader( std::optional<V> default_weight ) : default_weight(
+            default_weight ) {};
 
     std::pair<K, V> get_next( const JsonValue &val ) const {
         if( val.is_member() ) {
             const JsonMember &jm = dynamic_cast<const JsonMember &>( val );
             return std::pair<K, V>( jm.name(), static_cast<V>( val.get_float() ) );
         } else if( val.test_object() ) {
             JsonObject inline_pair = val.get_object();
-            if( !( inline_pair.size() == 1 || inline_pair.size() == 2 ) ) {
+            if( !( ( inline_pair.size() == 1 && default_weight.has_value() ) || inline_pair.size() == 2 ) ) {
                 inline_pair.throw_error( "weighted_string_id_reader failed to read object" );
             }
             K pair_key;
-            V pair_val = default_weight;
+            V pair_val = default_weight.value_or( V() );
             for( JsonMember mem : inline_pair ) {
                 if( mem.test_string() ) {
                     pair_key = K( std::move( mem.get_string() ) );
@@ -1875,12 +1877,14 @@ class weighted_string_id_reader : public generic_typed_reader<weighted_string_id
             return std::pair<K, V>(
                        K( std::move( arr[0].get_string() ) ),
                        static_cast<V>( arr[1].get_float() ) );
-        } else {
+        } else if( default_weight.has_value() ) {
             if( val.test_string() ) {
                 return std::pair<K, V>(
-                           K( std::move( val.get_string() ) ), default_weight );
+                           K( std::move( val.get_string() ) ), *default_weight );
             }
             val.throw_error( "weighted_string_id_reader provided with invalid string_id" );
+        } else {
+            val.throw_error( "weighted_string_id_reader requires two entries" );
         }
     }
 };

src/veh_type.cpp

@@ -49,6 +49,8 @@
 #include "vpart_range.h"
 #include "wcwidth.h"
 
+class emit;
+
 namespace
 {
 generic_factory<vehicle_prototype> vehicle_prototype_factory( "vehicle", "id" );
@@ -179,25 +181,11 @@ static void parse_vp_reqs( const JsonObject &obj, const vpart_id &id, const std:
     }
     JsonObject src = obj.get_object( key );
 
-    JsonArray sk = src.get_array( "skills" );
-    if( !sk.empty() ) {
-        skills.clear();
-        for( JsonArray cur : sk ) {
-            if( cur.size() != 2 ) {
-                debugmsg( "vpart '%s' has requirement with invalid skill entry", id.str() );
-                continue;
-            }
-            skills.emplace( skill_id( cur.get_string( 0 ) ), cur.get_int( 1 ) );
-        }
-    }
+    optional( src, false, "skills", skills, weighted_string_id_reader<skill_id, int> { std::nullopt } );
 
-    if( src.has_string( "time" ) ) {
-        assign( src, "time", time, /* strict = */ false );
-    } else if( src.has_int( "time" ) ) { // remove in 0.H
-        time = time_duration::from_moves( src.get_int( "time" ) );
-        debugmsg( "vpart '%s' defines requirement time as integer, use time units string", id.str() );
-    }
+    optional( src, false, "time", time, time );
 
+    // FIXME: generic typed reader for requirements
     if( src.has_string( "using" ) ) {
         reqs = { { requirement_id( src.get_string( "using" ) ), 1 } };
     } else if( src.has_array( "using" ) ) {
@@ -273,29 +261,29 @@ void vpart_info::load( const JsonObject &jo, const std::string &src )
 {
     const bool strict = src == "dda";
 
-    assign( jo, "name", name_, strict );
-    assign( jo, "item", base_item, strict );
-    assign( jo, "remove_as", removed_item, strict );
-    assign( jo, "location", location, strict );
-    assign( jo, "durability", durability, strict );
-    assign( jo, "damage_modifier", dmg_mod, strict );
-    assign( jo, "energy_consumption", energy_consumption, strict );
-    assign( jo, "power", power, strict );
-    assign( jo, "epower", epower, strict );
-    assign( jo, "emissions", emissions, strict );
-    assign( jo, "exhaust", exhaust, strict );
-    assign( jo, "fuel_type", fuel_type, strict );
-    assign( jo, "default_ammo", default_ammo, strict );
-    assign( jo, "folded_volume", folded_volume, strict );
-    optional( jo, was_loaded, "size", size );
-    assign( jo, "bonus", bonus, strict );
-    assign( jo, "cargo_weight_modifier", cargo_weight_modifier, strict );
-    assign( jo, "categories", categories, strict );
-    assign( jo, "flags", flags, strict );
-    assign( jo, "description", description, strict );
-    optional( jo, was_loaded, "color", color, nc_color_reader{} );
-    optional( jo, was_loaded, "broken_color", color_broken, nc_color_reader{} );
-    assign( jo, "comfort", comfort, strict );
+    optional( jo, was_loaded, "name", name_ );
+    optional( jo, was_loaded, "item", base_item );
+    optional( jo, was_loaded, "remove_as", removed_item );
+    optional( jo, was_loaded, "location", location );
+    optional( jo, was_loaded, "durability", durability, 0 );
+    optional( jo, was_loaded, "damage_modifier", dmg_mod, 100 );
+    optional( jo, was_loaded, "energy_consumption", energy_consumption, 0_W );
+    optional( jo, was_loaded, "power", power, 0_W );
+    optional( jo, was_loaded, "epower", epower, 0_W );
+    optional( jo, was_loaded, "emissions", emissions, string_id_reader<emit> {} );
+    optional( jo, was_loaded, "exhaust", exhaust, string_id_reader<emit> {} );
+    optional( jo, was_loaded, "fuel_type", fuel_type, itype_id::NULL_ID() );
+    optional( jo, was_loaded, "default_ammo", default_ammo, itype_id::NULL_ID() );
+    optional( jo, was_loaded, "folded_volume", folded_volume, std::nullopt );
+    optional( jo, was_loaded, "size", size, 0_ml );
+    optional( jo, was_loaded, "bonus", bonus, 0 );
+    optional( jo, was_loaded, "cargo_weight_modifier", cargo_weight_modifier, 100 );
+    optional( jo, was_loaded, "categories", categories, string_reader{} );
+    optional( jo, was_loaded, "flags", flags, string_reader{} );
+    optional( jo, was_loaded, "description", description );
+    optional( jo, was_loaded, "color", color, nc_color_reader{}, c_light_gray );
+    optional( jo, was_loaded, "broken_color", color_broken, nc_color_reader{}, c_light_gray );
+    optional( jo, was_loaded, "comfort", comfort, 0 );
     int legacy_floor_bedding_warmth = units::to_legacy_bodypart_temp_delta( floor_bedding_warmth );
     assign( jo, "floor_bedding_warmth", legacy_floor_bedding_warmth, strict );
     floor_bedding_warmth = units::from_legacy_bodypart_temp_delta( legacy_floor_bedding_warmth );
@@ -343,20 +331,14 @@ void vpart_info::load( const JsonObject &jo, const std::string &src )
         parse_vp_control_reqs( reqs, id, "land", control_land );
     }
 
-    assign( jo, "looks_like", looks_like, strict );
+    optional( jo, was_loaded, "looks_like", looks_like, looks_like );
 
     if( jo.has_member( "breaks_into" ) ) {
         breaks_into_group = item_group::load_item_group(
                                 jo.get_member( "breaks_into" ), "collection", "breaks_into for vpart " + id.str() );
     }
 
-    JsonArray qual = jo.get_array( "qualities" );
-    if( !qual.empty() ) {
-        qualities.clear();
-        for( JsonArray pair : qual ) {
-            qualities[ quality_id( pair.get_string( 0 ) ) ] = pair.get_int( 1 );
-        }
-    }
+    optional( jo, was_loaded, "qualities", qualities, weighted_string_id_reader<quality_id, int> {std::nullopt} );
 
     JsonArray tools = jo.get_array( "pseudo_tools" );
     if( !tools.empty() ) {
@@ -371,10 +353,10 @@ void vpart_info::load( const JsonObject &jo, const std::string &src )
             }
         }
     }
-    assign( jo, "folding_tools", folding_tools, strict );
-    assign( jo, "unfolding_tools", unfolding_tools, strict );
-    assign( jo, "folding_time", folding_time, strict );
-    assign( jo, "unfolding_time", unfolding_time, strict );
+    optional( jo, was_loaded, "folding_tools", folding_tools, string_id_reader<itype> {} );
+    optional( jo, was_loaded, "unfolding_tools", unfolding_tools, string_id_reader<itype> {} );
+    optional( jo, was_loaded, "folding_time", folding_time, 10_seconds );
+    optional( jo, was_loaded, "unfolding_time", unfolding_time, 10_seconds );
 
     if( jo.has_member( "damage_reduction" ) ) {
         JsonObject dred = jo.get_object( "damage_reduction" );