Merge pull request #54672 from mqrause/close_enemy_interruption

Fix activities not getting interrupted by dangerously close enemies

Author: kevingranade

src/activity_actor.cpp

@@ -21,7 +21,6 @@
 #include "avatar.h"
 #include "avatar_action.h"
 #include "bodypart.h"
-#include "calendar.h"
 #include "character.h"
 #include "coordinates.h"
 #include "contents_change_handler.h"
@@ -469,7 +468,7 @@ void aim_activity_actor::unload_RAS_weapon()
     }
 }
 
-void autodrive_activity_actor::start( player_activity &act, Character &who )
+void autodrive_activity_actor::start( player_activity &, Character &who )
 {
     const bool in_vehicle = who.in_vehicle && who.controlling_vehicle;
     const optional_vpart_position vp = get_map().veh_at( who.pos() );
@@ -480,7 +479,6 @@ void autodrive_activity_actor::start( player_activity &act, Character &who )
 
     player_vehicle = &vp->vehicle();
     player_vehicle->is_autodriving = true;
-    act.moves_left = calendar::INDEFINITELY_LONG;
 }
 
 void autodrive_activity_actor::do_turn( player_activity &act, Character &who )
@@ -2577,7 +2575,7 @@ std::unique_ptr<activity_actor> open_gate_activity_actor::deserialize( JsonValue
 
 void consume_activity_actor::start( player_activity &act, Character &guy )
 {
-    int moves;
+    int moves = 0;
     Character &player_character = get_player_character();
     if( consume_location ) {
         ret_val<edible_rating> ret = ret_val<edible_rating>::make_success();
@@ -2592,9 +2590,9 @@ void consume_activity_actor::start( player_activity &act, Character &guy )
             consume_menu_selections = std::vector<int>();
             consume_menu_selected_items.clear();
             consume_menu_filter.clear();
-            return;
+        } else {
+            moves = to_moves<int>( guy.get_consume_time( *consume_location ) );
         }
-        moves = to_moves<int>( guy.get_consume_time( *consume_location ) );
     } else if( !consume_item.is_null() ) {
         ret_val<edible_rating> ret = ret_val<edible_rating>::make_success();
         if( refuel ) {
@@ -2607,13 +2605,12 @@ void consume_activity_actor::start( player_activity &act, Character &guy )
             consume_menu_selections = std::vector<int>();
             consume_menu_selected_items.clear();
             consume_menu_filter.clear();
-            return;
+        } else {
+            moves = to_moves<int>( guy.get_consume_time( consume_item ) );
         }
-        moves = to_moves<int>( guy.get_consume_time( consume_item ) );
     } else {
         debugmsg( "Item/location to be consumed should not be null." );
         canceled = true;
-        return;
     }
 
     act.moves_total = moves;
@@ -3043,7 +3040,6 @@ void craft_activity_actor::start( player_activity &act, Character &crafter )
     if( !check_if_craft_okay( craft_item, crafter ) ) {
         act.set_to_null();
     }
-    act.moves_left = calendar::INDEFINITELY_LONG;
     activity_override = craft_item.get_item()->get_making().exertion_level();
     cached_crafting_speed = 0;
 }
@@ -4443,7 +4439,6 @@ void disassemble_activity_actor::start( player_activity &act, Character &who )
     // Mark the item, not available for other characters
     target->set_var( "activity_var", who.name );
 
-    act.moves_left = calendar::INDEFINITELY_LONG;
     activity_override = target->get_making().exertion_level();
 }
 
@@ -5804,6 +5799,10 @@ std::unique_ptr<activity_actor> forage_activity_actor::deserialize( JsonValue &j
 void longsalvage_activity_actor::start( player_activity &act, Character & )
 {
     act.index = index;
+
+    //todo: refactor the actor to process items in ::do_turn, then remove setting the moves to 0
+    //this currently still can't get interrupted before you get attacked
+    act.moves_left = 0;
 }
 
 void longsalvage_activity_actor::finish( player_activity &act, Character &who )

src/activity_actor_definitions.h

@@ -117,7 +117,7 @@ class autodrive_activity_actor : public activity_actor
             return activity_id( "ACT_AUTODRIVE" );
         }
 
-        void start( player_activity &act, Character & ) override;
+        void start( player_activity &, Character & ) override;
         void do_turn( player_activity &, Character & ) override;
         void canceled( player_activity &, Character & ) override;
         void finish( player_activity &act, Character & ) override;

src/do_turn.cpp

@@ -8,7 +8,6 @@
 #include "creature_tracker.h"
 #include "event_bus.h"
 #include "explosion.h"
-#include "field.h"
 #include "game.h"
 #include "gamemode.h"
 #include "help.h"
@@ -35,7 +34,6 @@
 #include "wcwidth.h"
 #include "worldfactory.h"
 
-static const activity_id ACT_AIM( "ACT_AIM" );
 static const activity_id ACT_AUTODRIVE( "ACT_AUTODRIVE" );
 static const activity_id ACT_OPERATION( "ACT_OPERATION" );
 
@@ -729,32 +727,13 @@ bool do_turn()
             // If player is performing a task, a monster is dangerously close,
             // and monster can reach to the player or it has some sort of a ranged attack,
             // warn them regardless of previous safemode warnings
