Merge pull request #82900 from GuardianDll/move_body_part_type_type

move body_part_type::type to enums.h to resolve include loop

Author: Maleclypse

src/activity_actor.cpp

@@ -8909,7 +8909,7 @@ void pulp_activity_actor::send_final_message( Character &you ) const
         } else if( pd.stomps_only ) {
             tools = string_format(
                         _( "It took you some time, stomping corpses with nothing but your %1$s, and occasionally cutting it with a %2$s." ),
-                        you.get_random_body_part_of_type( body_part_type::type::leg )->accusative_multiple, pd.cut_tool );
+                        you.get_random_body_part_of_type( bp_type::leg )->accusative_multiple, pd.cut_tool );
         } else if( pd.weapon_only ) {
             tools = string_format(
                         _( "It took you some time, bashing corpses with your %1$s, with occasional cuts with a %2$s." ),
@@ -8922,7 +8922,7 @@ void pulp_activity_actor::send_final_message( Character &you ) const
     } else {
         if( pd.stomps_only ) {
             tools = string_format( _( "It took you some time, stomping corpses with nothing but your %1$s." ),
-                                   you.get_random_body_part_of_type( body_part_type::type::leg )->accusative_multiple );
+                                   you.get_random_body_part_of_type( bp_type::leg )->accusative_multiple );
         } else if( pd.weapon_only ) {
             tools = string_format( _( "It took you some time, bashing corpses with just your %1$s." ),
                                    pd.bash_tool );

src/anatomy.cpp

@@ -9,6 +9,7 @@
 #include "character.h"
 #include "creature.h"
 #include "debug.h"
+#include "enums.h"
 #include "flag.h"
 #include "generic_factory.h"
 #include "messages.h"
@@ -279,20 +280,20 @@ bodypart_id anatomy::select_blocking_part( const Creature *blocker, bool arm, bo
         }
 
         // Can we block with our normal boring arm?
-        if( bp->has_type( body_part_type::type::arm ) && !bp->has_flag( json_flag_NONSTANDARD_BLOCK ) &&
+        if( bp->has_type( bp_type::arm ) && !bp->has_flag( json_flag_NONSTANDARD_BLOCK ) &&
             !arm ) {
             add_msg_debug( debugmode::DF_MELEE, "BP %s discarded, no arm blocks allowed",
                            body_part_name( bp ) );
             continue;
             // Can we block with our normal boring legs?
-        } else if( bp->has_type( body_part_type::type::leg ) &&
+        } else if( bp->has_type( bp_type::leg ) &&
                    !bp->has_flag( json_flag_NONSTANDARD_BLOCK ) && !leg ) {
             add_msg_debug( debugmode::DF_MELEE, "BP %s discarded, no leg blocks allowed",
                            body_part_name( bp ) );
             continue;
             // Can we block with our non-normal non-arms/non-legs?
-        } else if( ( ( !bp->has_type( body_part_type::type::arm ) &&
-                       !bp->has_type( body_part_type::type::leg ) ) || bp->has_flag( json_flag_NONSTANDARD_BLOCK ) ) &&
+        } else if( ( ( !bp->has_type( bp_type::arm ) &&
+                       !bp->has_type( bp_type::leg ) ) || bp->has_flag( json_flag_NONSTANDARD_BLOCK ) ) &&
                    !nonstandard ) {
             add_msg_debug( debugmode::DF_MELEE, "BP %s discarded, no nonstandard blocks allowed",
                            body_part_name( bp ) );

src/bodypart.cpp

@@ -73,23 +73,23 @@ std::string enum_to_string<side>( side data )
 }
 
 template<>
-std::string enum_to_string<body_part_type::type>( body_part_type::type data )
+std::string enum_to_string<bp_type>( bp_type data )
 {
     switch( data ) {
         // *INDENT-OFF*
-        case body_part_type::type::arm: return "arm";
-        case body_part_type::type::other: return "other";
-        case body_part_type::type::foot: return "foot";
-        case body_part_type::type::hand: return "hand";
-        case body_part_type::type::head: return "head";
-        case body_part_type::type::leg: return "leg";
-        case body_part_type::type::mouth: return "mouth";
-        case body_part_type::type::sensor: return "sensor";
-        case body_part_type::type::tail: return "tail";
-        case body_part_type::type::torso: return "torso";
-        case body_part_type::type::wing: return "wing";
+        case bp_type::arm: return "arm";
+        case bp_type::other: return "other";
+        case bp_type::foot: return "foot";
+        case bp_type::hand: return "hand";
+        case bp_type::head: return "head";
+        case bp_type::leg: return "leg";
+        case bp_type::mouth: return "mouth";
+        case bp_type::sensor: return "sensor";
+        case bp_type::tail: return "tail";
+        case bp_type::torso: return "torso";
+        case bp_type::wing: return "wing";
             // *INDENT-ON*
-        case body_part_type::type::num_types:
+        case bp_type::num_types:
             break;
     }
     cata_fatal( "Invalid body part type." );
@@ -249,12 +249,12 @@ void body_part_type::load_bp( const JsonObject &jo, const std::string &src )
     body_part_factory.load( jo, src );
 }
 
-body_part_type::type body_part_type::primary_limb_type() const
+bp_type body_part_type::primary_limb_type() const
 {
     return _primary_limb_type;
 }
 
-bool body_part_type::has_type( const body_part_type::type &type ) const
+bool body_part_type::has_type( const bp_type &type ) const
 {
     return limbtypes.count( type ) > 0;
 }
@@ -349,21 +349,21 @@ void body_part_type::load( const JsonObject &jo, std::string_view )
     optional( jo, was_loaded, "is_vital", is_vital, false );
     if( jo.has_array( "limb_types" ) ) {
         limbtypes.clear();
-        body_part_type::type first_type = body_part_type::type::num_types;
+        bp_type first_type = bp_type::num_types;
         bool set_first_type = true;
         for( JsonValue jval : jo.get_array( "limb_types" ) ) {
             float weight = 1.0f;
-            body_part_type::type limb_type;
+            bp_type limb_type;
             if( jval.test_array() ) {
                 JsonArray jarr = jval.get_array();
-                limb_type = io::string_to_enum<body_part_type::type>( jarr.get_string( 0 ) );
+                limb_type = io::string_to_enum<bp_type>( jarr.get_string( 0 ) );
                 weight = jarr.get_float( 1 );
                 set_first_type = false;
             } else {
-                limb_type = io::string_to_enum<body_part_type::type>( jval.get_string() );
+                limb_type = io::string_to_enum<bp_type>( jval.get_string() );
             }
             limbtypes.emplace( limb_type, weight );
-            if( first_type == body_part_type::type::num_types ) {
+            if( first_type == bp_type::num_types ) {
                 first_type = limb_type;
             }
         }
@@ -373,12 +373,12 @@ void body_part_type::load( const JsonObject &jo, std::string_view )
         }
     } else {
         limbtypes.clear();
-        body_part_type::type limb_type = {};
+        bp_type limb_type = {};
         mandatory( jo, was_loaded, "limb_type", limb_type );
         limbtypes.emplace( limb_type, 1.0f );
     }
 
-    if( _primary_limb_type == body_part_type::type::num_types ) {
+    if( _primary_limb_type == bp_type::num_types ) {
         float high = 0.f;
         for( auto &bp_type : limbtypes ) {
             if( high < bp_type.second ) {

src/bodypart.h

@@ -183,31 +183,6 @@ struct body_part_type {
          * the different types of body parts there are.
          * this allows for the ability to group limbs or determine a limb of a certain type
          */
-        enum class type {
-            // this is where helmets go, and is a vital part.
-            head,
-            // the torso is generally the center of mass of a creature
-            torso,
-            // provides sight
-            sensor,
-            // you eat and scream with this
-            mouth,
-            // may manipulate objects to some degree, is a main part
-            arm,
-            // manipulates objects. usually is not a main part.
-            hand,
-            // provides motive power
-            leg,
-            // helps with balance. usually is not a main part
-            foot,
-            // may reduce fall damage
-            wing,
-            // may provide balance or manipulation
-            tail,
-            // more of a general purpose limb, such as horns.
-            other,
-            num_types
-        };
 
         std::vector<std::pair<bodypart_str_id, mod_id>> src;
 
@@ -238,7 +213,7 @@ struct body_part_type {
         bodypart_str_id opposite_part;
 
         // A weighted list of limb types. The type with the highest weight is the primary type
-        std::map<body_part_type::type, float> limbtypes;
+        std::map<bp_type, float> limbtypes;
 
         // Limb-specific attacks
         std::set<matec_id> techniques;
@@ -332,7 +307,7 @@ struct body_part_type {
 
     private:
         int bionic_slots_ = 0;
-        body_part_type::type _primary_limb_type = body_part_type::type::num_types;
+        bp_type _primary_limb_type = bp_type::num_types;
         // Protection from various damage types
         resistances armor;
 
@@ -346,8 +321,8 @@ struct body_part_type {
         bool was_loaded = false;
 
         bool has_flag( const json_character_flag &flag ) const;
-        body_part_type::type primary_limb_type() const;
-        bool has_type( const body_part_type::type &type ) const;
+        bp_type primary_limb_type() const;
+        bool has_type( const bp_type &type ) const;
 
         // return a random sub part from the weighted list of subparts
         // if secondary is true instead returns a part from only the secondary sublocations
@@ -393,11 +368,6 @@ struct body_part_type {
                 &covered );
 };
 
-template<>
-struct enum_traits<body_part_type::type> {
-    static constexpr body_part_type::type last = body_part_type::type::num_types;
-};
-
 struct layer_details {
 
     std::vector<int> pieces;

src/character.cpp

@@ -2236,7 +2236,7 @@ bool Character::has_min_manipulators() const
 bool Character::has_two_arms_lifting() const
 {
     // 0.5f is one "standard" arm, so if you have more than that you barely qualify.
-    return get_limb_score( limb_score_lift, body_part_type::type::arm ) > 0.5f;
+    return get_limb_score( limb_score_lift, bp_type::arm ) > 0.5f;
 }
 
 std::set<matec_id> Character::get_limb_techs() const
@@ -2255,7 +2255,7 @@ std::set<matec_id> Character::get_limb_techs() const
 int Character::get_working_arm_count() const
 {
     int limb_count = 0;
-    body_part_type::type arm_type = body_part_type::type::arm;
+    bp_type arm_type = bp_type::arm;
     for( const bodypart_id &part : get_all_body_parts_of_type( arm_type ) ) {
         // Almost broken or overencumbered arms don't count
         if( get_part( part )->get_limb_score( *this,
@@ -2273,7 +2273,7 @@ bool Character::enough_working_legs() const
     int limb_count = 0;
     int working_limb_count = 0;
     for( const bodypart_id &part : get_all_body_parts() ) {
-        if( part->primary_limb_type() == body_part_type::type::leg ) {
+        if( part->primary_limb_type() == bp_type::leg ) {
             limb_count++;
             if( !is_limb_broken( part ) ) {
                 working_limb_count++;
@@ -2289,7 +2289,7 @@ int Character::get_working_leg_count() const
 {
     int working_limb_count = 0;
     for( const bodypart_id &part : get_all_body_parts() ) {
-        if( part->primary_limb_type() == body_part_type::type::leg ) {
+        if( part->primary_limb_type() == bp_type::leg ) {
             if( !is_limb_broken( part ) ) {
                 working_limb_count++;
             }
@@ -4219,7 +4219,7 @@ int layer_details::layer( const int encumbrance, bool conflicts )
     return total - current;
 }
 
-int Character::avg_encumb_of_limb_type( body_part_type::type part_type ) const
+int Character::avg_encumb_of_limb_type( bp_type part_type ) const
 {
     float limb_encumb = 0.0f;
     int num_limbs = 0;
@@ -5801,7 +5801,7 @@ bool Character::check_immunity_data( const field_immunity_data &ft ) const
         }
     }
     bool immune_by_body_part_resistance = !ft.immunity_data_body_part_env_resistance.empty();
-    for( const std::pair<body_part_type::type, int> &fide :
+    for( const std::pair<bp_type, int> &fide :
          ft.immunity_data_body_part_env_resistance ) {
         for( const bodypart_id &bp : get_all_body_parts_of_type( fide.first ) ) {
             if( get_env_resist( bp ) < fide.second ) {
@@ -5818,7 +5818,7 @@ bool Character::check_immunity_data( const field_immunity_data &ft ) const
 
     bool immune_by_worn_flags = !ft.immunity_data_part_item_flags.empty();
     // Check if all worn flags are fulfilled
-    for( const std::pair<body_part_type::type, flag_id> &fide :
+    for( const std::pair<bp_type, flag_id> &fide :
          ft.immunity_data_part_item_flags ) {
         for( const bodypart_id &bp : get_all_body_parts_of_type( fide.first ) ) {
             if( !worn_with_flag( fide.second, bp ) ) {
@@ -5835,7 +5835,7 @@ bool Character::check_immunity_data( const field_immunity_data &ft ) const
     }
 
     // Check if the optional worn flags are fulfilled
-    for( const std::pair<body_part_type::type, flag_id> &fide :
+    for( const std::pair<bp_type, flag_id> &fide :
          ft.immunity_data_part_item_flags_any ) {
         for( const bodypart_id &bp : get_all_body_parts_of_type( fide.first ) ) {
             if( worn_with_flag( fide.second, bp ) ) {
@@ -6894,7 +6894,7 @@ void Character::recalc_limb_energy_usage()
     float total_limb_count = 0.0f;
     float bionic_limb_count = 0.0f;
     float bionic_powercost = 0;
-    body_part_type::type arm_type = body_part_type::type::arm;
+    bp_type arm_type = bp_type::arm;
     for( const bodypart_id &bp : get_all_body_parts_of_type( arm_type ) ) {
         total_limb_count++;
         if( bp->has_flag( json_flag_BIONIC_LIMB ) ) {
@@ -6919,7 +6919,7 @@ void Character::recalc_limb_energy_usage()
     total_limb_count = 0.0f;
     bionic_limb_count = 0.0f;
     bionic_powercost = 0;
-    body_part_type::type leg_type = body_part_type::type::leg;
+    bp_type leg_type = bp_type::leg;
     for( const bodypart_id &bp : get_all_body_parts_of_type( leg_type ) ) {
         total_limb_count++;
         if( bp->has_flag( json_flag_BIONIC_LIMB ) ) {
@@ -7324,8 +7324,8 @@ int Character::item_handling_cost( const item &it, bool penalties, int base_cost
         // Grabbed penalty scales for grabbed arms/hands
         int pen = 2;
         for( const effect &eff : get_effects_with_flag( json_flag_GRAB ) ) {
-            if( eff.get_bp()->primary_limb_type() == body_part_type::type::arm ||
-                eff.get_bp()->primary_limb_type() == body_part_type::type::hand ) {
+            if( eff.get_bp()->primary_limb_type() == bp_type::arm ||
+                eff.get_bp()->primary_limb_type() == bp_type::hand ) {
                 pen++;
             }
         }
@@ -7336,12 +7336,12 @@ int Character::item_handling_cost( const item &it, bool penalties, int base_cost
     if( !bulk_cost ) {
         // For single handed items use the least encumbered hand
         if( it.is_two_handed( *this ) ) {
-            for( const bodypart_id &part : get_all_body_parts_of_type( body_part_type::type::hand ) ) {
+            for( const bodypart_id &part : get_all_body_parts_of_type( bp_type::hand ) ) {
                 mv += encumb( part );
             }
         } else {
             int min_encumb = INT_MAX;
-            for( const bodypart_id &part : get_all_body_parts_of_type( body_part_type::type::hand ) ) {
+            for( const bodypart_id &part : get_all_body_parts_of_type( bp_type::hand ) ) {
                 min_encumb = std::min( min_encumb, encumb( part ) );
             }
             mv += min_encumb;
@@ -13696,8 +13696,8 @@ bodypart_id Character::most_staunchable_bp( int &max_staunch )
         add_msg_debug( debugmode::DF_CHARACTER, "Wound care proficiency found, new limit %d", max_staunch );
     }
 
-    int num_broken_arms = get_num_broken_body_parts_of_type( body_part_type::type::arm );
-    int num_arms = get_num_body_parts_of_type( body_part_type::type::arm );
+    int num_broken_arms = get_num_broken_body_parts_of_type( bp_type::arm );
+    int num_arms = get_num_body_parts_of_type( bp_type::arm );
 
     // Don't warn about encumbrance if your arms are broken
     if( num_broken_arms ) {
@@ -13713,7 +13713,7 @@ bodypart_id Character::most_staunchable_bp( int &max_staunch )
     for( const bodypart_id &bp : get_all_body_parts() ) {
         intensity = get_effect_int( effect_bleed, bp );
         // Staunching a bleeding on one of your arms is hard (handle multiple arms)
-        if( bp->has_type( body_part_type::type::arm ) ) {
+        if( bp->has_type( bp_type::arm ) ) {
             intensity /= ( 1.0f - 1.0f / num_arms );
         }
         // Tourniquets make staunching easier, letting you treat arterial bleeds on your legs
@@ -13791,7 +13791,7 @@ void Character::pause()
         bodypart_id bp_id = most_staunchable_bp( max );
 
         // Don't warn about encumbrance if your arms are broken
-        int num_broken_arms = get_num_broken_body_parts_of_type( body_part_type::type::arm );
+        int num_broken_arms = get_num_broken_body_parts_of_type( bp_type::arm );
         if( num_broken_arms ) {
             add_msg_player_or_npc( m_warning,
                                    _( "Your broken limb significantly hampers your efforts to put pressure on a bleeding wound!" ),

src/character.h

@@ -992,7 +992,7 @@ class Character : public Creature, public visitable
 
         /** Returns ENC provided by armor, etc. */
         int encumb( const bodypart_id &bp ) const;
-        int avg_encumb_of_limb_type( body_part_type::type part_type ) const;
+        int avg_encumb_of_limb_type( bp_type part_type ) const;
 
         /** Returns body weight plus weight of inventory and worn/wielded items */
         units::mass get_weight() const override;
@@ -1511,10 +1511,10 @@ class Character : public Creature, public visitable
         // Get the specified limb score. If bp is defined, only the scores from that body part type are summed.
         // override forces the limb score to be affected by encumbrance/wounds (-1 == no override).
         float get_limb_score( const limb_score_id &score,
-                              const body_part_type::type &bp = body_part_type::type::num_types,
+                              const bp_type &bp = bp_type::num_types,
                               int override_encumb = -1, int override_wounds = -1 ) const;
         float manipulator_score( const std::map<bodypart_str_id, bodypart> &body,
-                                 body_part_type::type type, int override_encumb, int override_wounds ) const;
+                                 bp_type type, int override_encumb, int override_wounds ) const;
 
         bool has_min_manipulators() const;
         // technically this is "has more than one arm"

src/character_attire.cpp

@@ -650,7 +650,7 @@ bool Character::is_wearing_shoes( const side &check_side ) const
 
     for( const bodypart_id &part : get_all_body_parts() ) {
         // Is any right|left foot...
-        if( !part->has_type( body_part_type::type::foot ) ) {
+        if( !part->has_type( bp_type::foot ) ) {
             continue;
         }
         side_covered = worn.is_wearing_shoes( part );