Monster weakpoints to optional/mandatory

Unfortunately, the "weakpoints" can delete from the "weakpoint sets",
the contents of which aren't known until finalization. This requires
disabling the 'copy-from' requirement for weakpoints and adding a
special reader to handle this.

Author: ehughsbaird

data/mods/No_Hope/monsters.json

@@ -503,6 +503,7 @@
     "weight": "386 kg",
     "hp": 120,
     "speed": 200,
+    "weakpoint_sets": [ "wps_animal_quadruped" ],
     "material": [ "flesh" ],
     "symbol": "M",
     "color": "brown",

src/generic_factory.h

@@ -1389,6 +1389,7 @@ template<typename Derived>
 class generic_typed_reader
 {
     static constexpr bool read_objects = false;
+    static constexpr bool check_extend_delete_copy_from = true;
 public:
     template<typename C, typename Fn>
     // I tried using a member function pointer and couldn't work it out
@@ -1619,8 +1620,11 @@ class generic_typed_reader
         const Derived &derived = static_cast<const Derived &>( *this );
         // or no handler for the container
         if( !was_loaded ) {
-            warn_disabled_feature( jo, "extend", member_name, "no copy-from" );
-            warn_disabled_feature( jo, "delete", member_name, "no copy-from" );
+            // this is gross, but some JSON wants to delete from things loaded by a different member on the same entity
+            if( Derived::check_extend_delete_copy_from ) {
+                warn_disabled_feature( jo, "extend", member_name, "no copy-from" );
+                warn_disabled_feature( jo, "delete", member_name, "no copy-from" );
+            }
             warn_disabled_feature( jo, "relative", member_name, "no copy-from" );
             warn_disabled_feature( jo, "proportional", member_name, "no copy-from" );
         }
@@ -2083,6 +2087,20 @@ class time_bound_reader : public bound_reader<T>
     };
 };
 
