Revises ChannelJobs, ChannelGroups, and ChannelManager implementations

Author: cppcooper

plugins/channel-safely/channel-groups.cpp

@@ -20,43 +20,41 @@ void ChannelJobs::load_channel_jobs() {
     }
 }
 
-bool ChannelJobs::has_cavein_conditions(const df::coord &map_pos) {
-    if likely(Maps::isValidTilePos(map_pos)) {
-        auto p = map_pos;
-        auto ttype = *Maps::getTileType(p);
-        if (!DFHack::isOpenTerrain(ttype)) {
-            // check shared neighbour for cave-in conditions
-            df::coord neighbours[4];
-            get_connected_neighbours(map_pos, neighbours);
-            int connectedness = 4;
-            for (auto n: neighbours) {
-                if (!Maps::isValidTilePos(n) || active.count(n) || DFHack::isOpenTerrain(*Maps::getTileType(n))) {
-                    connectedness--;
-                }
+bool ChannelJobs::has_cavein_conditions(const df::coord &map_pos) const {
+    auto p = map_pos;
+    auto ttype = *Maps::getTileType(p);
+    if (!DFHack::isOpenTerrain(ttype)) {
+        // check shared neighbour for cave-in conditions
+        df::coord neighbours[4];
+        get_connected_neighbours(map_pos, neighbours);
+        int connectedness = 4;
+        for (auto n: neighbours) {
+            if (!Maps::isValidTilePos(n) || active.count(n) || DFHack::isOpenTerrain(*Maps::getTileType(n))) {
+                connectedness--;
             }
-            if (!connectedness) {
-                // do what?
-                p.z--;
-                if (!Maps::isValidTilePos(p)) return false;
-                ttype = *Maps::getTileType(p);
-                if (DFHack::isOpenTerrain(ttype) || DFHack::isFloorTerrain(ttype)) {
-                    return true;
-                }
+        }
+        if (!connectedness) {
+            // do what?
+            p.z--;
+            if (!Maps::isValidTilePos(p)) return false;
+            ttype = *Maps::getTileType(p);
+            if (DFHack::isOpenTerrain(ttype) || DFHack::isFloorTerrain(ttype)) {
+                return true;
             }
         }
     }
     return false;
 }
 
-bool ChannelJobs::possible_cavein(const df::coord &job_pos) {
-    for (auto iter : active) {
-        if (iter == job_pos) continue;
-        if (calc_distance(job_pos, iter) <= 2) {
+bool ChannelJobs::possible_cavein(const df::coord &job_pos) const {
+    for (auto dig_pos : active) {
+        if (dig_pos == job_pos) continue;
+        if (calc_distance(job_pos, dig_pos) <= 2) {
             // find neighbours
             df::coord n1[8];
             df::coord n2[8];
             get_neighbours(job_pos, n1);
-            get_neighbours(iter, n2);
+            get_neighbours(dig_pos, n2);
             // find shared neighbours
             for (int i = 0; i < 7; ++i) {
                 for (int j = i + 1; j < 8; ++j) {
@@ -181,25 +179,7 @@ void ChannelGroups::scan(bool full_scan) {
         full_scan = sometimes_scanFULLY(RNG);
     }
 
-    // save current jobs, then clear and load the current jobs
-    std::set<df::coord> last_jobs;
-    for (auto &pos : jobs) {
-        last_jobs.emplace(pos);
-    }
-    jobs.load_channel_jobs();
-    // transpose channel jobs to
-    std::set<df::coord> new_jobs;
-    std::set<df::coord> gone_jobs;
-    set_difference(last_jobs, jobs, gone_jobs);
-    set_difference(jobs, last_jobs, new_jobs);
-    INFO(groups).print("gone jobs: %zd\nnew jobs: %zd\n",gone_jobs.size(), new_jobs.size());
-    for (auto &pos : new_jobs) {
-        add(pos);
-    }
-    for (auto &pos : gone_jobs){
-        remove(pos);
-    }
-
+    scan_jobs();
     DEBUG(groups).print("  scan()\n");
     // foreach block
     for (int32_t z = mapz - 1; z >= 0; --z) {
@@ -263,6 +243,28 @@ void ChannelGroups::scan(bool full_scan) {
     INFO(groups).print("scan() exits\n");
 }
 
+// updates groupings of adjacent channel designations based on changes to the job list
+void ChannelGroups::scan_jobs() {
+    // save current jobs, then clear and load the current jobs
+    std::set<df::coord> last_jobs;
+    for (auto &pos : jobs) {
+        last_jobs.emplace(pos);
+    }
+    jobs.load_channel_jobs();
+    // transpose channel jobs to
+    std::set<df::coord> new_jobs;
+    std::set<df::coord> gone_jobs;
+    set_difference(last_jobs, jobs, gone_jobs);
+    set_difference(jobs, last_jobs, new_jobs);
+    INFO(groups).print("gone jobs: %zd\nnew jobs: %zd\n",gone_jobs.size(), new_jobs.size());
+    for (auto &pos : new_jobs) {
+        add(pos);
+    }
+    for (auto &pos : gone_jobs){
+        remove(pos);
+    }
+}
+
 // clears out the containers for unloading maps or disabling the plugin
 void ChannelGroups::clear() {
     debug_map();

plugins/channel-safely/channel-manager.cpp

@@ -1,9 +1,11 @@
+#include <active-job-manager.h>
 #include <channel-manager.h>
 #include <tile-cache.h>
 #include <inlines.h>
 
 #include <modules/EventManager.h> //hash function for df::coord
 #include <df/block_square_event_designation_priorityst.h>
+#include <df/unit.h>
 
 #define NUMARGS(...) std::tuple_size<decltype(std::make_tuple(__VA_ARGS__))>::value
 #define d_assert(condition, ...) \
@@ -13,8 +15,11 @@
                 assert(0);                                                      \
             }
 
+namespace CSP {
+    extern ActiveJobManager active_job_manager;
+}
 
-df::unit* find_dwarf(const df::coord &map_pos) {
+df::unit* find_nearest_dwarf(const df::coord &map_pos) {
 
     df::unit* nearest = nullptr;
     uint32_t distance;
@@ -76,7 +81,7 @@ void ChannelManager::manage_group(const Group &group, bool set_marker_mode, bool
          * To count access, we find a random miner dwarf and count how many tile neighbours they can path to
          * */
         // find a dwarf to path from
-        df::coord miner_pos = find_dwarf(*group.begin())->pos;
+        df::coord miner_pos = find_nearest_dwarf(*group.begin())->pos;
 
         // Analyze designations
         for (const auto &pos: group) {
@@ -101,6 +106,7 @@ void ChannelManager::manage_group(const Group &group, bool set_marker_mode, bool
                     }
                 } else {
                     WARN(manager).print(" has %d access\n", access);
+                    // if any
                     cavein_possible = config.riskaverse;
                     cavein_candidates.emplace(pos, access);
                     least_access = std::min(access, least_access);
@@ -182,7 +188,9 @@ bool ChannelManager::manage_one(const df::coord &map_pos, bool set_marker_mode,
             }
             if (marker_mode) {
                 if (jobs.count(map_pos)) {
-                    cancel_job(map_pos);
+                    // todo: this can still execute in the JobStartedEvent() stack
+                    CSP::active_job_manager.cancel(map_pos);
+                    //cancel_job(map_pos);
                 }
             } else if (!block->flags.bits.designated) {
                 block->flags.bits.designated = true;
@@ -202,6 +210,4 @@ bool ChannelManager::manage_one(const df::coord &map_pos, bool set_marker_mode,
 void ChannelManager::mark_done(const df::coord &map_pos) {
     groups.remove(map_pos);
     jobs.erase(map_pos);
-    CSP::dignow_queue.erase(map_pos);
-    TileCache::Get().uncache(map_pos);
 }

plugins/channel-safely/include/active-job-manager.h

@@ -59,5 +59,6 @@ class ActiveJobManager {
     void on_job_start(df::job* job);
     void on_job_completed(color_ostream &out, df::job* job);
     void on_report_event(df::report* report);
+    void cancel(df::coord site) {cancel_queue.emplace(site);}
     void clear();
-};
+};

plugins/channel-safely/include/channel-groups.h

@@ -33,7 +33,7 @@ class ChannelGroups {
     GroupsMap groups_map;
     Groups groups;
     ChannelJobs &jobs;
-    std::set<int> free_spots;
+    std::set<int> free_spots; // ids of groups that are empty, recycling empty groups
 protected:
     void add(const df::coord &map_pos);
 public:
@@ -46,6 +46,7 @@ class ChannelGroups {
     explicit ChannelGroups(ChannelJobs &jobs) : jobs(jobs) { groups.reserve(200); }
     void scan_one(const df::coord &map_pos);
     void scan(bool full_scan = false);
+    void scan_jobs();
     void clear();
     void remove(const df::coord &map_pos);
     Groups::const_iterator find(const df::coord &map_pos) const;

plugins/channel-safely/include/channel-jobs.h

@@ -21,24 +21,16 @@ using namespace DFHack;
  */
 class ChannelJobs {
 private:
-    using Jobs = std::unordered_set<df::coord>; // job* will exist until it is complete, and likely beyond
     std::unordered_map<df::coord, df::job*> jobs;
-    Jobs locations;
-    Jobs active;
-protected:
-    bool has_cavein_conditions(const df::coord &map_pos);
+    std::unordered_set<df::coord> locations;
 public:
     void load_channel_jobs();
-    bool possible_cavein(const df::coord &job_pos);
-    void mark_active(const df::coord &map_pos) { active.emplace(map_pos); }
     void clear() {
-        active.clear();
         locations.clear();
         jobs.clear();
     }
     int count(const df::coord &map_pos) const { return locations.count(map_pos); }
-    Jobs::iterator erase(const df::coord &map_pos) {
-        active.erase(map_pos);
+    std::unordered_set<df::coord>::iterator erase(const df::coord &map_pos) {
         jobs.erase(map_pos);
         auto iter = locations.find(map_pos);
         if (iter != locations.end()) {
@@ -47,7 +39,7 @@ class ChannelJobs {
         return iter;
     }
     df::job* find_job(const df::coord &map_pos) const { return jobs.count(map_pos) ? jobs.find(map_pos)->second : nullptr; }
-    Jobs::const_iterator find(const df::coord &map_pos) const { return locations.find(map_pos); }
-    Jobs::const_iterator begin() const { return locations.begin(); }
-    Jobs::const_iterator end() const { return locations.end(); }
+    std::unordered_set<df::coord>::const_iterator find(const df::coord &map_pos) const { return locations.find(map_pos); }
+    std::unordered_set<df::coord>::const_iterator begin() const { return locations.begin(); }
+    std::unordered_set<df::coord>::const_iterator end() const { return locations.end(); }
 };