Adds an onUnitAction event

docs/Lua API.rst

@@ -4406,6 +4406,10 @@ These events are straight from EventManager module. Each of them first needs to
 
     Called when a unit uses an interaction on another.
 
+14. ``onUnitAction(unit_id, action, action_id)``
+
+    Called when a unit does an action (movement, attacking, talking and so on).
+
 Functions
 ---------
 

docs/changelog.txt

@@ -47,6 +47,7 @@ changelog.txt uses a syntax similar to RST, with a few special sequences:
 - `EventManager`: add new event type ``JOB_STARTED``, triggered when a job first gains a worker
 - `EventManager`: add new event type ``NEW_UNIT_ACTIVE``, triggered when a new unit appears on the active list
 - `EventManager`: now each registered handler for an event can have its own frequency instead of all handlers using the lowest frequency of all handlers
+- `EventManager`: add new event type ``UNIT_ACTION``, triggered when a unit starts an action
 - `stocks`: allow search terms to match the full item label, even when the label is truncated for length
 - `dfhack-examples-guide`: add mugs to ``basic`` manager orders
 - `gui/create-item`: Added "(chain)" annotation text for armours with the [CHAIN_METAL_TEXT] flag set

library/include/modules/EventManager.h

@@ -37,6 +37,7 @@ namespace DFHack {
                 UNIT_ATTACK,
                 UNLOAD,
                 INTERACTION,
+                UNIT_ACTION,
                 EVENT_MAX
             };
         }
@@ -95,6 +96,12 @@ namespace DFHack {
             int32_t defendReport;
         };
 
+        struct ActionData {
+            int32_t unitId;
+            df::unit_action* action;
+            int32_t actionId;
+        };
+
         DFHACK_EXPORT void registerListener(EventType::EventType e, EventHandler handler, Plugin* plugin);
         DFHACK_EXPORT int32_t registerTick(EventHandler handler, int32_t when, Plugin* plugin, bool absolute=false);
         DFHACK_EXPORT void unregister(EventType::EventType e, EventHandler handler, Plugin* plugin);

library/modules/EventManager.cpp

@@ -28,6 +28,7 @@
 #include "df/report.h"
 #include "df/ui.h"
 #include "df/unit.h"
+#include "df/unit_action.h"
 #include "df/unit_flags1.h"
 #include "df/unit_inventory_item.h"
 #include "df/unit_report_type.h"
@@ -137,6 +138,7 @@ static void manageReportEvent(color_ostream& out);
 static void manageUnitAttackEvent(color_ostream& out);
 static void manageUnloadEvent(color_ostream& out){};
 static void manageInteractionEvent(color_ostream& out);
+static void manageActionEvent(color_ostream& out);
 
 typedef void (*eventManager_t)(color_ostream&);
 
@@ -157,6 +159,7 @@ static const eventManager_t eventManager[] = {
         manageUnitAttackEvent,
         manageUnloadEvent,
         manageInteractionEvent,
+        manageActionEvent,
 };
 
 //job initiated
@@ -200,6 +203,9 @@ static int32_t reportToRelevantUnitsTime = -1;
 //interaction
 static int32_t lastReportInteraction;
 
