Add support for partial armor coverage for monsters (CleverRaven#51304)

* Modify load_damage_array to specify default

* Add weakpoint.h

* Implement weakpoint.cpp

* Various compiler fixes

* Add weakpoints to mtype.

* Let weakpoints modify monster armor.

* Compiler fixes

* weakpoint bugfixes.

* Run astyle

* Add json documentation

* Run json_formatter

* Run clang tidy

* Fix GCC-only warning

* clang-tidy

* Clarify weakpoint docs and switch to percentage coverage.

* Rename armor offset to armor penalty, flipping the sign.

data/json/monsters/misc.json

@@ -17,6 +17,8 @@
     "morale": 100,
     "melee_cut": 0,
     "vision_day": 1,
+    "armor_bullet": 100,
+    "weakpoints": [ { "name": "knee", "armor_mult": { "bullet": 0.5 }, "armor_penalty": { "bullet": 25 }, "coverage": 50 } ],
     "harvest": "exempt",
     "death_function": { "corpse_type": "NO_CORPSE", "message": "The %s melts away." },
     "regenerates": 50,

doc/MONSTERS.md

@@ -63,6 +63,7 @@ Monsters may also have any of these optional properties:
 | `armor_stab`             | (integer) Monster's protection from stab damage
 | `armor_acid`             | (integer) Monster's protection from acid damage
 | `armor_fire`             | (integer) Monster's protection from fire damage
+| `weakpoints`             | (array of objects) Weakpoints in the monster's protection
 | `vision_day`             | (integer) Vision range in full daylight, with `50` being the typical maximum
 | `vision_night`           | (integer) Vision range in total darkness, ex. coyote `5`, bear `10`, sewer rat `30`, flaming eye `40`
 | `tracking_distance`      | (integer) Amount of tiles the monster will keep between itself and its current tracked enemy or followed leader. Defaults to `3`.
@@ -316,6 +317,18 @@ Amount of cutting damage added to die roll on monster melee attack.
 
 Monster protection from bashing, cutting, stabbing, acid and fire damage.
 
+## "weakpoints"
+(array of objects, optional)
+
+Weakpoints in the monster's protection.
+
+| field               | description
+| ---                 | ---
+| `name`              | Name of the weakpoint.
+| `coverage`          | Base percentage chance of hitting the weakpoint. May be increased by skill level. (e.g. A coverage of 5 means a 5% base chance of hitting the weakpoint)
+| `armor_multiplier`  | multipler on the monster's base protection when hitting the weakpoint.
+| `armor_penalty`     | a flat penalty to the monster's protection, applied after the multiplier.
+
 ## "vision_day", "vision_night"
 (integer, optional)
 

src/damage.cpp

@@ -430,10 +430,11 @@ damage_instance load_damage_instance_inherit( const JsonArray &jarr, const damag
     return di;
 }
 
-std::array<float, static_cast<int>( damage_type::NUM )> load_damage_array( const JsonObject &jo )
+std::array<float, static_cast<int>( damage_type::NUM )> load_damage_array( const JsonObject &jo,
+        float default_value )
 {
     std::array<float, static_cast<int>( damage_type::NUM )> ret;
-    float init_val = jo.get_float( "all", 0.0f );
+    float init_val = jo.get_float( "all", default_value );
 
     float phys = jo.get_float( "physical", init_val );
     ret[ static_cast<int>( damage_type::BASH ) ] = jo.get_float( "bash", phys );

src/damage.h

@@ -151,6 +151,7 @@ resistances load_resistances_instance( const JsonObject &jo );
 
 // Returns damage or resistance data
 // Handles some shorthands
-std::array<float, static_cast<int>( damage_type::NUM )> load_damage_array( const JsonObject &jo );
+std::array<float, static_cast<int>( damage_type::NUM )> load_damage_array( const JsonObject &jo,
+        float default_value = 0.0f );
 
 #endif // CATA_SRC_DAMAGE_H

src/monster.cpp

@@ -63,6 +63,7 @@
 #include "trap.h"
 #include "units.h"
 #include "viewer.h"
+#include "weakpoint.h"
 #include "weather.h"
 
 static const efftype_id effect_badpoison( "badpoison" );
@@ -1492,10 +1493,18 @@ bool monster::block_hit( Creature *, bodypart_id &, damage_instance & )
 
 void monster::absorb_hit( const bodypart_id &, damage_instance &dam )
 {
+    resistances r = resistances( *this );
+    const weakpoint *weakpoint = type->weakpoints.select_weakpoint();
+    weakpoint->apply_to( r );
     for( auto &elem : dam.damage_units ) {
         add_msg_debug( debugmode::DF_MONSTER, "Dam Type: %s :: Ar Pen: %.1f :: Armor Mult: %.1f",
                        name_by_dt( elem.type ), elem.res_pen, elem.res_mult );
-        elem.amount -= std::min( resistances( *this ).get_effective_resist( elem ) +
+        add_msg_debug( debugmode::DF_MONSTER,
+                       "Weakpoint: %s :: Armor Mult: %.1f :: Armor Penalty: %.1f :: Resist: %.1f",
+                       weakpoint->id, weakpoint->armor_mult[static_cast<int>( elem.type )],
+                       weakpoint->armor_penalty[static_cast<int>( elem.type )],
+                       r.get_effective_resist( elem ) );
+        elem.amount -= std::min( r.get_effective_resist( elem ) +
                                  get_worn_armor_val( elem.type ), elem.amount );
     }
 }

src/monstergenerator.cpp

@@ -34,6 +34,7 @@
 #include "rng.h"
 #include "translations.h"
 #include "units.h"
+#include "weakpoint.h"
 
 namespace behavior
 {
@@ -718,6 +719,11 @@ void mtype::load( const JsonObject &jo, const std::string &src )
     assign( jo, "armor_acid", armor_acid, strict, 0 );
     assign( jo, "armor_fire", armor_fire, strict, 0 );
 
+    if( jo.has_array( "weakpoints" ) ) {
+        weakpoints.clear();
+        weakpoints.load( jo.get_array( "weakpoints" ) );
+    }
+
     optional( jo, was_loaded, "bleed_rate", bleed_rate, 100 );
 
     assign( jo, "vision_day", vision_day, strict, 0 );

src/mtype.cpp

@@ -14,6 +14,7 @@
 #include "monstergenerator.h"
 #include "translations.h"
 #include "units.h"
+#include "weakpoint.h"
 
 static const itype_id itype_bone( "bone" );
 static const itype_id itype_bone_tainted( "bone_tainted" );

src/mtype.h

@@ -23,6 +23,7 @@
 #include "translations.h"
 #include "type_id.h"
 #include "units.h" // IWYU pragma: keep
+#include "weakpoint.h"
 
 class Creature;
 class monster;
@@ -332,6 +333,7 @@ struct mtype {
         int armor_bullet = -1;  /** innate armor vs. bullet */
         int armor_acid = -1;    /** innate armor vs. acid */
         int armor_fire = -1;    /** innate armor vs. fire */
+        ::weakpoints weakpoints;
 
         // Bleed rate in percent, 0 makes the monster immune to bleeding
         int bleed_rate = 100;

src/weakpoint.cpp

@@ -0,0 +1,77 @@
+#include "weakpoint.h"
+
+#include <string>
+#include <utility>
+
+#include "assign.h"
+#include "creature.h"
+#include "damage.h"
+#include "item.h"
+#include "rng.h"
+
+class JsonArray;
+class JsonObject;
+
+weakpoint::weakpoint()
+{
+    // arrays must be filled manually to avoid UB.
+    armor_mult.fill( 1.0f );
+    armor_penalty.fill( 0.0f );
+}
+
+void weakpoint::load( const JsonObject &jo )
+{
+    assign( jo, "id", id );
+    assign( jo, "name", name );
+    assign( jo, "coverage", coverage, false, 0.0f, 100.0f );
+    if( jo.has_object( "armor_mult" ) ) {
+        armor_mult = load_damage_array( jo.get_object( "armor_mult" ), 1.0f );
+    }
+    if( jo.has_object( "armor_penalty" ) ) {
+        armor_penalty = load_damage_array( jo.get_object( "armor_penalty" ), 0.0f );
+    }
+    // Set the ID to the name, if not provided.
+    if( id.empty() ) {
+        id = name;
+    }
+}
+
+void weakpoint::apply_to( resistances &resistances ) const
+{
+    for( int i = 0; i < static_cast<int>( damage_type::NUM ); ++i ) {
+        resistances.resist_vals[i] *= armor_mult[i];
+        resistances.resist_vals[i] -= armor_penalty[i];
+    }
+}
+
+float weakpoint::hit_chance() const
+{
+    return coverage;
+}
+
+const weakpoint *weakpoints::select_weakpoint() const
+{
+    float idx = rng_float( 0.0f, 100.0f );
+    for( const weakpoint &weakpoint : weakpoint_list ) {
+        float hit_chance = weakpoint.hit_chance( );
+        if( hit_chance <= idx ) {
+            return &weakpoint;
+        }
+        idx -= hit_chance;
+    }
+    return &default_weakpoint;
+}
+
+void weakpoints::clear()
+{
+    weakpoint_list.clear();
+}
+
+void weakpoints::load( const JsonArray &ja )
+{
+    for( const JsonObject jo : ja ) {
+        weakpoint tmp;
+        tmp.load( jo );
+        weakpoint_list.push_back( std::move( tmp ) );
+    }
+}

src/weakpoint.h

@@ -0,0 +1,48 @@
+#pragma once
+#ifndef CATA_SRC_WEAKPOINT_H
+#define CATA_SRC_WEAKPOINT_H
+
+#include <array>
+#include <string>
+#include <vector>
+
+#include "creature.h"
+#include "damage.h"
+
+class JsonArray;
+class JsonObject;
+
+struct weakpoint {
+    // ID of the weakpoint. Equal to the name, if not provided.
+    std::string id;
+    // Name of the weakpoint. Can be empty.
+    std::string name;
+    // Percent chance of hitting the weakpoint. Can be increased by skill.
+    float coverage = 100.0f;
+    // Multiplier for existing armor values. Defaults to 1.
+    std::array<float, static_cast<int>( damage_type::NUM )> armor_mult;
+    // Flat penalty to armor values. Applied after the multiplier.
+    std::array<float, static_cast<int>( damage_type::NUM )> armor_penalty;
+
+    weakpoint();
+    // Apply the armor multipliers and offsets to a set of resistances.
+    void apply_to( resistances &resistances ) const;
+    // Return the change of the creature hitting the weakpoint.
+    float hit_chance( ) const;
+    void load( const JsonObject &jo );
+};
+
+struct weakpoints {
+    // List of weakpoints. Each weakpoint should have a unique id.
+    std::vector<weakpoint> weakpoint_list;
+    // Default weakpoint to return.
+    weakpoint default_weakpoint;
+
+    // Selects a weakpoint to hit.
+    const weakpoint *select_weakpoint( ) const;
+
+    void clear();
+    void load( const JsonArray &ja );
+};
+
+#endif // CATA_SRC_WEAKPOINT_H