Opportunity attacks

Instead of triggering attacks when monsters move next to the player,
fire em when the player moves away from monsters. No energy cost for
this one, except for stuff like juggernauts and ogres. Intended to
reduce impact on combat generally.

Author: PleasingFungus

crawl-ref/source/mon-act.cc

@@ -3129,37 +3129,12 @@ static bool _monster_swaps_places(monster* mon, const coord_def& delta)
     return false;
 }
 
-static void _mons_closing_attack(monster& mons, coord_def delta)
+void mon_maybe_attack_you(monster& mons)
 {
-    // XXX: should check reach instead of a fixed distance 1?
-    if (mons.confused() || mons_is_batty(mons) || mons.foe_distance() > 1)
+    monster *ru_target = nullptr;
+    if (_handle_ru_melee_redirection(mons, &ru_target))
         return;
-    if (!one_chance_in(6))
-        return;
-    actor* foe = mons.get_foe();
-    ASSERT(foe); // else, how is foe distance <= 0?
-    if (!mons.can_see(*foe))
-        return;
-    coord_def old_pos = mons.pos() - delta;
-    if (adjacent(old_pos, foe->pos()))
-        return;
-
-
-    const string name = foe->name(DESC_THE);
-    const string msg = make_stringf(" attacks %s as %s move%s adjacent!",
-                                    name.c_str(),
-                                    mons.pronoun(PRONOUN_SUBJECTIVE).c_str(),
-                                    mons.pronoun_plurality() ? "" : "s");
-    simple_monster_message(mons, msg.c_str());
-
-    if (foe->is_player())
-    {
-        monster *ru_target = nullptr;
-        if (_handle_ru_melee_redirection(mons, &ru_target))
-            return;
-        _melee_attack_player(mons, ru_target);
-    } else
-        fight_melee(&mons, foe);
+    _melee_attack_player(mons, ru_target);
 }
 
 static bool _do_move_monster(monster& mons, const coord_def& delta)
@@ -3288,7 +3263,6 @@ static bool _do_move_monster(monster& mons, const coord_def& delta)
     _handle_manticore_barbs(mons);
 
     _swim_or_move_energy(mons);
-    _mons_closing_attack(mons, delta);
 
     return true;
 }

crawl-ref/source/mon-act.h

@@ -36,4 +36,6 @@ void handle_monster_move(monster* mon);
 
 void queue_monster_for_action(monster* mons);
 
+void mon_maybe_attack_you(monster &mon);
+
 #define ENERGY_SUBMERGE(entry) (max(entry->energy_usage.swim / 2, 1))

crawl-ref/source/movement.cc

@@ -229,6 +229,45 @@ static void _clear_constriction_data()
         you.stop_being_constricted();
 }
 
+static void _trigger_opportunity_attacks(coord_def new_pos)
+{
+    for (adjacent_iterator ai(you.pos()); ai; ++ai)
+    {
+        monster* mon = monster_at(*ai);
+        // No, there is no logic to this ordering (pf):
+        if (!mon
+            || mon->wont_attack()
+            || !mons_has_attacks(*mon)
+            || adjacent(new_pos, mon->pos())
+            || mon->confused()
+            || !mon->can_see(you)
+            || !one_chance_in(5))
+        {
+            continue;
+        }
+        actor* foe = mon->get_foe();
+        if (!foe || !foe->is_player())
+            continue;
+
+        simple_monster_message(*mon, " attacks as you move away!");
+        const int old_energy = mon->speed_increment;
+        mon_maybe_attack_you(*mon);
+        // Refund up to 100 energy (1 turn) from the attack.
+        // Thus, only slow attacking monsters use energy for these.
+        mon->speed_increment = min(mon->speed_increment + 100, old_energy);
+
+        if (you.pending_revival)
+            return;
+    }
+}
+
+static void _apply_pre_move_effects(coord_def new_pos)
+{
+    remove_water_hold();
+    _clear_constriction_data();
+    _trigger_opportunity_attacks(new_pos);
+}
+
 bool apply_cloud_trail(const coord_def old_pos)
 {
     if (you.duration[DUR_CLOUD_TRAIL])
@@ -687,10 +726,6 @@ static spret _rampage_forward(coord_def move)
     }
 
     // We've passed the validity checks, go ahead and rampage.
-
-    // First, apply any necessary pre-move effects:
-    remove_water_hold();
-    _clear_constriction_data();
     const coord_def old_pos = you.pos();
 
     clear_messages();
@@ -709,6 +744,11 @@ static spret _rampage_forward(coord_def move)
              valid_target->name(DESC_THE, true).c_str());
     }
 
+    // First, apply any necessary pre-move effects:
+    _apply_pre_move_effects(beam.target);
+    if (you.pending_revival) // died to opportunity attack
+        return spret::success;
+
     // stepped = true, we're flavouring this as movement, not a blink.
     move_player_to_grid(beam.target, true);
 
@@ -1074,8 +1114,9 @@ void move_player_action(coord_def move)
         // when confusion causes no move.
         if (you.pos() != targ && targ_pass)
         {
-            remove_water_hold();
-            _clear_constriction_data();
+            _apply_pre_move_effects(targ);
+            if (you.pending_revival) // died to opportunity attack
+                return;
             move_player_to_grid(targ, true);
             apply_barbs_damage();
             remove_ice_movement();