+//unit action
+static std::map<int32_t,std::vector<int32_t> > unitToKnownActions;
+
 void DFHack::EventManager::onStateChange(color_ostream& out, state_change_event event) {
     static bool doOnce = false;
 //    const string eventNames[] = {"world loaded", "world unloaded", "map loaded", "map unloaded", "viewscreen changed", "core initialized", "begin unload", "paused", "unpaused"};
@@ -222,6 +228,7 @@ void DFHack::EventManager::onStateChange(color_ostream& out, state_change_event
         buildings.clear();
         constructions.clear();
         equipmentLog.clear();
+        unitToKnownActions.clear();
 
         Buildings::clearBuildings(out);
         lastReport = -1;
@@ -1254,3 +1261,32 @@ static void manageInteractionEvent(color_ostream& out) {
         //TODO: deduce attacker from latest defend event first
     }
 }
+
+static void manageActionEvent(color_ostream& out) {
+    if (!df::global::world)
+        return;
+    multimap<Plugin*,EventHandler> copy(handlers[EventType::UNIT_ACTION].begin(), handlers[EventType::UNIT_ACTION].end());
+    for ( size_t a = 0; a < df::global::world->units.all.size(); a++ ) {
+        df::unit* unit = df::global::world->units.all[a];
+        if ( Units::isActive(unit) ) {
+            auto knownActions = &unitToKnownActions[unit->id];
+            for ( df::unit_action* action : unit->actions ) {
+                if ( action->type != df::unit_action_type::None) {
+                    if ( std::find(knownActions->begin(), knownActions->end(), action->id) == knownActions->end() ) {
+                        knownActions->push_back(action->id);
+                        for ( auto b = copy.begin(); b != copy.end(); b++ ) {
+                            EventHandler handle = (*b).second;
+                            ActionData data = {unit->id, action, action->id};
+                            handle.eventHandler(out, (void*)&data);
+                        }
+                    }
+                } else {
+                    auto newEnd = std::remove(knownActions->begin(), knownActions->end(), action->id);
+                    knownActions->erase(newEnd, knownActions->end());
+                }
+            }
+        } else {
+            unitToKnownActions.erase(unit->id);
+        }
+    }
+}

plugins/eventful.cpp

@@ -20,6 +20,7 @@
 #include "df/reaction_reagent_itemst.h"
 #include "df/reaction_product_itemst.h"
 #include "df/unit.h"
+#include "df/unit_action.h"
 #include "df/unit_inventory_item.h"
 #include "df/unit_wound.h"
 #include "df/world.h"
@@ -109,6 +110,7 @@ DEFINE_LUA_EVENT_NH_1(onReport, int32_t);
 DEFINE_LUA_EVENT_NH_3(onUnitAttack, int32_t, int32_t, int32_t);
 DEFINE_LUA_EVENT_NH_0(onUnload);
 DEFINE_LUA_EVENT_NH_6(onInteraction, std::string, std::string, int32_t, int32_t, int32_t, int32_t);
+DEFINE_LUA_EVENT_NH_3(onUnitAction, int32_t, df::unit_action*, int32_t);
 
 DFHACK_PLUGIN_LUA_EVENTS {
     DFHACK_LUA_EVENT(onWorkshopFillSidebarMenu),
@@ -136,6 +138,7 @@ DFHACK_PLUGIN_LUA_EVENTS {
     DFHACK_LUA_EVENT(onUnitAttack),
     DFHACK_LUA_EVENT(onUnload),
     DFHACK_LUA_EVENT(onInteraction),
+    DFHACK_LUA_EVENT(onUnitAction),
     DFHACK_LUA_END
 };
 
@@ -220,6 +223,10 @@ static void ev_mng_interaction(color_ostream& out, void* ptr) {
     EventManager::InteractionData* data = (EventManager::InteractionData*)ptr;
     onInteraction(out, data->attackVerb, data->defendVerb, data->attacker, data->defender, data->attackReport, data->defendReport);
 }
+static void ev_mng_action(color_ostream& out, void* ptr) {
+    EventManager::ActionData* data = (EventManager::ActionData*)ptr;
+    onUnitAction(out, data->unitId, data->action, data->actionId);
+}
 std::vector<int> enabledEventManagerEvents(EventManager::EventType::EVENT_MAX,-1);
 typedef void (*handler_t) (color_ostream&,void*);
 
@@ -242,6 +249,7 @@ static const handler_t eventHandlers[] = {
  ev_mng_unitAttack,
  ev_mng_unload,
  ev_mng_interaction,
+ ev_mng_action,
 };
 static void enableEvent(int evType,int freq)
 {

plugins/lua/eventful.lua

@@ -166,6 +166,7 @@ eventType=invertTable{
     "UNIT_ATTACK",
     "UNLOAD",
     "INTERACTION",
+    "UNIT_ACTION",
     "EVENT_MAX"
 }
 return _ENV