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 player_t::has_absorb() and current_absorb_amount() helpers
(scoped to enemy actors) plus a target.has_absorb expression for APL
queries.

Author: mat-simon

engine/action/action.cpp

@@ -2133,20 +2133,27 @@ 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 );
 
+  // When the target is an enemy with absorbs, attacker attribution should
+  // reflect pre-absorb damage: the player rolled it; a shield consuming some
+  // shouldn't undercount their DPS.
+  double credited_amount = state->result_amount;
+  if ( state->target && state->target->is_enemy() && state->self_absorb_amount > 0 )
+    credited_amount += state->self_absorb_amount;
+
   // 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 +2165,11 @@ 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() && data->self_absorb_amount > 0 )
+    credited_amount += data->self_absorb_amount;
+
+  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/player/player.cpp

@@ -5888,6 +5888,31 @@ double player_t::composite_player_absorb_received_multiplier() const
   return current.absorb_received_multiplier;
 }
 
+bool player_t::has_absorb() const
+{
+  // Scoped to enemy actors. Player-side absorb subtypes (fractional, per-event-
+  // limited, total-limited) aren't faithfully represented by a naive iteration
+  // over absorb_buff_list, so this query intentionally only reports for enemies
+  // where raid_event=shield places simple absorb_buff_t entries.
+  if ( !is_enemy() )
+    return false;
+  for ( const absorb_buff_t* ab : absorb_buff_list )
+    if ( ab->check() )
+      return true;
+  return false;
+}
+
+double player_t::current_absorb_amount() const
+{
+  if ( !is_enemy() )
+    return 0;
+  double total = 0;
+  for ( const absorb_buff_t* ab : absorb_buff_list )
+    if ( ab->check() )
+      total += ab->current_value;
+  return total;
+}
+
 double player_t::composite_player_target_crit_chance( player_t* t ) const
 {
   double c = 0.0;
@@ -12090,6 +12115,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* );
+
+  bool has_absorb() const;
+  double current_absorb_amount() const;
+
   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,99 @@ 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;
+  // Each shield event owns its own absorb_buff_t so overlapping shields stack;
+  // instance_id seeds a unique buff name for buff_t::find lookups.
+  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 )
+  {
+    // Use the event's position in sim->raid_events for the unique-name id.
+    // This is consistent across sim_t clones (each thread parses
+    // raid_events_str in the same order) so cross-thread stat merging
+    // aggregates correctly. Could be replaced with raid_event_t::internal_id
+    // if that becomes a framework-provided field.
+    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 );
+    }
+
+    // amount unspecified => unbreakable for the window. infinity sentinel
+    // avoids consume()-driven expiry; _finish() drops it on window close.
+    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 +2398,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" )