-            if( u.activity && !u.has_activity( ACT_AIM ) &&
-                u.activity.moves_left > 0 &&
-                !u.activity.is_distraction_ignored( distraction_type::hostile_spotted_near ) ) {
-                Creature *hostile_critter = g->is_hostile_very_close( true );
-
-                if( hostile_critter != nullptr ) {
-                    g->cancel_activity_or_ignore_query( distraction_type::hostile_spotted_near,
-                                                        string_format( _( "The %s is dangerously close!" ),
-                                                                hostile_critter->get_name() ) );
-                }
-            }
-
-            if( u.activity && !u.has_activity( ACT_AIM ) && u.activity.moves_left > 0 &&
-                !u.activity.is_distraction_ignored( distraction_type::dangerous_field ) ) {
-                for( const std::pair<const field_type_id, field_entry> &field : m.field_at( u.pos() ) ) {
-                    if( u.is_dangerous_field( field.second ) ) {
-                        if( g->cancel_activity_or_ignore_query( distraction_type::dangerous_field,
-                                                                string_format( _( "You stand in %s!" ),
-                                                                        field.second.name() ) ) ||
-                            u.activity.is_distraction_ignored( distraction_type::dangerous_field ) ) {
-                            break;
-                        }
+            if( u.activity ) {
+                for( std::pair<const distraction_type, std::string> &dist : u.activity.get_distractions() ) {
+                    if( g->cancel_activity_or_ignore_query( dist.first, dist.second ) ) {
+                        break;
                     }
                 }
             }
-
         }
     }
 

src/game.cpp

@@ -3855,6 +3855,18 @@ Creature *game::is_hostile_within( int distance, bool dangerous )
     return nullptr;
 }
 
+field_entry *game::is_in_dangerous_field()
+{
+    map &here = get_map();
+    for( std::pair<const field_type_id, field_entry> &field : here.field_at( u.pos() ) ) {
+        if( u.is_dangerous_field( field.second ) ) {
+            return &field.second;
+        }
+    }
+
+    return nullptr;
+}
+
 std::unordered_set<tripoint> game::get_fishable_locations( int distance, const tripoint &fish_pos )
 {
     // We're going to get the contiguous fishable terrain starting at

src/game.h

@@ -559,6 +559,7 @@ class game
         character_id assign_npc_id();
         Creature *is_hostile_nearby();
         Creature *is_hostile_very_close( bool dangerous = false );
+        field_entry *is_in_dangerous_field();
         // Handles shifting coordinates transparently when moving between submaps.
         // Helper to make calling with a player pointer less verbose.
         point update_map( Character &p, bool z_level_changed = false );

src/player_activity.cpp

@@ -10,6 +10,8 @@
 #include "calendar.h"
 #include "character.h"
 #include "construction.h"
+#include "field.h"
+#include "game.h"
 #include "item.h"
 #include "itype.h"
 #include "map.h"
@@ -464,3 +466,28 @@ void player_activity::inherit_distractions( const player_activity &other )
         ignore_distraction( type );
     }
 }
+
+
+std::map<distraction_type, std::string> player_activity::get_distractions()
+{
+    std::map < distraction_type, std::string > res;
+    if( id() != ACT_AIM && moves_left > 0 ) {
+        if( !is_distraction_ignored( distraction_type::hostile_spotted_near ) ) {
+            Creature *hostile_critter = g->is_hostile_very_close( true );
+            if( hostile_critter != nullptr ) {
+                res.emplace( distraction_type::hostile_spotted_near,
+                             string_format( _( "The %s is dangerously close!" ),
+                                            g->is_hostile_very_close( true )->get_name() ) );
+            }
+        }
+        if( !is_distraction_ignored( distraction_type::dangerous_field ) ) {
+            field_entry *field = g->is_in_dangerous_field();
+            if( field != nullptr ) {
+                res.emplace( distraction_type::dangerous_field, string_format( _( "You stand in %s!" ),
+                             g->is_in_dangerous_field()->name() ) );
+            }
+        }
+    }
+
+    return res;
+}

src/player_activity.h

@@ -11,6 +11,7 @@
 #include <vector>
 
 #include "activity_actor.h"
+#include "calendar.h"
 #include "clone_ptr.h"
 #include "compatibility.h"
 #include "enums.h"
@@ -41,7 +42,7 @@ class player_activity
         /** Total number of moves required to complete the activity */
         int moves_total = 0;
         /** The number of moves remaining in this activity before it is complete. */
-        int moves_left = 0;
+        int moves_left = calendar::INDEFINITELY_LONG;
         /** Controls whether this activity can be cancelled at all */
         bool interruptable = true;
         /** Controls whether this activity can be cancelled with 'pause' action */
@@ -177,6 +178,8 @@ class player_activity
         bool do_drop_invalid_inventory() const {
             return !actor || actor->do_drop_invalid_inventory();
         }
+
+        std::map<distraction_type, std::string> get_distractions();
 };
 
 #endif // CATA_SRC_PLAYER_ACTIVITY_H

tests/monster_helpers.cpp

@@ -0,0 +1,13 @@
+#include "monster_helpers.h"
+
+#include "item.h"
+#include "monster.h"
+
+void move_monster_turn( monster &mon )
+{
+    const int moves = mon.get_speed();
+    mon.mod_moves( moves );
+    while( mon.get_moves() > 0 ) {
+        mon.move();
+    }
+}

tests/monster_helpers.h

@@ -0,0 +1,9 @@
+#pragma once
+#ifndef CATA_TESTS_MONSTER_HELPERS_H
+#define CATA_TESTS_MONSTER_HELPERS_H
+
+class monster;
+
+void move_monster_turn( monster &mon );
+
+#endif // CATA_TESTS_MONSTER_HELPERS_H