Initial implementation of wounds (#82525)

* Initial implementation of wounds

* Apply suggestions from code review

Co-authored-by: ehughsbaird <[email protected]>

* Apply suggestions from code review

Co-authored-by: mqrause <[email protected]>

* Update doc/JSON/WOUNDS.md

* Apply suggestions from code review

Co-authored-by: ehughsbaird <[email protected]>

* try to sort finalization a bit

---------

Co-authored-by: ehughsbaird <[email protected]>
Co-authored-by: mqrause <[email protected]>

Author: 3 people

data/core/external_options.json

@@ -104,6 +104,13 @@
     "stype": "bool",
     "value": false
   },
+  {
+    "type": "EXTERNAL_OPTION",
+    "name": "WOUND_CHANCE",
+    "//": "Probability to get a wound from taking damage.  0.25 means 25% to get a wound.",
+    "stype": "float",
+    "value": 0.25
+  },
   {
     "type": "EXTERNAL_OPTION",
     "name": "PAIN_PENALTY_MOD_STR",

data/mods/Isolation-Protocol/game_balance.json

@@ -16,5 +16,11 @@
     "name": "WEARY_RECOVERY_MULT",
     "stype": "float",
     "value": 2
+  },
+  {
+    "type": "EXTERNAL_OPTION",
+    "name": "WOUND_CHANCE",
+    "stype": "float",
+    "value": 0.0
   }
 ]

data/mods/aftershock_exoplanet/options.json

@@ -11,6 +11,12 @@
     "//": "Anesthetic cost removed in this mod, as autodocs do all the heavy lifting.",
     "tools": [ [  ] ]
   },
+  {
+    "type": "EXTERNAL_OPTION",
+    "name": "WOUND_CHANCE",
+    "stype": "float",
+    "value": 0.0
+  },
   {
     "type": "EXTERNAL_OPTION",
     "name": "CBM_SLOTS_ENABLED",

doc/JSON/WOUNDS.md

@@ -0,0 +1,23 @@
+# Wounds
+
+Wound is a type, that affects specific bodyparts. It's similar in this to effects, but it can be applied only on specific bodyparts, and their ability to be aided/repaired using (at the moment of writing, yet to be added) wound_fix
+
+### Wound
+
+```jsonc
+  {
+    "id": "scratch",
+    "type": "wound",
+    "name": { "str": "scratch", "str_pl": "scratches" },
+    "description": "Foobar.",
+    "weight": 10, // weight of a wound, determines the chance of this specific wound to be picked when limb takes damage. Default 1
+    "damage_types": [ "cut", "bash" ], // only taking these type of damage can apply wound. Mandatory
+    "damage_required": [ 1, 1000 ], // smallest and highest damage that is required for this wound to be applied. Mandatory
+    "pain": [ 1, 10 ], // when wound is applied, it would give character this random amount of pain rolled between this two numbers. Default 0
+    "healing_time": [ "2 hours", "25 days" ], // how long this wound need time to be fully healed. Rolled randomly when applied, supposed to be adjusted by wound_fix.
+            // Default infinite duration
+    "whitelist_bp_with_flag": "LIMB_UPPER", // only body parts with this flag can receive the wound.
+    "blacklist_bp_with_flag": "CYBERNETIC_OR_WHATEVER_IT_DOESNT_EXIST_YET", // Bodyparts with this flag cannot receive this wound.
+  }
+```
+

src/bodypart.cpp

@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "body_part_set.h"
+#include "calendar.h"
 #include "creature.h"
 #include "debug.h"
 #include "enum_conversions.h"
@@ -20,6 +21,8 @@
 #include "pimpl.h"
 #include "rng.h"
 #include "subbodypart.h"
+#include "type_id.h"
+#include "wound.h"
 
 const bodypart_str_id body_part_arm_l( "arm_l" );
 const bodypart_str_id body_part_arm_r( "arm_r" );
@@ -514,6 +517,14 @@ void body_part_type::finalize()
     if( !damage.empty() ) {
         unarmed_bonus = true;
     }
+
+    for( const wound_type &wd : wound_type::get_all() ) {
+        if( wd.allowed_on_bodypart( id ) ) {
+            const bp_wounds bpw = { wd.id, wd.damage_types, wd.damage_required };
+            potential_wounds.add( bpw, wd.weight );
+        }
+    }
+
     finalize_damage_map( armor.resist_vals );
 }
 
@@ -1031,6 +1042,28 @@ float bodypart::get_limb_score_max( const limb_score_id &score ) const
     return id->get_limb_score_max( score );
 }
 
