Merge branch 'eventManager' into recent

library/CMakeLists.txt

@@ -111,6 +111,7 @@ include/modules/Burrows.h
 include/modules/Constructions.h
 include/modules/Units.h
 include/modules/Engravings.h
+include/modules/EventManager.h
 include/modules/Gui.h
 include/modules/Items.h
 include/modules/Job.h
@@ -132,6 +133,7 @@ modules/Burrows.cpp
 modules/Constructions.cpp
 modules/Units.cpp
 modules/Engravings.cpp
+modules/EventManager.cpp
 modules/Gui.cpp
 modules/Items.cpp
 modules/Job.cpp

library/Core.cpp

@@ -44,6 +44,7 @@ using namespace std;
 #include "VersionInfo.h"
 #include "PluginManager.h"
 #include "ModuleFactory.h"
+#include "modules/EventManager.h"
 #include "modules/Gui.h"
 #include "modules/World.h"
 #include "modules/Graphic.h"
@@ -947,6 +948,7 @@ bool Core::Init()
     cerr << "Initializing Plugins.\n";
     // create plugin manager
     plug_mgr = new PluginManager(this);
+    plug_mgr->init(this);
     IODATA *temp = new IODATA;
     temp->core = this;
     temp->plug_mgr = plug_mgr;
@@ -1281,6 +1283,8 @@ static int buildings_timer = 0;
 
 void Core::onUpdate(color_ostream &out)
 {
+    EventManager::manageEvents(out);
+
     // convert building reagents
     if (buildings_do_onupdate && (++buildings_timer & 1))
         buildings_onUpdate(out);
@@ -1294,6 +1298,8 @@ void Core::onUpdate(color_ostream &out)
 
 void Core::onStateChange(color_ostream &out, state_change_event event)
 {
+    EventManager::onStateChange(out, event);
+
     buildings_onStateChange(out, event);
 
     plug_mgr->OnStateChange(out, event);

library/PluginManager.cpp

@@ -22,6 +22,7 @@ must not be misrepresented as being the original software.
 distribution.
 */
 
+#include "modules/EventManager.h"
 #include "Internal.h"
 #include "Core.h"
 #include "MemAccess.h"
@@ -270,6 +271,7 @@ bool Plugin::unload(color_ostream &con)
     // if we are actually loaded
     if(state == PS_LOADED)
     {
+        EventManager::unregisterAll(this);
         // notify the plugin about an attempt to shutdown
         if (plugin_onstatechange &&
             plugin_onstatechange(con, SC_BEGIN_UNLOAD) == CR_NOT_FOUND)
@@ -598,6 +600,22 @@ void Plugin::push_function(lua_State *state, LuaFunction *fn)
 }
 
 PluginManager::PluginManager(Core * core)
+{
+    cmdlist_mutex = new mutex();
+    eval_ruby = NULL;
+}
+
+PluginManager::~PluginManager()
+{
+    for(size_t i = 0; i < all_plugins.size();i++)
+    {
+        delete all_plugins[i];
+    }
+    all_plugins.clear();
+    delete cmdlist_mutex;
+}
+
+void PluginManager::init(Core * core)
 {
 #ifdef LINUX_BUILD
     string path = core->getHackPath() + "plugins/";
@@ -606,8 +624,6 @@ PluginManager::PluginManager(Core * core)
     string path = core->getHackPath() + "plugins\\";
     const string searchstr = ".plug.dll";
 #endif
-    cmdlist_mutex = new mutex();
-    eval_ruby = NULL;
     vector <string> filez;
     getdir(path, filez);
     for(size_t i = 0; i < filez.size();i++)
@@ -622,16 +638,6 @@ PluginManager::PluginManager(Core * core)
     }
 }
 
-PluginManager::~PluginManager()
-{
-    for(size_t i = 0; i < all_plugins.size();i++)
-    {
-        delete all_plugins[i];
-    }
-    all_plugins.clear();
-    delete cmdlist_mutex;
-}
-
 Plugin *PluginManager::getPluginByName (const std::string & name)
 {
     for(size_t i = 0; i < all_plugins.size(); i++)

library/include/PluginManager.h

@@ -205,6 +205,7 @@ namespace DFHack
         friend class Plugin;
         PluginManager(Core * core);
         ~PluginManager();
+        void init(Core* core);
         void OnUpdate(color_ostream &out);
         void OnStateChange(color_ostream &out, state_change_event event);
         void registerCommands( Plugin * p );

library/include/modules/Buildings.h

@@ -25,7 +25,9 @@ distribution.
 #pragma once
 #include "Export.h"
 #include "DataDefs.h"
+#include "Types.h"
 #include "df/building.h"
+#include "df/building_type.h"
 #include "df/civzone_type.h"
 #include "df/furnace_type.h"
 #include "df/workshop_type.h"
@@ -181,5 +183,8 @@ DFHACK_EXPORT bool constructWithFilters(df::building *bld, std::vector<df::job_i
  */
 DFHACK_EXPORT bool deconstruct(df::building *bld);
 
+void updateBuildings(color_ostream& out, void* ptr);
+void clearBuildings(color_ostream& out);
+
 }
 }

library/include/modules/EventManager.h

@@ -0,0 +1,60 @@
+#pragma once
+#ifndef EVENT_MANAGER_H_INCLUDED
+#define EVENT_MANAGER_H_INCLUDED
+
+#include "Core.h"
+#include "Export.h"
+#include "ColorText.h"
+#include "PluginManager.h"
+#include "Console.h"
+
+namespace DFHack {
+    namespace EventManager {
+        namespace EventType {
+            enum EventType {
+                TICK,
+                JOB_INITIATED,
+                JOB_COMPLETED,
+                UNIT_DEATH,
+                ITEM_CREATED,
+                BUILDING,
+                CONSTRUCTION,
+                SYNDROME,
+                INVASION,
+                EVENT_MAX
+            };
+        }
+
+        struct EventHandler {
+            void (*eventHandler)(color_ostream&, void*); //called when the event happens
+            int32_t freq;
+
+            EventHandler(void (*eventHandlerIn)(color_ostream&, void*), int32_t freqIn): eventHandler(eventHandlerIn), freq(freqIn) {
+            }
+
+            bool operator==(EventHandler& handle) const {
+                return eventHandler == handle.eventHandler && freq == handle.freq;
+            }
+            bool operator!=(EventHandler& handle) const {
+                return !( *this == handle);
+            }
+        };
+
+        struct SyndromeData {
+            int32_t unitId;
+            int32_t syndromeIndex;
+            SyndromeData(int32_t unitId_in, int32_t syndromeIndex_in): unitId(unitId_in), syndromeIndex(syndromeIndex_in) {
+
+            }
+        };
+        
+        DFHACK_EXPORT void registerListener(EventType::EventType e, EventHandler handler, Plugin* plugin);
+        DFHACK_EXPORT void registerTick(EventHandler handler, int32_t when, Plugin* plugin, bool absolute=false);
+        DFHACK_EXPORT void unregister(EventType::EventType e, EventHandler handler, Plugin* plugin);
+        DFHACK_EXPORT void unregisterAll(Plugin* plugin);
+        void manageEvents(color_ostream& out);
+        void onStateChange(color_ostream& out, state_change_event event);
+    }
+}
+
+#endif

library/include/modules/Job.h

@@ -49,7 +49,7 @@ namespace DFHack
 {
     namespace Job {
         // Duplicate the job structure. It is not linked into any DF lists.
-        DFHACK_EXPORT df::job *cloneJobStruct(df::job *job);
+        DFHACK_EXPORT df::job *cloneJobStruct(df::job *job, bool keepWorkerData=false);
 
         // Delete a cloned structure.
         DFHACK_EXPORT void deleteJobStruct(df::job *job);

library/modules/Buildings.cpp

@@ -25,11 +25,16 @@ distribution.
 
 #include "Internal.h"
 
+#include <algorithm>
+#include <cstdlib>
+#include <iostream>
+#include <map>
 #include <string>
+#include <unordered_map>
 #include <vector>
-#include <map>
 using namespace std;
 
+#include "ColorText.h"
 #include "VersionInfo.h"
 #include "MemAccess.h"
 #include "Types.h"
@@ -77,6 +82,14 @@ using df::global::building_next_id;
 using df::global::process_jobs;
 using df::building_def;
 
+struct CoordHash {
+    size_t operator()(const df::coord pos) const {
+        return pos.x*65537 + pos.y*17 + pos.z;
+    }
+};
+
+static unordered_map<df::coord, int32_t, CoordHash> locationToBuilding;
+
 static uint8_t *getExtentTile(df::building_extents &extent, df::coord2d tile)
 {
     if (!extent.extents)
@@ -236,6 +249,31 @@ df::building *Buildings::findAtTile(df::coord pos)
     if (!occ || !occ->bits.building)
         return NULL;
 
+    auto a = locationToBuilding.find(pos);
+    if ( a == locationToBuilding.end() ) {
+        cerr << __FILE__ << ", " << __LINE__ << ": can't find building at " << pos.x << ", " << pos.y << ", " <<pos.z << "." << endl;
+        exit(1);
+    }
+    int32_t id = (*a).second;
+    int32_t index = df::building::binsearch_index(df::global::world->buildings.all, id);
+    if ( index == -1 ) {
+        cerr << __FILE__ << ", " << __LINE__ << ": can't find building at " << pos.x << ", " << pos.y << ", " <<pos.z << "." << endl;
+        exit(1);
+    }
+    df::building* building = df::global::world->buildings.all[index];
+    if (!building->isSettingOccupancy())
+        return NULL;
+
+    if (building->room.extents && building->isExtentShaped())
+    {
+        auto etile = getExtentTile(building->room, pos);
+        if (!etile || !*etile)
+            return NULL;
+    }
+    return building;
+
+    /*
+    //old method: brute-force
     auto &vec = df::building::get_vector();
     for (size_t i = 0; i < vec.size(); i++)
     {
@@ -260,6 +298,7 @@ df::building *Buildings::findAtTile(df::coord pos)
     }
 
     return NULL;
+    */
 }
 
 bool Buildings::findCivzonesAt(std::vector<df::building_civzonest*> *pvec, df::coord pos)
@@ -1077,3 +1116,52 @@ bool Buildings::deconstruct(df::building *bld)
     return true;
 }
 
+static unordered_map<int32_t, df::coord> corner1;
+static unordered_map<int32_t, df::coord> corner2;
+
+void Buildings::clearBuildings(color_ostream& out) {
+    corner1.clear();
+    corner2.clear();
+    locationToBuilding.clear();
+}
+
+void Buildings::updateBuildings(color_ostream& out, void* ptr) {
+    //out.print("Updating buildings, %s %d\n", __FILE__, __LINE__);
+    int32_t id = (int32_t)ptr;
+    
+    if ( corner1.find(id) == corner1.end() ) {
+        //new building: mark stuff
+        int32_t index = df::building::binsearch_index(df::global::world->buildings.all, id);
+        if ( index == -1 ) {
+            out.print("%s, line %d: Couldn't find new building id=%d.\n", __FILE__, __LINE__, id);
+            exit(1);
+        }
+        df::building* building = df::global::world->buildings.all[index];
+        df::coord p1(min(building->x1, building->x2), min(building->y1,building->y2), building->z);
+        df::coord p2(max(building->x1, building->x2), max(building->y1,building->y2), building->z);
+
+        corner1[id] = p1;
+        corner2[id] = p2;
+
+        for ( int32_t x = p1.x; x <= p2.x; x++ ) {
+            for ( int32_t y = p1.y; y <= p2.y; y++ ) {
+                df::coord pt(x,y,building->z);
+                locationToBuilding[pt] = id;
+            }
+        }
+    } else {
+        //existing building: destroy it
+        df::coord p1 = corner1[id];
+        df::coord p2 = corner2[id];
+        
+        for ( int32_t x = p1.x; x <= p2.x; x++ ) {
+            for ( int32_t y = p1.y; y <= p2.y; y++ ) {
+                df::coord pt(x,y,p1.z);
+                locationToBuilding.erase(pt);
+            }
+        }
+
+        corner1.erase(id);
+        corner2.erase(id);
+    }
+}

library/modules/EventManager.cpp

@@ -0,0 +1,503 @@
+#include "Core.h"
+#include "Console.h"
+#include "modules/Buildings.h"
+#include "modules/Constructions.h"
+#include "modules/EventManager.h"
+#include "modules/Job.h"
+#include "modules/World.h"
+
+#include "df/building.h"
+#include "df/construction.h"
+#include "df/global_objects.h"
+#include "df/item.h"
+#include "df/job.h"
+#include "df/job_list_link.h"
+#include "df/ui.h"
+#include "df/unit.h"
+#include "df/unit_syndrome.h"
+#include "df/world.h"
+
+#include <map>
+#include <unordered_map>
+#include <unordered_set>
+
+using namespace std;
+using namespace DFHack;
+using namespace EventManager;
+
+/*
+ * TODO:
+ *  error checking
+ *  consider a typedef instead of a struct for EventHandler
+ **/
+
+//map<uint32_t, vector<DFHack::EventManager::EventHandler> > tickQueue;
+multimap<uint32_t, EventHandler> tickQueue;
+
+//TODO: consider unordered_map of pairs, or unordered_map of unordered_set, or whatever
+multimap<Plugin*, EventHandler> handlers[EventType::EVENT_MAX];
+uint32_t eventLastTick[EventType::EVENT_MAX];
+
+const uint32_t ticksPerYear = 403200;
+
+void DFHack::EventManager::registerListener(EventType::EventType e, EventHandler handler, Plugin* plugin) {
+    handlers[e].insert(pair<Plugin*, EventHandler>(plugin, handler));
+}
+
+void DFHack::EventManager::registerTick(EventHandler handler, int32_t when, Plugin* plugin, bool absolute) {
+    uint32_t tick = DFHack::World::ReadCurrentYear()*ticksPerYear
+        + DFHack::World::ReadCurrentTick();
+    if ( !Core::getInstance().isWorldLoaded() ) {
+        tick = 0;
+        if ( absolute ) {
+            Core::getInstance().getConsole().print("Warning: absolute flag will not be honored.\n");
+        }
+    }
+    if ( absolute ) {
+        tick = 0;
+    }
+    
+    tickQueue.insert(pair<uint32_t, EventHandler>(tick+(uint32_t)when, handler));
+    handlers[EventType::TICK].insert(pair<Plugin*,EventHandler>(plugin,handler));
+    return;
+}
+
+void DFHack::EventManager::unregister(EventType::EventType e, EventHandler handler, Plugin* plugin) {
+    for ( multimap<Plugin*, EventHandler>::iterator i = handlers[e].find(plugin); i != handlers[e].end(); i++ ) {
+        if ( (*i).first != plugin )
+            break;
+        EventHandler handle = (*i).second;
+        if ( handle == handler ) {
+            handlers[e].erase(i);
+            break;
+        }
+    }
+    return;
+}
+
+void DFHack::EventManager::unregisterAll(Plugin* plugin) {
+    for ( auto i = handlers[EventType::TICK].find(plugin); i != handlers[EventType::TICK].end(); i++ ) {
+        if ( (*i).first != plugin )
+            break;
+        
+        //shenanigans to avoid concurrent modification
+        EventHandler getRidOf = (*i).second;
+        bool didSomething;
+        do {
+            didSomething = false;
+            for ( auto j = tickQueue.begin(); j != tickQueue.end(); j++ ) {
+                EventHandler candidate = (*j).second;
+                if ( getRidOf != candidate )
+                    continue;
+                tickQueue.erase(j);
+                didSomething = true;
+                break;
+            }
+        } while(didSomething);
+    }
+    for ( size_t a = 0; a < (size_t)EventType::EVENT_MAX; a++ ) {
+        handlers[a].erase(plugin);
+    }
+    return;
+}
+
+static void manageTickEvent(color_ostream& out);
+static void manageJobInitiatedEvent(color_ostream& out);
+static void manageJobCompletedEvent(color_ostream& out);
+static void manageUnitDeathEvent(color_ostream& out);
+static void manageItemCreationEvent(color_ostream& out);
+static void manageBuildingEvent(color_ostream& out);
+static void manageConstructionEvent(color_ostream& out);
+static void manageSyndromeEvent(color_ostream& out);
+static void manageInvasionEvent(color_ostream& out);
+
+//tick event
+static uint32_t lastTick = 0;
+
+//job initiated
+static int32_t lastJobId = -1;
+
+//job completed
+static unordered_map<int32_t, df::job*> prevJobs;
+
+//unit death
+static unordered_set<int32_t> livingUnits;
+
+//item creation
+static int32_t nextItem;
+
+//building
+static int32_t nextBuilding;
+static unordered_set<int32_t> buildings;
+
+//construction
+static unordered_set<df::construction*> constructions;
+static bool gameLoaded;
+
+//invasion
+static int32_t nextInvasion;
+
+void DFHack::EventManager::onStateChange(color_ostream& out, state_change_event event) {
+    static bool doOnce = false;
+    if ( !doOnce ) {
+        //TODO: put this somewhere else
+        doOnce = true;
+        EventHandler buildingHandler(Buildings::updateBuildings, 100);
+        DFHack::EventManager::registerListener(EventType::BUILDING, buildingHandler, NULL);
+        //out.print("Registered listeners.\n %d", __LINE__);
+    }
+    if ( event == DFHack::SC_WORLD_UNLOADED ) {
+        lastTick = 0;
+        lastJobId = -1;
+        for ( auto i = prevJobs.begin(); i != prevJobs.end(); i++ ) {
+            Job::deleteJobStruct((*i).second);
+        }
+        prevJobs.clear();
+        tickQueue.clear();
+        livingUnits.clear();
+        nextItem = -1;
+        nextBuilding = -1;
+        buildings.clear();
+        constructions.clear();
+
+        Buildings::clearBuildings(out);
+        gameLoaded = false;
+        nextInvasion = -1;
+    } else if ( event == DFHack::SC_WORLD_LOADED ) {
+        uint32_t tick = DFHack::World::ReadCurrentYear()*ticksPerYear
+            + DFHack::World::ReadCurrentTick();
+        multimap<uint32_t,EventHandler> newTickQueue;
+        for ( auto i = tickQueue.begin(); i != tickQueue.end(); i++ ) {
+            newTickQueue.insert(pair<uint32_t,EventHandler>(tick + (*i).first, (*i).second));
+        }
+        tickQueue.clear();
+
+        tickQueue.insert(newTickQueue.begin(), newTickQueue.end());
+
+        nextItem = 0;
+        nextBuilding = 0;
+        lastTick = 0;
+        nextInvasion = df::global::ui->invasions.next_id;
+        gameLoaded = true;
+    }
+}
+
+void DFHack::EventManager::manageEvents(color_ostream& out) {
+    if ( !gameLoaded ) {
+        return;
+    }
+    uint32_t tick = DFHack::World::ReadCurrentYear()*ticksPerYear
+        + DFHack::World::ReadCurrentTick();
+    
+    if ( tick <= lastTick )
+        return;
+    lastTick = tick;
+
+    int32_t eventFrequency[EventType::EVENT_MAX];
+    for ( size_t a = 0; a < EventType::EVENT_MAX; a++ ) {
+        int32_t min = 1000000000;
+        for ( auto b = handlers[a].begin(); b != handlers[a].end(); b++ ) {
+            EventHandler bob = (*b).second;
+            if ( bob.freq < min )
+                min = bob.freq;
+        }
+        eventFrequency[a] = min;
+    }
+    
+    manageTickEvent(out);
+    if ( tick - eventLastTick[EventType::JOB_INITIATED] >= eventFrequency[EventType::JOB_INITIATED] ) {
+        manageJobInitiatedEvent(out);
+        eventLastTick[EventType::JOB_INITIATED] = tick;
+    }
+    if ( tick - eventLastTick[EventType::JOB_COMPLETED] >= eventFrequency[EventType::JOB_COMPLETED] ) {
+        manageJobCompletedEvent(out);
+        eventLastTick[EventType::JOB_COMPLETED] = tick;
+    }
+    if ( tick - eventLastTick[EventType::UNIT_DEATH] >= eventFrequency[EventType::UNIT_DEATH] ) {
+        manageUnitDeathEvent(out);
+        eventLastTick[EventType::UNIT_DEATH] = tick;
+    }
+    if ( tick - eventLastTick[EventType::ITEM_CREATED] >= eventFrequency[EventType::ITEM_CREATED] ) {
+        manageItemCreationEvent(out);
+        eventLastTick[EventType::ITEM_CREATED] = tick;
+    }
+    if ( tick - eventLastTick[EventType::BUILDING] >= eventFrequency[EventType::BUILDING] ) {
+        manageBuildingEvent(out);
+        eventLastTick[EventType::BUILDING] = tick;
+    }
+    if ( tick - eventLastTick[EventType::CONSTRUCTION] >= eventFrequency[EventType::CONSTRUCTION] ) {
+        manageConstructionEvent(out);
+        eventLastTick[EventType::CONSTRUCTION] = tick;
+    }
+    if ( tick - eventLastTick[EventType::SYNDROME] >= eventFrequency[EventType::SYNDROME] ) {
+        manageSyndromeEvent(out);
+        eventLastTick[EventType::SYNDROME] = tick;
+    }
+    if ( tick - eventLastTick[EventType::INVASION] >= eventFrequency[EventType::INVASION] ) {
+        manageInvasionEvent(out);
+        eventLastTick[EventType::INVASION] = tick;
+    }
+
+    return;
+}
+
+static void manageTickEvent(color_ostream& out) {
+    uint32_t tick = DFHack::World::ReadCurrentYear()*ticksPerYear
+        + DFHack::World::ReadCurrentTick();
+    while ( !tickQueue.empty() ) {
+        if ( tick < (*tickQueue.begin()).first )
+            break;
+        EventHandler handle = (*tickQueue.begin()).second;
+        tickQueue.erase(tickQueue.begin());
+        handle.eventHandler(out, (void*)tick);
+    }
+    
+}
+
+static void manageJobInitiatedEvent(color_ostream& out) {
+    if ( handlers[EventType::JOB_INITIATED].empty() )
+        return;
+    
+    if ( lastJobId == -1 ) {
+        lastJobId = *df::global::job_next_id - 1;
+        return;
+    }
+
+    if ( lastJobId+1 == *df::global::job_next_id ) {
+        return; //no new jobs
+    }
+    multimap<Plugin*,EventHandler> copy(handlers[EventType::JOB_INITIATED].begin(), handlers[EventType::JOB_INITIATED].end());
+    
+    for ( df::job_list_link* link = &df::global::world->job_list; link != NULL; link = link->next ) {
+        if ( link->item == NULL )
+            continue;
+        if ( link->item->id <= lastJobId )
+            continue;
+        for ( auto i = copy.begin(); i != copy.end(); i++ ) {
+            (*i).second.eventHandler(out, (void*)link->item);
+        }
+    }
+
+    lastJobId = *df::global::job_next_id - 1;
+}
+
+static void manageJobCompletedEvent(color_ostream& out) {
+    if ( handlers[EventType::JOB_COMPLETED].empty() ) {
+        return;
+    }
+    
+    multimap<Plugin*,EventHandler> copy(handlers[EventType::JOB_COMPLETED].begin(), handlers[EventType::JOB_COMPLETED].end());
+    map<int32_t, df::job*> nowJobs;
+    for ( df::job_list_link* link = &df::global::world->job_list; link != NULL; link = link->next ) {
+        if ( link->item == NULL )
+            continue;
+        nowJobs[link->item->id] = link->item;
+    }
+
+    for ( auto i = prevJobs.begin(); i != prevJobs.end(); i++ ) {
+        if ( nowJobs.find((*i).first) != nowJobs.end() )
+            continue;
+
+        //recently finished or cancelled job!
+        for ( auto j = copy.begin(); j != copy.end(); j++ ) {
+            (*j).second.eventHandler(out, (void*)(*i).second);
+        }
+    }
+
+    //erase old jobs, copy over possibly altered jobs
+    for ( auto i = prevJobs.begin(); i != prevJobs.end(); i++ ) {
+        Job::deleteJobStruct((*i).second);
+    }
+    prevJobs.clear();
+    
+    //create new jobs
+    for ( auto j = nowJobs.begin(); j != nowJobs.end(); j++ ) {
+        /*map<int32_t, df::job*>::iterator i = prevJobs.find((*j).first);
+        if ( i != prevJobs.end() ) {
+            continue;
+        }*/
+
+        df::job* newJob = Job::cloneJobStruct((*j).second, true);
+        prevJobs[newJob->id] = newJob;
+    }
+
+    /*//get rid of old pointers to deallocated jobs
+    for ( size_t a = 0; a < toDelete.size(); a++ ) {
+        prevJobs.erase(a);
+    }*/
+}
+
+static void manageUnitDeathEvent(color_ostream& out) {
+    if ( handlers[EventType::UNIT_DEATH].empty() ) {
+        return;
+    }
+    
+    multimap<Plugin*,EventHandler> copy(handlers[EventType::UNIT_DEATH].begin(), handlers[EventType::UNIT_DEATH].end());
+    for ( size_t a = 0; a < df::global::world->units.active.size(); a++ ) {
+        df::unit* unit = df::global::world->units.active[a];
+        if ( unit->counters.death_id == -1 ) {
+            livingUnits.insert(unit->id);
+            continue;
+        }
+        //dead: if dead since last check, trigger events
+        if ( livingUnits.find(unit->id) == livingUnits.end() )
+            continue;
+
+        for ( auto i = copy.begin(); i != copy.end(); i++ ) {
+            (*i).second.eventHandler(out, (void*)unit->id);
+        }
+        livingUnits.erase(unit->id);
+    }
+}
+
+static void manageItemCreationEvent(color_ostream& out) {
+    if ( handlers[EventType::ITEM_CREATED].empty() ) {
+        return;
+    }
+
+    if ( nextItem >= *df::global::item_next_id ) {
+        return;
+    }
+
+    multimap<Plugin*,EventHandler> copy(handlers[EventType::ITEM_CREATED].begin(), handlers[EventType::ITEM_CREATED].end());
+    size_t index = df::item::binsearch_index(df::global::world->items.all, nextItem, false);
+    for ( size_t a = index; a < df::global::world->items.all.size(); a++ ) {
+        df::item* item = df::global::world->items.all[a];
+        //invaders
+        if ( item->flags.bits.foreign )
+            continue;
+        //traders who bring back your items?
+        if ( item->flags.bits.trader )
+            continue;
+        //migrants
+        if ( item->flags.bits.owned )
+            continue;
+        //spider webs don't count
+        if ( item->flags.bits.spider_web )
+            continue;
+        for ( auto i = copy.begin(); i != copy.end(); i++ ) {
+            (*i).second.eventHandler(out, (void*)item->id);
+        }
+    }
+    nextItem = *df::global::item_next_id;
+}
+
+static void manageBuildingEvent(color_ostream& out) {
+    /*
+     * TODO: could be faster
+     * consider looking at jobs: building creation / destruction
+     **/
+    if ( handlers[EventType::BUILDING].empty() )
+        return;
+    
+    multimap<Plugin*,EventHandler> copy(handlers[EventType::BUILDING].begin(), handlers[EventType::BUILDING].end());
+    //first alert people about new buildings
+    for ( int32_t a = nextBuilding; a < *df::global::building_next_id; a++ ) {
+        int32_t index = df::building::binsearch_index(df::global::world->buildings.all, a);
+        if ( index == -1 ) {
+            //out.print("%s, line %d: Couldn't find new building with id %d.\n", __FILE__, __LINE__, a);
+            //the tricky thing is that when the game first starts, it's ok to skip buildings, but otherwise, if you skip buildings, something is probably wrong. TODO: make this smarter
+            continue;
+        }
+        buildings.insert(a);
+        for ( auto b = copy.begin(); b != copy.end(); b++ ) {
+            EventHandler bob = (*b).second;
+            bob.eventHandler(out, (void*)a);
+        }
+    }
+    nextBuilding = *df::global::building_next_id;
+    
+    //now alert people about destroyed buildings
+    unordered_set<int32_t> toDelete;
+    for ( auto a = buildings.begin(); a != buildings.end(); a++ ) {
+        int32_t id = *a;
+        int32_t index = df::building::binsearch_index(df::global::world->buildings.all,id);
+        if ( index != -1 )
+            continue;
+        toDelete.insert(id);
+
+        for ( auto b = copy.begin(); b != copy.end(); b++ ) {
+            EventHandler bob = (*b).second;
+            bob.eventHandler(out, (void*)id);
+        }
+    }
+
+    for ( auto a = toDelete.begin(); a != toDelete.end(); a++ ) {
+        int32_t id = *a;
+        buildings.erase(id);
+    }
+    
+    //out.print("Sent building event.\n %d", __LINE__);
+}
+
+static void manageConstructionEvent(color_ostream& out) {
+    if ( handlers[EventType::CONSTRUCTION].empty() )
+        return;
+
+    unordered_set<df::construction*> constructionsNow(df::global::world->constructions.begin(), df::global::world->constructions.end());
+    
+    multimap<Plugin*,EventHandler> copy(handlers[EventType::CONSTRUCTION].begin(), handlers[EventType::CONSTRUCTION].end());
+    for ( auto a = constructions.begin(); a != constructions.end(); a++ ) {
+        df::construction* construction = *a;
+        if ( constructionsNow.find(construction) != constructionsNow.end() )
+            continue;
+        for ( auto b = copy.begin(); b != copy.end(); b++ ) {
+            EventHandler handle = (*b).second;
+            handle.eventHandler(out, (void*)construction);
+        }
+    }
+
+    for ( auto a = constructionsNow.begin(); a != constructionsNow.end(); a++ ) {
+        df::construction* construction = *a;
+        if ( constructions.find(construction) != constructions.end() )
+            continue;
+        for ( auto b = copy.begin(); b != copy.end(); b++ ) {
+            EventHandler handle = (*b).second;
+            handle.eventHandler(out, (void*)construction);
+        }
+    }
+    
+    constructions.clear();
+    constructions.insert(constructionsNow.begin(), constructionsNow.end());
+}
+
+static void manageSyndromeEvent(color_ostream& out) {
+    if ( handlers[EventType::SYNDROME].empty() )
+        return;
+
+    multimap<Plugin*,EventHandler> copy(handlers[EventType::SYNDROME].begin(), handlers[EventType::SYNDROME].end());
+    for ( auto a = df::global::world->units.active.begin(); a != df::global::world->units.active.end(); a++ ) {
+        df::unit* unit = *a;
+        if ( unit->flags1.bits.dead )
+            continue;
+        for ( size_t b = 0; b < unit->syndromes.active.size(); b++ ) {
+            df::unit_syndrome* syndrome = unit->syndromes.active[b];
+            uint32_t startTime = syndrome->year*ticksPerYear + syndrome->year_time;
+            if ( startTime <= eventLastTick[EventType::SYNDROME] )
+                continue;
+
+            SyndromeData data(unit->id, b);
+            for ( auto c = copy.begin(); c != copy.end(); c++ ) {
+                EventHandler handle = (*c).second;
+                handle.eventHandler(out, (void*)&data);
+            }
+        }
+    }
+}
+
+static void manageInvasionEvent(color_ostream& out) {
+    if ( handlers[EventType::INVASION].empty() )
+        return;
+
+    multimap<Plugin*,EventHandler> copy(handlers[EventType::INVASION].begin(), handlers[EventType::INVASION].end());
+
+    if ( df::global::ui->invasions.next_id <= nextInvasion )
+        return;
+    nextInvasion = df::global::ui->invasions.next_id;
+
+    for ( auto a = copy.begin(); a != copy.end(); a++ ) {
+        EventHandler handle = (*a).second;
+        handle.eventHandler(out, (void*)nextInvasion);
+    }
+}
+

library/modules/Job.cpp

@@ -55,7 +55,7 @@ using namespace std;
 using namespace DFHack;
 using namespace df::enums;
 
-df::job *DFHack::Job::cloneJobStruct(df::job *job)
+df::job *DFHack::Job::cloneJobStruct(df::job *job, bool keepWorkerData)
 {
     CHECK_NULL_POINTER(job);
 
@@ -76,7 +76,7 @@ df::job *DFHack::Job::cloneJobStruct(df::job *job)
     {
         df::general_ref *ref = pnew->general_refs[i];
 
-        if (virtual_cast<df::general_ref_unit>(ref))
+        if (!keepWorkerData && virtual_cast<df::general_ref_unit_workerst>(ref))
             vector_erase_at(pnew->general_refs, i);
         else
             pnew->general_refs[i] = ref->clone();

plugins/devel/CMakeLists.txt

@@ -18,6 +18,7 @@ DFHACK_PLUGIN(stripcaged stripcaged.cpp)
 DFHACK_PLUGIN(rprobe rprobe.cpp)
 DFHACK_PLUGIN(nestboxes nestboxes.cpp)
 DFHACK_PLUGIN(vshook vshook.cpp)
+DFHACK_PLUGIN(eventExample eventExample.cpp)
 IF(UNIX)
 DFHACK_PLUGIN(ref-index ref-index.cpp)
 ENDIF()

plugins/devel/eventExample.cpp

@@ -0,0 +1,108 @@
+
+#include "Console.h"
+#include "Core.h"
+#include "Export.h"
+#include "PluginManager.h"
+#include "modules/EventManager.h"
+#include "DataDefs.h"
+
+#include "df/item.h"
+#include "df/world.h"
+
+#include <vector>
+
+using namespace DFHack;
+using namespace std;
+
+DFHACK_PLUGIN("eventExample");
+
+void jobInitiated(color_ostream& out, void* job);
+void jobCompleted(color_ostream& out, void* job);
+void timePassed(color_ostream& out, void* ptr);
+void unitDeath(color_ostream& out, void* ptr);
+void itemCreate(color_ostream& out, void* ptr);
+void building(color_ostream& out, void* ptr);
+void construction(color_ostream& out, void* ptr);
+void syndrome(color_ostream& out, void* ptr);
+void invasion(color_ostream& out, void* ptr);
+
+command_result eventExample(color_ostream& out, vector<string>& parameters);
+
+DFhackCExport command_result plugin_init(color_ostream &out, std::vector<PluginCommand> &commands) {
+    commands.push_back(PluginCommand("eventExample", "Sets up a few event triggers.",eventExample));
+    return CR_OK;
+}
+
+command_result eventExample(color_ostream& out, vector<string>& parameters) {
+    EventManager::EventHandler initiateHandler(jobInitiated, 10);
+    EventManager::EventHandler completeHandler(jobCompleted, 5);
+    EventManager::EventHandler timeHandler(timePassed, 1);
+    EventManager::EventHandler deathHandler(unitDeath, 500);
+    EventManager::EventHandler itemHandler(itemCreate, 1000);
+    EventManager::EventHandler buildingHandler(building, 500);
+    EventManager::EventHandler constructionHandler(construction, 100);
+    EventManager::EventHandler syndromeHandler(syndrome, 1);
+    EventManager::EventHandler invasionHandler(invasion, 1000);
+    Plugin* me = Core::getInstance().getPluginManager()->getPluginByName("eventExample");
+    EventManager::unregisterAll(me);
+
+    EventManager::registerListener(EventManager::EventType::JOB_INITIATED, initiateHandler, me);
+    EventManager::registerListener(EventManager::EventType::JOB_COMPLETED, completeHandler, me);
+    EventManager::registerTick(timeHandler, 1, me);
+    EventManager::registerTick(timeHandler, 2, me);
+    EventManager::registerTick(timeHandler, 4, me);
+    EventManager::registerTick(timeHandler, 8, me);
+    EventManager::registerListener(EventManager::EventType::UNIT_DEATH, deathHandler, me);
+    EventManager::registerListener(EventManager::EventType::ITEM_CREATED, itemHandler, me);
+    EventManager::registerListener(EventManager::EventType::BUILDING, buildingHandler, me);
+    EventManager::registerListener(EventManager::EventType::CONSTRUCTION, constructionHandler, me);
+    EventManager::registerListener(EventManager::EventType::SYNDROME, syndromeHandler, me);
+    EventManager::registerListener(EventManager::EventType::INVASION, invasionHandler, me);
+    out.print("Events registered.\n");
+    return CR_OK;
+}
+
+void jobInitiated(color_ostream& out, void* job) {
+    out.print("Job initiated! 0x%X\n", job);
+}
+
+void jobCompleted(color_ostream& out, void* job) {
+    out.print("Job completed! 0x%X\n", job);
+}
+
+void timePassed(color_ostream& out, void* ptr) {
+    out.print("Time: %d\n", (int32_t)(ptr));
+}
+
+void unitDeath(color_ostream& out, void* ptr) {
+    out.print("Death: %d\n", (int32_t)(ptr));
+}
+
+void itemCreate(color_ostream& out, void* ptr) {
+    int32_t item_index = df::item::binsearch_index(df::global::world->items.all, (int32_t)ptr);
+    if ( item_index == -1 ) {
+        out.print("%s, %d: Error.\n", __FILE__, __LINE__);
+    }
+    df::item* item = df::global::world->items.all[item_index];
+    df::item_type type = item->getType();
+    df::coord pos = item->pos;
+    out.print("Item created: %d, %s, at (%d,%d,%d)\n", (int32_t)(ptr), ENUM_KEY_STR(item_type, type).c_str(), pos.x, pos.y, pos.z);
+}
+
+void building(color_ostream& out, void* ptr) {
+    out.print("Building created/destroyed: %d\n", (int32_t)ptr);
+}
+
+void construction(color_ostream& out, void* ptr) {
+    out.print("Construction created/destroyed: 0x%X\n", ptr);
+}
+
+void syndrome(color_ostream& out, void* ptr) {
+    EventManager::SyndromeData* data = (EventManager::SyndromeData*)ptr;
+    out.print("Syndrome started: unit %d, syndrome %d.\n", data->unitId, data->syndromeIndex);
+}
+
+void invasion(color_ostream& out, void* ptr) {
+    out.print("New invasion! %d\n", (int32_t)ptr);
+}
+