Add raid_events=shield + non-mutating absorb pipeline for enemies

A new `shield` raid event puts an absorb buff on a target enemy
(target=, amount=, school= options plus standard timing controls).

To support this without breaking class on-hit triggers,
account_absorb_buffs no longer mutates s->result_amount when the
target is an enemy. The absorbed amount is tracked via
s->result_absorbed (already the HP-impact field) and applied at
do_damage time. Player-side behavior is unchanged.

Also adds player_t::has_absorb() and current_absorb_amount() helpers.

Author: mat-simon

engine/player/player.cpp

@@ -5888,6 +5888,23 @@ double player_t::composite_player_absorb_received_multiplier() const
   return current.absorb_received_multiplier;
 }
 
+bool player_t::has_absorb() const
+{
+  for ( const absorb_buff_t* ab : absorb_buff_list )
+    if ( ab->check() )
+      return true;
+  return false;
+}
+
+double player_t::current_absorb_amount() const
+{
+  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;
@@ -8481,6 +8498,12 @@ void account_absorb_buffs( player_t& p, action_state_t* s, school_e school )
 
   */
 
+  // Captured before the absorb iteration mutates s->result_amount. For enemy
+  // targets we restore this value at the end so attacker stats and on-hit gates
+  // (e.g., "if result_amount > 0") see pre-absorb damage. HP impact is tracked
+  // via s->result_absorbed and applied in do_damage().
+  double pre_absorb_amount = s->result_amount;
+
   if ( !( p.absorb_buff_list.empty() && p.instant_absorb_list.empty() ) )
   {
     /* First, handle high priority absorbs and instant absorbs. These absorbs should
@@ -8607,6 +8630,9 @@ void account_absorb_buffs( player_t& p, action_state_t* s, school_e school )
   p.iteration_absorb_taken += s->self_absorb_amount;
 
   s->result_absorbed = s->result_amount;
+
+  if ( p.is_enemy() )
+    s->result_amount = pre_absorb_amount;
 }
 
 /**
@@ -8694,9 +8720,9 @@ void player_t::do_damage( action_state_t* incoming_state )
   collect_dmg_taken_data( *this, incoming_state,
                           incoming_state->result_mitigated - incoming_state->self_absorb_amount );
 
-  if ( incoming_state->result_amount > 0.0 )
+  if ( incoming_state->result_absorbed > 0.0 )
   {
-    actual_amount = resource_loss( RESOURCE_HEALTH, incoming_state->result_amount, nullptr, incoming_action );
+    actual_amount = resource_loss( RESOURCE_HEALTH, incoming_state->result_absorbed, nullptr, incoming_action );
   }
 
   // New callback system; proc abilities on incoming events.

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

@@ -7,6 +7,8 @@
 #include "action/action.hpp"
 #include "action/spell.hpp"
 #include "buff/buff.hpp"
+
+#include <atomic>
 #include "dbc/dbc.hpp"
 #include "player/pet.hpp"
 #include "player/player.hpp"
@@ -1667,6 +1669,95 @@ 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, util::string_view options_str )
+    : raid_event_t( s, "shield" ), amount( 0.0 ), school( SCHOOL_NONE )
+  {
+    static std::atomic<int> next_id { 0 };
+    instance_id = ++next_id;
+
+    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, util::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 +2396,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" )