+std::vector<wound> bodypart::get_wounds() const
+{
+    return wounds;
+}
+
+void bodypart::add_wound( wound &wd )
+{
+    wounds.push_back( wd );
+}
+
+void bodypart::add_wound( wound_type_id wd )
+{
+    wounds.emplace_back( wd );
+}
+
+void bodypart::update_wounds( time_duration time_passed )
+{
+    wounds.erase( std::remove_if( wounds.begin(), wounds.end(), [time_passed]( wound & wd ) {
+        return wd.update_wound( time_passed );
+    } ), wounds.end() );
+}
+
 int bodypart::get_hp_cur() const
 {
     return hp_cur;
@@ -1224,6 +1257,8 @@ void bodypart::serialize( JsonOut &json ) const
     json.member( "temp_conv", units::to_legacy_bodypart_temp( temp_conv ) );
     json.member( "frostbite_timer", frostbite_timer );
 
+    json.member( "wounds", wounds );
+
     json.end_object();
 }
 
@@ -1245,6 +1280,8 @@ void bodypart::deserialize( const JsonObject &jo )
     }
     jo.read( "frostbite_timer", frostbite_timer, true );
 
+    jo.read( "wounds", wounds );
+
 }
 
 void stat_hp_mods::load( const JsonObject &jsobj )

src/bodypart.h

@@ -20,10 +20,13 @@
 #include "type_id.h"
 #include "units.h"
 #include "weather.h"
+#include "weighted_list.h"
+#include "wound.h"
 
 class Creature;
 class JsonObject;
 class JsonOut;
+class time_duration;
 struct body_part_type;
 struct localized_comparator;
 template <typename E> struct enum_traits;
@@ -135,6 +138,14 @@ struct bp_limb_score {
     float max = 0.0f;
 };
 
+struct bp_wounds {
+    wound_type_id id;
+    // damage type that can apply this specific wound
+    std::vector<damage_type_id> damage_type;
+    // how much damage one need to deal to apply this wound, min and max
+    std::pair<int, int> damage_required;
+};
+
 struct bp_onhit_effect {
     // ID of the effect to apply
     efftype_id id;
@@ -317,6 +328,8 @@ struct body_part_type {
         // TODO: Coverage/Encumbrance multiplier
         std::vector<bodypart_str_id> similar_bodyparts;
 
+        weighted_int_list<bp_wounds> potential_wounds;
+
     private:
         int bionic_slots_ = 0;
         body_part_type::type _primary_limb_type = body_part_type::type::num_types;
@@ -456,6 +469,8 @@ class bodypart
 
         std::array<int, NUM_WATER_TOLERANCE> mut_drench; // NOLINT(cata-serialize)
 
+        std::vector<wound> wounds;
+
         // adjust any limb "value" based on how wounded the limb is. scaled to 0-75%
         float wound_adjusted_limb_value( float val ) const;
         // Same idea as for wounds, though not all scores get this applied. Should be applied after wounds.
@@ -500,6 +515,12 @@ class bodypart
                               int override_wounds = -1 ) const;
         float get_limb_score_max( const limb_score_id &score ) const;
 
+        std::vector<wound> get_wounds() const;
+
+        void add_wound( wound &wd );
+        void add_wound( wound_type_id wd );
+        void update_wounds( time_duration time_passed );
+
         int get_hp_cur() const;
         int get_hp_max() const;
         float get_hit_size() const;

src/character.cpp

@@ -113,8 +113,8 @@
 #include "translation.h"
 #include "translations.h"
 #include "trap.h"
-#include "uilist.h"
 #include "ui_manager.h"
+#include "uilist.h"
 #include "uistate.h"
 #include "units.h"
 #include "value_ptr.h"
@@ -127,6 +127,7 @@
 #include "vpart_range.h"
 #include "weather.h"
 #include "weather_type.h"
+#include "wound.h"
 
 class activity_actor;
 
@@ -2546,6 +2547,8 @@ void Character::process_turn()
         }
     }
 
+    update_wounds( 1_turns );
+
     // We can dodge again! Assuming we can actually move...
     if( in_sleep_state() ) {
         blocks_left = 0;
@@ -7957,6 +7960,21 @@ void Character::update_cached_mutations()
     trait_flag_cache.clear();
 }
 
+void Character::apply_wound( bodypart_id bp, wound_type_id wd )
+{
+    bodypart &body_bp = body.at( bp.id() );
+    body_bp.add_wound( wd );
+    morale->on_stat_change( "perceived_pain", get_perceived_pain() );
+}
+
+void Character::update_wounds( time_duration time_passed )
+{
+    for( auto &bp : body ) {
+        bp.second.update_wounds( time_passed );
+    }
+    morale->on_stat_change( "perceived_pain", get_perceived_pain() );
+}
+
 void Character::passive_absorb_hit( const bodypart_id &bp, damage_unit &du ) const
 {
     // >0 check because some mutations provide negative armor
@@ -8377,6 +8395,30 @@ void Character::apply_damage( Creature *source, bodypart_id hurt, int dam,
     }
 }
 
