vehicle item spawn to optional/mandatory

Also clean up variant spawning and fix a bug

Author: ehughsbaird

doc/JSON/VEHICLES_JSON.md

@@ -116,15 +116,13 @@ and describes the items that may spawn at that location.
 TYPE and DATA may be one of:
 ```jsonc
 "items": "itemid"                                   // single item of that type
-"items": [ "itemid1", "itemid2", /* ... */ ]        // all the items in the array
+"items": [ "itemid1", { "id": "itemid2", "variant": "foo" }, /* ... */ ]        // all the items in the array
 "item_groups": "groupid"                            // one or more items in the group, depending on
                                                     // whether the group is a collection or distribution
 "item_groups": [ "groupid1", "groupid2" /* ... */ ] // one or more items for each group
 ```
 the optional keyword "chance" provides an X in 100 chance that a particular item definition will spawn.
 
-If a single item is specified through `"items"`, an itype variant for it can be specified through `"variant"`.
-
 Multiple lines of items may share the same X and Y values.
 
 ### Zones list

src/item_factory.cpp

@@ -1614,7 +1614,10 @@ void Item_factory::finalize_item_blacklist()
         vehicle_prototype &prototype = const_cast<vehicle_prototype &>( const_prototype );
         for( vehicle_item_spawn &vis : prototype.item_spawns ) {
             auto &vec = vis.item_ids;
-            const auto iter = std::remove_if( vec.begin(), vec.end(), item_is_blacklisted );
+            auto is_blacklisted = []( const std::pair<itype_id, std::string> &pair ) {
+                return item_is_blacklisted( pair.first );
+            };
+            const auto iter = std::remove_if( vec.begin(), vec.end(), is_blacklisted );
             vec.erase( iter, vec.end() );
         }
     }
