Add raid_events=shield + helpers for enemy-side absorbs

A new `shield` raid event puts an absorb buff on a target enemy
(target=, amount=, school= options plus standard timing controls).
The raid event creates a real absorb_buff_t so the shield correctly
absorbs damage and influences fight termination — the encounter-
modeling use case, analogous to raid_event=vulnerable.

When a player damages an enemy with an absorb, the attacker's stats
include the absorbed portion as damage dealt (action.cpp), so DPS
attribution reflects the rolled damage rather than only the post-
absorb HP impact.

Adds has_absorb() and current_absorb_amount() (virtual on player_t,
defined for enemy_t) plus a target.has_absorb expression for APL
queries.

Author: mat-simon

engine/action/action.cpp

@@ -2133,20 +2133,30 @@ void action_t::assess_damage( result_amount_type rt, action_state_t* state )
   // Execute outbound damage assessor pipeline on the state object
   player->assessor_out_damage.execute( rt, state );
 
+  // Credit absorbed-on-enemy damage to attacker stats. (mitigated - absorbed)
+  // is per-event; self_absorb_amount would accumulate across DoT ticks.
+  double credited_amount = state->result_amount;
+  if ( state->target && state->target->is_enemy() )
+  {
+    double absorbed = state->result_mitigated - state->result_absorbed;
+    if ( absorbed > 0 )
+      credited_amount += absorbed;
+  }
+
   // TODO: Should part of this move to assessing, priority_iteration_damage for example?
   if ( state->result_raw > 0 || result_is_miss( state->result ) )
   {
     if ( sim->fight_style == FIGHT_STYLE_DUNGEON_SLICE || sim->fight_style == FIGHT_STYLE_DUNGEON_ROUTE )
     {
       if ( state->target->is_boss() )
       {
-        player->priority_iteration_dmg += state->result_amount;
+        player->priority_iteration_dmg += credited_amount;
       }
     }
     else if ( state->target == sim->target ||
               ( sim->merge_enemy_priority_dmg && state->target->is_boss() ) )
     {
-      player->priority_iteration_dmg += state->result_amount;
+      player->priority_iteration_dmg += credited_amount;
     }
 
     record_data( state );
@@ -2158,7 +2168,15 @@ void action_t::record_data( action_state_t* data )
   if ( !stats )
     return;
 
-  stats->add_result( data->result_amount, data->result_total, report_amount_type( data ), data->result,
+  double credited_amount = data->result_amount;
+  if ( data->target && data->target->is_enemy() )
+  {
+    double absorbed = data->result_mitigated - data->result_absorbed;
+    if ( absorbed > 0 )
+      credited_amount += absorbed;
+  }
+
+  stats->add_result( credited_amount, data->result_total, report_amount_type( data ), data->result,
                      ( may_block || player->position() != POSITION_BACK ) ? data->block_result : BLOCK_RESULT_UNKNOWN,
                      data->target );
 }

engine/class_modules/sc_enemy.cpp

@@ -92,6 +92,19 @@ struct enemy_t : public player_t
   void demise() override;
   double armor_coefficient( int level, tank_dummy_e diff );
   std::unique_ptr<expr_t> create_expression( util::string_view expression_str ) override;
+
+  bool has_absorb() const override
+  {
+    return range::any_of( absorb_buff_list,
+                          []( const absorb_buff_t* ab ) { return ab->check_value() > 0; } );
+  }
+
+  double current_absorb_amount() const override
+  {
+    return range::accumulate( absorb_buff_list, 0.0,
+                              []( const absorb_buff_t* ab ) { return ab->check_value(); } );
+  }
+
   timespan_t available() const override
   {
     return waiting_time;

engine/player/player.cpp

@@ -12090,6 +12090,9 @@ std::unique_ptr<expr_t> player_t::create_expression( util::string_view expressio
   if ( expression_str == "is_enemy" )
     return expr_t::create_constant( "is_enemy", is_enemy() );
 
+  if ( expression_str == "has_absorb" )
+    return make_fn_expr( expression_str, [ this ] { return has_absorb() ? 1.0 : 0.0; } );
+
   if ( expression_str == "attack_haste" )
     return make_fn_expr( expression_str, [this] { return cache.attack_haste(); } );
 

engine/player/player.hpp

@@ -1413,6 +1413,10 @@ struct player_t : public actor_t
   virtual void assess_damage_imminent_pre_absorb( school_e, result_amount_type, action_state_t* );
   virtual void assess_damage_imminent( school_e, result_amount_type, action_state_t* );
   virtual void do_damage( action_state_t* );
+
+  virtual bool has_absorb() const { return false; }
+  virtual double current_absorb_amount() const { return 0.0; }
+
   virtual void assess_heal( school_e, result_amount_type, action_state_t* );
   virtual void trigger_callbacks( proc_types, proc_types2, action_t* action, action_state_t* state,
                                   proc_trigger_type_e pt_type = TRIGGER_ACTION );

engine/sim/raid_event.cpp

@@ -1667,6 +1667,92 @@ struct vulnerable_event_t final : public raid_event_t
   }
 };
 
+// Shield ===================================================================
+
+struct shield_event_t final : public raid_event_t
+{
+  double amount;
+  std::string school_str;
+  player_t* target = nullptr;
+  std::string target_str;
+  school_e school;
+  absorb_buff_t* buff = nullptr;
+  int instance_id;
+
+  shield_event_t( sim_t* s, std::string_view options_str )
+    : raid_event_t( s, "shield" ), amount( 0.0 ), school( SCHOOL_NONE )
+  {
+    // Position in sim->raid_events; consistent across sim_t clones.
+    instance_id = static_cast<int>( s->raid_events.size() );
+
+    add_option( opt_float( "amount", amount ) );
+    add_option( opt_string( "school", school_str ) );
+
+    if ( sim->fight_style == FIGHT_STYLE_DUNGEON_ROUTE )
+      add_option( opt_string( "target", target_str ) );
+    else
+      add_option( opt_func( "target", [ this ]( auto, auto, std::string_view v ) { return parse_target( v ); } ) );
+
+    parse_options( options_str );
+
+    if ( sim->fight_style == FIGHT_STYLE_DUNGEON_ROUTE )
+      target_str = "Pull_" + util::to_string( pull ) + "_" + target_str;
+
+    if ( !school_str.empty() )
+    {
+      school = util::parse_school_type( school_str );
+      if ( school == SCHOOL_NONE )
+        throw std::invalid_argument( fmt::format( "Unknown shield raid event school '{}'", school_str ) );
+    }
+  }
+
+  bool parse_target( std::string_view value )
+  {
+    auto it = range::find_if( sim->target_list, [ &value ]( const player_t* t ) {
+      return util::str_compare_ci( value, t->name() );
+    } );
+
+    if ( it != sim->target_list.end() )
+    {
+      target = *it;
+      return true;
+    }
+    sim->error( "Unknown shield raid event target '{}'", value );
+    return true;
+  }
+
+  void _start() override
+  {
+    if ( !buff )
+    {
+      if ( sim->fight_style == FIGHT_STYLE_DUNGEON_ROUTE )
+      {
+        target = sim->find_player( target_str );
+        if ( !target )
+          throw std::invalid_argument( fmt::format( "Unknown shield raid event target '{}'", target_str ) );
+      }
+      else if ( !target )
+      {
+        target = sim->target;
+      }
+
+      buff = make_buff<absorb_buff_t>( target, fmt::format( "raid_event_shield_{}", instance_id ) );
+      if ( school != SCHOOL_NONE )
+        buff->set_absorb_school( school );
+    }
+
+    // No amount => unbreakable; infinity makes consume() never reduce to 0.
+    double value = amount > 0 ? amount : std::numeric_limits<double>::infinity();
+    buff->trigger( 1, value, -1.0, timespan_t::max() );
+  }
+
+  void _finish() override
+  {
+    if ( buff )
+      buff->expire();
+  }
+};
+
 // Position Switch ==========================================================
 
 struct position_event_t : public raid_event_t
@@ -2305,6 +2391,8 @@ std::unique_ptr<raid_event_t> raid_event_t::create( sim_t* sim, util::string_vie
     return std::unique_ptr<raid_event_t>( new stun_event_t( sim, options_str ) );
   if ( name == "vulnerable" )
     return std::unique_ptr<raid_event_t>( new vulnerable_event_t( sim, options_str ) );
+  if ( name == "shield" )
+    return std::unique_ptr<raid_event_t>( new shield_event_t( sim, options_str ) );
   if ( name == "position_switch" )
     return std::unique_ptr<raid_event_t>( new position_event_t( sim, options_str ) );
   if ( name == "flying" )