+void Character::apply_random_wound( bodypart_id bp, const damage_instance &d )
+{
+    if( x_in_y( 1.0f - get_option<float>( "WOUND_CHANCE" ), 1.0f ) ) {
+        return;
+    }
+
+    weighted_int_list<wound_type_id> possible_wounds;
+    for( const weighted_object<int, bp_wounds> &wd : bp->potential_wounds ) {
+        for( const damage_unit &du : d.damage_units ) {
+            const bool damage_within_limits =
+                du.amount >= wd.obj.damage_required.first &&
+                du.amount <= wd.obj.damage_required.second;
+            const bool damage_type_matches = std::find( wd.obj.damage_type.begin(), wd.obj.damage_type.end(),
+                                             du.type ) != wd.obj.damage_type.end();
+            if( damage_within_limits && damage_type_matches ) {
+                possible_wounds.add( wd.obj.id, wd.weight );
+            }
+        }
+    }
+    if( !possible_wounds.empty() ) {
+        apply_wound( bp, *possible_wounds.pick() );
+    }
+}
+
 dealt_damage_instance Character::deal_damage( Creature *source, bodypart_id bp,
         const damage_instance &d, const weakpoint_attack &attack, const weakpoint & )
 {
@@ -8493,6 +8535,8 @@ dealt_damage_instance Character::deal_damage( Creature *source, bodypart_id bp,
         }
     }
 
+    apply_random_wound( bp, d );
+
     on_hurt( source );
     return dealt_dams;
 }
@@ -12798,6 +12842,18 @@ bool Character::immune_to( const bodypart_id &bp, damage_unit dam ) const
     return dam.amount <= 0;
 }
 
+int Character::get_pain() const
+{
+    int p = 0;
+    for( const std::pair<const bodypart_str_id, bodypart> &bp : get_body() ) {
+        for( const wound &wd : bp.second.get_wounds() ) {
+            p += wd.get_pain();
+        }
+    }
+
+    return p + Creature::get_pain();
+}
+
 int Character::mod_pain( int npain )
 {
     if( npain > 0 ) {

src/character.h

@@ -952,6 +952,10 @@ class Character : public Creature, public visitable
         void update_stomach( const time_point &from, const time_point &to );
         /** Updates the mutations from enchantments */
         void update_cached_mutations();
+        /** Adds this specific wound to bodypart */
+        void apply_wound( bodypart_id bp, wound_type_id wd );
+        /** Updates the status of wounds character has */
+        void update_wounds( time_duration time_passed );
         /** Returns true if character needs food, false if character is an NPC with NO_NPC_FOOD set */
         bool needs_food() const;
         /** Increases hunger, thirst, sleepiness and stimulants wearing off. `rate_multiplier` is for retroactive updates. */
@@ -1289,6 +1293,7 @@ class Character : public Creature, public visitable
         /** Actually hurt the player, hurts a body_part directly, no armor reduction */
         void apply_damage( Creature *source, bodypart_id hurt, int dam,
                            bool bypass_med = false ) override;
+        void apply_random_wound( bodypart_id bp, const damage_instance &d );
         /** Calls Creature::deal_damage and handles damaged effects (waking up, etc.) */
         dealt_damage_instance deal_damage( Creature *source, bodypart_id bp,
                                            const damage_instance &d,
@@ -2677,6 +2682,8 @@ class Character : public Creature, public visitable
          */
         bool immune_to( const bodypart_id &bp, damage_unit dam ) const;
 
+        /** Modifies a pain value by wounds before passing it to Creature::mod_pain() */
+        int get_pain() const override;
         /** Modifies a pain value by player traits before passing it to Creature::mod_pain() */
         int mod_pain( int npain ) override;
         /** Sets new intensity of pain an reacts to it */

src/character_morale.cpp

@@ -208,6 +208,11 @@ void Character::check_and_recover_morale()
     apply_persistent_morale();
 
     if( !morale->consistent_with( test_morale ) ) {
+
+        add_msg_debug( debugmode::DF_CHARACTER, "Test morale:\n%s\n", test_morale.to_string_writable() );
+        add_msg_debug( debugmode::DF_CHARACTER, "Actual %s morale:\n%s\n", disp_name( true ),
+                       morale->to_string_writable() );
+
         *morale = player_morale( test_morale ); // Recover consistency
         add_msg_debug( debugmode::DF_CHARACTER, "%s morale was recovered.", disp_name( true ) );
     }

src/creature.h

@@ -824,7 +824,6 @@ class Creature : public viewer
         bodypart_id get_random_body_part( bool main = false ) const;
         /**
          * Returns body parts this creature have.
-         * @param only_main If true, only displays parts that can have hit points
          */
         std::vector<bodypart_id> get_all_body_parts(
             get_body_part_flags = get_body_part_flags::none ) const;