@@ -1716,7 +1719,8 @@ void Item_factory::finalize_item_blacklist()
     for( const vehicle_prototype &const_prototype : vehicles::get_all_prototypes() ) {
         vehicle_prototype &prototype = const_cast<vehicle_prototype &>( const_prototype );
         for( vehicle_item_spawn &vis : prototype.item_spawns ) {
-            for( itype_id &type_to_spawn : vis.item_ids ) {
+            for( std::pair<itype_id, std::string> &spawn_pair : vis.item_ids ) {
+                itype_id &type_to_spawn = spawn_pair.first;
                 std::map<itype_id, std::vector<migration>>::iterator replacement =
                         migrations.find( type_to_spawn );
                 if( replacement == migrations.end() ) {

src/veh_type.cpp

@@ -1327,14 +1327,38 @@ struct veh_proto_part_def_reader : generic_typed_reader<veh_proto_part_def_reade
 
 };
 
-void vehicle_prototype::load( const JsonObject &jo, std::string_view )
+struct veh_spawn_item_reader : generic_typed_reader<veh_spawn_item_reader> {
+    std::pair<itype_id, std::string> get_next( const JsonValue &jv ) const {
+        if( jv.test_string() ) {
+            return std::make_pair( itype_id( jv.get_string() ), "" );
+        }
+        JsonObject jo = jv.get_object();
+        std::pair<itype_id, std::string> ret;
+        mandatory( jo, false, "id", ret.first );
+        optional( jo, false, "variant", ret.second );
+        return ret;
+    }
+};
+
+void vehicle_item_spawn::deserialize( const JsonObject &jo )
 {
-    vgroups[vgroup_id( id.str() )].add_vehicle( id, 100 );
-    optional( jo, was_loaded, "name", name );
+    mandatory( jo, false, "x", pos.x() );
+    mandatory( jo, false, "y", pos.y() );
 
+    mandatory( jo, false, "chance", chance, numeric_bound_reader{ 0, 100 } );
 
+    // constrain both with_magazine and with_ammo to [0-100]
+    optional( jo, false, "magazine", with_magazine, numeric_bound_reader{ 0, 100 }, 0 );
+    optional( jo, false, "ammo", with_ammo, numeric_bound_reader{ 0, 100 }, 0 );
 
+    optional( jo, false, "items", item_ids, veh_spawn_item_reader{} );
+    optional( jo, false, "item_groups", item_groups, string_id_reader<Item_spawn_data> {} );
+}
 
+void vehicle_prototype::load( const JsonObject &jo, std::string_view )
+{
+    vgroups[vgroup_id( id.str() )].add_vehicle( id, 100 );
+    optional( jo, was_loaded, "name", name );
 
     if( jo.has_member( "blueprint" ) ) {
         // currently unused, read to suppress unvisited members warning
@@ -1351,46 +1375,7 @@ void vehicle_prototype::load( const JsonObject &jo, std::string_view )
         parts.insert( parts.end(), tmp.begin(), tmp.end() );
     }
 
-    for( JsonObject spawn_info : jo.get_array( "items" ) ) {
-        vehicle_item_spawn next_spawn;
-        next_spawn.pos.x() = spawn_info.get_int( "x" );
-        next_spawn.pos.y() = spawn_info.get_int( "y" );
-
-        next_spawn.chance = spawn_info.get_int( "chance" );
-        if( next_spawn.chance <= 0 || next_spawn.chance > 100 ) {
-            debugmsg( "Invalid spawn chance in %s (%d, %d): %d%%",
-                      name, next_spawn.pos.x(), next_spawn.pos.y(), next_spawn.chance );
-        }
-
-        // constrain both with_magazine and with_ammo to [0-100]
-        next_spawn.with_magazine = std::max( std::min( spawn_info.get_int( "magazine",
-                                             next_spawn.with_magazine ), 100 ), 0 );
-        next_spawn.with_ammo = std::max( std::min( spawn_info.get_int( "ammo",
-                                         next_spawn.with_ammo ), 100 ), 0 );
-
-        if( spawn_info.has_array( "items" ) ) {
-            //Array of items that all spawn together (i.e. jack+tire)
-            spawn_info.read( "items", next_spawn.item_ids, true );
-        } else if( spawn_info.has_string( "items" ) ) {
-            //Treat single item as array
-            // And read the gun variant (if it exists)
-            if( spawn_info.has_string( "variant" ) ) {
-                const std::string variant = spawn_info.get_string( "variant" );
-                next_spawn.variant_ids.emplace_back( itype_id( spawn_info.get_string( "items" ) ), variant );
-            } else {
-                next_spawn.item_ids.emplace_back( spawn_info.get_string( "items" ) );
-            }
-        }
-        if( spawn_info.has_array( "item_groups" ) ) {
-            //Pick from a group of items, just like map::place_items
-            for( const std::string line : spawn_info.get_array( "item_groups" ) ) {
-                next_spawn.item_groups.emplace_back( line );
-            }
-        } else if( spawn_info.has_string( "item_groups" ) ) {
-            next_spawn.item_groups.emplace_back( spawn_info.get_string( "item_groups" ) );
-        }
-        item_spawns.push_back( std::move( next_spawn ) );
-    }
+    optional( jo, was_loaded, "items", item_spawns );
 
     for( JsonObject jzi : jo.get_array( "zones" ) ) {
         zone_type_id zone_type( jzi.get_member( "type" ).get_string() );
@@ -1687,8 +1672,8 @@ void vehicles::finalize_prototypes()
                           proto.name, i.pos.x(), i.pos.y(), i.chance );
             }
             for( auto &j : i.item_ids ) {
-                if( !item::type_is_defined( j ) ) {
-                    debugmsg( "unknown item %s in spawn list of %s", j.c_str(), proto.id.str() );
+                if( !item::type_is_defined( j.first ) ) {
+                    debugmsg( "unknown item %s in spawn list of %s", j.first.c_str(), proto.id.str() );
                 }
             }
             for( auto &j : i.item_groups ) {

src/veh_type.h

@@ -506,10 +506,11 @@ struct vehicle_item_spawn {
     int with_ammo = 0;
     /** Chance [0-100%] for items to spawn with their default magazine (if any) */
     int with_magazine = 0;
-    std::vector<itype_id> item_ids;
-    // item_ids, but for items with variants specified
-    std::vector<std::pair<itype_id, std::string>> variant_ids;
+    // item_ids, with variants specified (empty is ignored)
+    std::vector<std::pair<itype_id, std::string>> item_ids;
     std::vector<item_group_id> item_groups;
+
+    void deserialize( const JsonObject &jo );
 };
 
 /**

src/vehicle.cpp

@@ -6405,17 +6405,13 @@ void vehicle::place_spawn_items( map &here )
                     continue;
                 }
 
-                for( const itype_id &e : spawn.item_ids ) {
-                    if( rng_float( 0, 1 ) < spawn_rate ) {
-                        item spawn( e );
-                        created.emplace_back( spawn.in_its_container() );
-                    }
-                }
-                for( const std::pair<itype_id, std::string> &e : spawn.variant_ids ) {
+                for( const std::pair<itype_id, std::string> &e : spawn.item_ids ) {
                     if( rng_float( 0, 1 ) < spawn_rate ) {
                         item spawn( e.first );
+                        if( !e.second.empty() ) {
+                            spawn.set_itype_variant( e.second );
+                        }
                         item added = spawn.in_its_container();
-                        added.set_itype_variant( e.second );
                         created.push_back( added );
                     }
                 }

tests/vehicle_export_test.cpp

@@ -30,7 +30,7 @@ static bool operator==( const vehicle_item_spawn &l, const vehicle_item_spawn &r
     return l.pos == r.pos && l.chance == r.chance &&
            l.with_ammo == r.with_ammo && l.with_magazine == r.with_magazine && l.item_ids == r.item_ids &&
            // NOLINTNEXTLINE(misc-redundant-expression)
-           l.variant_ids == r.variant_ids && l.item_groups == r.item_groups;
+           l.item_groups == r.item_groups;
 }
 
 TEST_CASE( "export_vehicle_test" )