+struct weakpoints;
+
+struct weakpoints_reader : generic_typed_reader<weakpoints_reader> {
+    static constexpr bool check_extend_delete_copy_from = false;
+
+    std::set<std::string> &deleted;
+
+    explicit weakpoints_reader( std::set<std::string> &del ) : deleted( del ) {}
+
+    weakpoints get_next( const JsonValue &jv ) const;
+    bool do_extend( const JsonObject &jo, std::string_view name, weakpoints &member ) const;
+    bool do_delete( const JsonObject &jo, std::string_view name, weakpoints &member ) const;
+};
+
 /**
  * Only for external use in legacy code where migrating to `class translation`
  * is impractical. For new code load with `class translation` instead.

src/monstergenerator.cpp

@@ -862,58 +862,10 @@ void mtype::load( const JsonObject &jo, const std::string &src )
     // Load each set of weakpoints.
     // Each subsequent weakpoint set overwrites
     // matching weakpoints from the previous set.
-    if( jo.has_array( "weakpoint_sets" ) ) {
-        weakpoints_deferred.clear();
-        for( JsonValue jval : jo.get_array( "weakpoint_sets" ) ) {
-            weakpoints_deferred.emplace_back( jval.get_string() );
-        }
-    }
-
+    optional( jo, was_loaded, "weakpoint_sets", weakpoints_deferred, auto_flags_reader<weakpoints_id> {} );
     // Finally, inline weakpoints overwrite
     // any matching weakpoints from the previous sets.
-    if( jo.has_array( "weakpoints" ) ) {
-        weakpoints_deferred_inline.clear();
-        ::weakpoints tmp_wp;
-        tmp_wp.load( jo.get_array( "weakpoints" ) );
-        weakpoints_deferred_inline.add_from_set( tmp_wp, true );
-    }
-
-    if( jo.has_object( "extend" ) ) {
-        JsonObject tmp = jo.get_object( "extend" );
-        tmp.allow_omitted_members();
-        if( tmp.has_array( "weakpoint_sets" ) ) {
-            for( JsonValue jval : tmp.get_array( "weakpoint_sets" ) ) {
-                weakpoints_deferred.emplace_back( jval.get_string() );
-            }
-        }
-        if( tmp.has_array( "weakpoints" ) ) {
-            ::weakpoints tmp_wp;
-            tmp_wp.load( tmp.get_array( "weakpoints" ) );
-            weakpoints_deferred_inline.add_from_set( tmp_wp, true );
-        }
-    }
-
-    if( jo.has_object( "delete" ) ) {
-        JsonObject tmp = jo.get_object( "delete" );
-        tmp.allow_omitted_members();
-        if( tmp.has_array( "weakpoint_sets" ) ) {
-            for( JsonValue jval : tmp.get_array( "weakpoint_sets" ) ) {
-                weakpoints_id set_id( jval.get_string() );
-                auto iter = std::find( weakpoints_deferred.begin(), weakpoints_deferred.end(), set_id );
-                if( iter != weakpoints_deferred.end() ) {
-                    weakpoints_deferred.erase( iter );
-                }
-            }
-        }
-        if( tmp.has_array( "weakpoints" ) ) {
-            ::weakpoints tmp_wp;
-            tmp_wp.load( tmp.get_array( "weakpoints" ) );
-            for( const weakpoint &wp_del : tmp_wp.weakpoint_list ) {
-                weakpoints_deferred_deleted.emplace( wp_del.id );
-            }
-            weakpoints_deferred_inline.del_from_set( tmp_wp );
-        }
-    }
+    optional( jo, was_loaded, "weakpoints", weakpoints_deferred_inline, weakpoints_reader{weakpoints_deferred_deleted} );
 
     optional( jo, was_loaded, "status_chance_multiplier", status_chance_multiplier, numeric_bound_reader{0.0f, 5.0f},
               1.f );

src/weakpoint.cpp

@@ -3,6 +3,7 @@
 #include <algorithm>
 #include <cmath>
 #include <memory>
+#include <set>
 #include <string>
 #include <utility>
 
@@ -579,6 +580,61 @@ void weakpoints::clear()
     weakpoint_list.clear();
 }
 
+void weakpoints::deserialize( const JsonValue &jv )
+{
+    load( jv.get_array() );
+}
+
+bool weakpoints::handle_extend( const JsonValue &jv )
+{
+    weakpoints tmp;
+    tmp.deserialize( jv );
+    add_from_set( tmp, true );
+    return true;
+}
+
+bool weakpoints::handle_delete( const JsonValue &jv )
+{
+    weakpoints tmp;
+    tmp.deserialize( jv );
+    del_from_set( tmp );
+    return true;
+}
+
+weakpoints weakpoints_reader::get_next( const JsonValue &jv ) const
+{
+    weakpoints ret;
+    if( !jv.read( ret ) ) {
+        jv.throw_error( "Invalid weakpoints format" );
+    }
+    return ret;
+}
+
+bool weakpoints_reader::do_extend( const JsonObject &jo, const std::string_view name,
+                                   weakpoints &member ) const
+{
+    if( !jo.has_member( name ) ) {
+        return false;
+    }
+    return member.handle_extend( jo.get_member( name ) );
+}
+
+bool weakpoints_reader::do_delete( const JsonObject &jo, const std::string_view name,
+                                   weakpoints &member ) const
+{
+    if( !jo.has_member( name ) ) {
+        return false;
+    }
+    weakpoints tmp;
+    tmp.deserialize( jo.get_member( name ) );
+    // deferred delete for weakpoints from sets
+    for( const weakpoint &del : tmp.weakpoint_list ) {
+        deleted.emplace( del.id );
+    }
+    member.del_from_set( tmp );
+    return true;
+}
+
 void weakpoints::load( const JsonArray &ja )
 {
     for( const JsonObject jo : ja ) {

src/weakpoint.h

@@ -198,6 +198,10 @@ struct weakpoints {
     void finalize();
     void check() const;
 
+    void deserialize( const JsonValue &jv );
+    bool handle_extend( const JsonValue &jv );
+    bool handle_delete( const JsonValue &jv );
+
     /********************* weakpoint_set handling ****************************/
     // load standalone JSON type
     void load( const JsonObject &jo, std::string_view src );