Merge pull request #2382 from cppcooper/patch-2

Updates spectate plugin

docs/changelog.txt

@@ -68,8 +68,10 @@ changelog.txt uses a syntax similar to RST, with a few special sequences:
 - `orders`: replace shell craft orders with orders for shell leggings. they have a slightly higher trade price, and "shleggings" is hilarious.
 - `spectate`: new ``auto-unpause`` option for auto-dismissal of announcement pause events (e.g. sieges).
 - `spectate`: new ``auto-disengage`` option for auto-disengagement of plugin through player interaction whilst unpaused.
-- `spectate`: new ``focus-jobs`` option for following a dwarf after their job has finished (when disabled).
 - `spectate`: new ``tick-threshold``, option for specifying the change interval (maximum follow time when focus-jobs is enabled)
+- `spectate`: new ``animals``, option for sometimes following animals
+- `spectate`: new ``hostiles``, option for sometimes following hostiles
+- `spectate`: new ``visiting``, option for sometimes following visiting merchants, diplomats or plain visitors
 - `spectate`: added persistent configuration of the plugin settings
 - `gui/cp437-table`: new global keybinding for the clickable on-screen keyboard for players with keyboard layouts that prevent them from using certain keys: Ctrl-Shift-K
 - `quickfort-library-guide`: dreamfort blueprint improvements: added a quantum stockpile for training bolts

docs/plugins/spectate.rst

@@ -38,11 +38,12 @@ Examples
 
 Features
 --------
-:focus-jobs:     Toggle whether the plugin should always be following a job. (default: disabled)
 :auto-unpause:   Toggle auto-dismissal of game pause events. (default: disabled)
 :auto-disengage: Toggle auto-disengagement of plugin through player intervention while unpaused. (default: disabled)
+:animals:        Toggle whether to sometimes follow animals. (default: disabled)
+:hostiles:       Toggle whether to sometimes follow hostiles (eg. undead, titan, invader, etc.) (default: disabled)
+:visiting:       Toggle whether to sometimes follow visiting units (eg. diplomat)
 
 Settings
 --------
-:tick-threshold: Set the plugin's tick interval for changing the followed dwarf.
+:tick-threshold: Set the plugin's tick interval for changing the followed dwarf. (default: 1000)
-                 Acts as a maximum follow time when used with focus-jobs enabled. (default: 50)

plugins/spectate/spectate.cpp

@@ -1,16 +1,19 @@
 //
 // Created by josh on 7/28/21.
+// Last updated: 11//10/22
 //
 
 #include "pause.h"
 
-#include "Core.h"
+#include <Debug.h>
-#include <modules/Gui.h>
+#include <Core.h>
-#include <Console.h>
 #include <Export.h>
 #include <PluginManager.h>
-#include <modules/World.h>
+
 #include <modules/EventManager.h>
+#include <modules/World.h>
+#include <modules/Maps.h>
+#include <modules/Gui.h>
 #include <modules/Job.h>
 #include <modules/Units.h>
 #include <df/job.h>
@@ -19,11 +22,17 @@
 #include <df/global_objects.h>
 #include <df/world.h>
 #include <df/viewscreen.h>
+#include <df/creature_raw.h>
 
-#include <map>
+#include <array>
-#include <set>
 #include <random>
 #include <cinttypes>
+#include <functional>
+
+// Debugging
+namespace DFHack {
+    DBG_DECLARE(spectate, plugin, DebugCategory::LINFO);
+}
 
 DFHACK_PLUGIN("spectate");
 DFHACK_PLUGIN_IS_ENABLED(enabled);
@@ -36,132 +45,292 @@ using namespace DFHack;
 using namespace Pausing;
 using namespace df::enums;
 
-void onTick(color_ostream& out, void* tick);
+struct Configuration {
-void onJobStart(color_ostream &out, void* job);
+    bool unpause = false;
-void onJobCompletion(color_ostream &out, void* job);
+    bool disengage = false;
+    bool animals = false;
+    bool hostiles = true;
+    bool visitors = false;
+    int32_t tick_threshold = 1000;
+} config;
 
-uint64_t tick_threshold = 1000;
-bool focus_jobs_enabled = false;
-bool disengage_enabled = false;
-bool unpause_enabled = false;
 Pausing::AnnouncementLock* pause_lock = nullptr;
 bool lock_collision = false;
 bool announcements_disabled = false;
 
-bool following_dwarf = false;
-df::unit* our_dorf = nullptr;
-df::job* job_watched = nullptr;
-int32_t timestamp = -1;
-
-std::set<int32_t> job_tracker;
-std::map<uint16_t,int16_t> freq;
-std::default_random_engine RNG;
-
-void enable_auto_unpause(color_ostream &out, bool state);
-
-
 #define base 0.99
 
 static const std::string CONFIG_KEY = std::string(plugin_name) + "/config";
 enum ConfigData {
     UNPAUSE,
     DISENGAGE,
-    JOB_FOCUS,
+    TICK_THRESHOLD,
-    TICK_THRESHOLD
+    ANIMALS,
+    HOSTILES,
+    VISITORS
+
 };
 
-static PersistentDataItem config;
+static PersistentDataItem pconfig;
-inline void saveConfig() {
-    if (config.isValid()) {
-        config.ival(UNPAUSE) = unpause_enabled;
-        config.ival(DISENGAGE) = disengage_enabled;
-        config.ival(JOB_FOCUS) = focus_jobs_enabled;
-        config.ival(TICK_THRESHOLD) = tick_threshold;
-    }
-}
 
+DFhackCExport command_result plugin_enable(color_ostream &out, bool enable);
 command_result spectate (color_ostream &out, std::vector <std::string> & parameters);
+#define COORDARGS(id) id.x, id.y, id.z
 
-DFhackCExport command_result plugin_init (color_ostream &out, std::vector <PluginCommand> &commands) {
+namespace SP {
-    commands.push_back(PluginCommand("spectate",
+    bool following_dwarf = false;
-                                     "Automated spectator mode.",
+    df::unit* our_dorf = nullptr;
-                                     spectate,
+    int32_t timestamp = -1;
-                                     false));
+    std::default_random_engine RNG;
-    pause_lock = new AnnouncementLock("spectate");
-    return CR_OK;
-}
 
-DFhackCExport command_result plugin_shutdown (color_ostream &out) {
+    void DebugUnitVector(std::vector<df::unit*> units) {
-    delete pause_lock;
+        if (debug_plugin.isEnabled(DFHack::DebugCategory::LDEBUG)) {
-    return CR_OK;
+            for (auto unit: units) {
-}
+                DEBUG(plugin).print("[id: %d]\n animal: %d\n hostile: %d\n visiting: %d\n",
+                                    unit->id,
+                                    Units::isAnimal(unit),
+                                    Units::isDanger(unit),
+                                    Units::isVisiting(unit));
+            }
+        }
+    }
 
-DFhackCExport command_result plugin_load_data (color_ostream &out) {
+    void PrintStatus(color_ostream &out) {
-    config = World::GetPersistentData(CONFIG_KEY);
+        out.print("Spectate is %s\n", enabled ? "ENABLED." : "DISABLED.");
+        out.print(" FEATURES:\n");
+        out.print("  %-20s\t%s\n", "auto-unpause: ", config.unpause ? "on." : "off.");
+        out.print("  %-20s\t%s\n", "auto-disengage: ", config.disengage ? "on." : "off.");
+        out.print("  %-20s\t%s\n", "animals: ", config.animals ? "on." : "off.");
+        out.print("  %-20s\t%s\n", "hostiles: ", config.hostiles ? "on." : "off.");
+        out.print("  %-20s\t%s\n", "visiting: ", config.visitors ? "on." : "off.");
+        out.print(" SETTINGS:\n");
+        out.print("  %-20s\t%" PRIi32 "\n", "tick-threshold: ", config.tick_threshold);
+        if (following_dwarf)
+            out.print(" %-21s\t%s[id: %d]\n","FOLLOWING:", our_dorf ? our_dorf->name.first_name.c_str() : "nullptr", df::global::ui->follow_unit);
+    }
 
-    if (!config.isValid()) {
+    void SetUnpauseState(bool state) {
-        config = World::AddPersistentData(CONFIG_KEY);
+        // we don't need to do any of this yet if the plugin isn't enabled
-        saveConfig();
+        if (enabled) {
+            // todo: R.E. UNDEAD_ATTACK event [still pausing regardless of announcement settings]
+            // lock_collision == true means: enable_auto_unpause() was already invoked and didn't complete
+            // The onupdate function above ensure the procedure properly completes, thus we only care about
+            // state reversal here ergo `enabled != state`
+            if (lock_collision && config.unpause != state) {
+                WARN(plugin).print("Spectate auto-unpause: Not enabled yet, there was a lock collision. When the other lock holder releases, auto-unpause will engage on its own.\n");
+                // if unpaused_enabled is true, then a lock collision means: we couldn't save/disable the pause settings,
+                // therefore nothing to revert and the lock won't even be engaged (nothing to unlock)
+                lock_collision = false;
+                config.unpause = state;
+                if (config.unpause) {
+                    // a collision means we couldn't restore the pause settings, therefore we only need re-engage the lock
+                    pause_lock->lock();
+                }
+                return;
+            }
+            // update the announcement settings if we can
+            if (state) {
+                if (World::SaveAnnouncementSettings()) {
+                    World::DisableAnnouncementPausing();
+                    announcements_disabled = true;
+                    pause_lock->lock();
+                } else {
+                    WARN(plugin).print("Spectate auto-unpause: Could not fully enable. There was a lock collision, when the other lock holder releases, auto-unpause will engage on its own.\n");
+                    lock_collision = true;
+                }
             } else {
-        unpause_enabled = config.ival(UNPAUSE);
-        disengage_enabled = config.ival(DISENGAGE);
-        focus_jobs_enabled = config.ival(JOB_FOCUS);
-        tick_threshold = config.ival(TICK_THRESHOLD);
                 pause_lock->unlock();
-        enable_auto_unpause(out, unpause_enabled);
+                if (announcements_disabled) {
+                    if (!World::RestoreAnnouncementSettings()) {
+                        // this in theory shouldn't happen, if others use the lock like we do in spectate
+                        WARN(plugin).print("Spectate auto-unpause: Could not fully disable. There was a lock collision, when the other lock holder releases, auto-unpause will disengage on its own.\n");
+                        lock_collision = true;
+                    } else {
+                        announcements_disabled = false;
+                    }
+                }
+            }
+            if (lock_collision) {
+                ERR(plugin).print("Spectate auto-unpause: Could not fully enable. There was a lock collision, when the other lock holder releases, auto-unpause will engage on its own.\n");
+                WARN(plugin).print(
+                            " auto-unpause: must wait for another Pausing::AnnouncementLock to be lifted.\n"
+                            " The action you were attempting will complete when the following lock or locks lift.\n");
+                pause_lock->reportLocks(Core::getInstance().getConsole());
+            }
+        }
+        config.unpause = state;
     }
-    return DFHack::CR_OK;
-}
 
-DFhackCExport command_result plugin_enable(color_ostream &out, bool enable) {
+    void SaveSettings() {
-    namespace EM = EventManager;
+        if (pconfig.isValid()) {
-    if (enable && !enabled) {
+            pconfig.ival(UNPAUSE) = config.unpause;
-        out.print("Spectate mode enabled!\n");
+            pconfig.ival(DISENGAGE) = config.disengage;
-        using namespace EM::EventType;
+            pconfig.ival(TICK_THRESHOLD) = config.tick_threshold;
-        EM::EventHandler ticking(onTick, 15);
+            pconfig.ival(ANIMALS) = config.animals;
-        EM::EventHandler start(onJobStart, 0);
+            pconfig.ival(HOSTILES) = config.hostiles;
-        EM::EventHandler complete(onJobCompletion, 0);
+            pconfig.ival(VISITORS) = config.visitors;
-        EM::registerListener(EventType::TICK, ticking, plugin_self);
+        }
-        EM::registerListener(EventType::JOB_STARTED, start, plugin_self);
-        EM::registerListener(EventType::JOB_COMPLETED, complete, plugin_self);
-        enabled = true; // enable_auto_unpause won't do anything without this set now
-        enable_auto_unpause(out, unpause_enabled);
-    } else if (!enable && enabled) {
-        // warp 8, engage!
-        out.print("Spectate mode disabled!\n");
-        EM::unregisterAll(plugin_self);
-        // we need to retain whether auto-unpause is enabled, but we also need to disable its effect
-        bool temp = unpause_enabled;
-        enable_auto_unpause(out, false);
-        unpause_enabled = temp;
-        job_tracker.clear();
-        freq.clear();
     }
-    enabled = enable;
-    return DFHack::CR_OK;
-}
 
-DFhackCExport command_result plugin_onstatechange(color_ostream &out, state_change_event event) {
+    void LoadSettings() {
-    if (enabled) {
+        pconfig = World::GetPersistentData(CONFIG_KEY);
-        switch (event) {
+
-            case SC_MAP_UNLOADED:
+        if (!pconfig.isValid()) {
-            case SC_BEGIN_UNLOAD:
+            pconfig = World::AddPersistentData(CONFIG_KEY);
-            case SC_WORLD_UNLOADED:
+            SaveSettings();
-                our_dorf = nullptr;
+        } else {
-                job_watched = nullptr;
+            config.unpause = pconfig.ival(UNPAUSE);
-                following_dwarf = false;
+            config.disengage = pconfig.ival(DISENGAGE);
+            config.tick_threshold = pconfig.ival(TICK_THRESHOLD);
+            config.animals = pconfig.ival(ANIMALS);
+            config.hostiles = pconfig.ival(HOSTILES);
+            config.visitors = pconfig.ival(VISITORS);
+            pause_lock->unlock();
+            SetUnpauseState(config.unpause);
+        }
+    }
+
+    bool FollowADwarf() {
+        if (enabled && !World::ReadPauseState()) {
+            df::coord viewMin = Gui::getViewportPos();
+            df::coord viewMax{viewMin};
+            const auto &dims = Gui::getDwarfmodeViewDims().map().second;
+            viewMax.x += dims.x - 1;
+            viewMax.y += dims.y - 1;
+            viewMax.z = viewMin.z;
+            std::vector<df::unit*> units;
+            static auto add_if = [&](std::function<bool(df::unit*)> check) {
+                for (auto unit : world->units.active) {
+                    if (check(unit)) {
+                        units.push_back(unit);
+                    }
+                }
+            };
+            static auto valid = [](df::unit* unit) {
+                if (Units::isAnimal(unit)) {
+                    return config.animals;
+                }
+                if (Units::isVisiting(unit)) {
+                    return config.visitors;
+                }
+                if (Units::isDanger(unit)) {
+                    return config.hostiles;
+                }
+                return true;
+            };
+            static auto calc_extra_weight = [](size_t idx, double r1, double r2) {
+                switch(idx) {
+                    case 0:
+                        return r2;
+                    case 1:
+                        return (r2-r1)/1.3;
+                    case 2:
+                        return (r2-r1)/2;
                     default:
-                break;
+                        return 0.0;
+                }
+            };
+            /// Collecting our choice pool
+            ///////////////////////////////
+            std::array<int32_t, 10> ranges{};
+            std::array<bool, 5> range_exists{};
+            static auto build_range = [&](size_t idx){
+                size_t first = idx * 2;
+                size_t second = idx * 2 + 1;
+                size_t previous = first - 1;
+                // first we get the end of the range
+                ranges[second] = units.size() - 1;
+                // then we calculate whether the range exists, and set the first index appropriately
+                if (idx == 0) {
+                    range_exists[idx] = ranges[second] >= 0;
+                    ranges[first] = 0;
+                } else {
+                    range_exists[idx] = ranges[second] > ranges[previous];
+                    ranges[first] = ranges[previous] +  (range_exists[idx] ? 1 : 0);
                 }
+            };
+
+            /// RANGE 0 (in view + working)
+            // grab valid working units
+            add_if([&](df::unit* unit) {
+                return valid(unit) &&
+                       Units::isUnitInBox(unit, COORDARGS(viewMin), COORDARGS(viewMax)) &&
+                       Units::isCitizen(unit, true) &&
+                       unit->job.current_job;
+            });
+            build_range(0);
+
+            /// RANGE 1 (in view)
+            add_if([&](df::unit* unit) {
+                return valid(unit) && Units::isUnitInBox(unit, COORDARGS(viewMin), COORDARGS(viewMax));
+            });
+            build_range(1);
+
+            /// RANGE 2 (working citizens)
+            add_if([](df::unit* unit) {
+                return valid(unit) && Units::isCitizen(unit, true) && unit->job.current_job;
+            });
+            build_range(2);
+
+            /// RANGE 3 (citizens)
+            add_if([](df::unit* unit) {
+                return valid(unit) && Units::isCitizen(unit, true);
+            });
+            build_range(3);
+
+            /// RANGE 4 (any valid)
+            add_if(valid);
+            build_range(4);
+
+            // selecting from our choice pool
+            if (!units.empty()) {
+                std::array<double, 5> bw{23,17,13,7,1}; // probability weights for each range
+                std::vector<double> i;
+                std::vector<double> w;
+                bool at_least_one = false;
+                // in one word, elegance
+                for(size_t idx = 0; idx < range_exists.size(); ++idx) {
+                    if (range_exists[idx]) {
+                        at_least_one = true;
+                        const auto &r1 = ranges[idx*2];
+                        const auto &r2 = ranges[idx*2+1];
+                        double extra = calc_extra_weight(idx, r1, r2);
+                        i.push_back(r1);
+                        w.push_back(bw[idx] + extra);
+                        if (r1 != r2) {
+                            i.push_back(r2);
+                            w.push_back(bw[idx] + extra);
+                        }
+                    }
+                }
+                if (!at_least_one) {
+                    return false;
+                }
+                DebugUnitVector(units);
+                std::piecewise_linear_distribution<> follow_any(i.begin(), i.end(), w.begin());
+                // if you're looking at a warning about a local address escaping, it means the unit* from units (which aren't local)
+                size_t idx = follow_any(RNG);
+                our_dorf = units[idx];
+                df::global::ui->follow_unit = our_dorf->id;
+                timestamp = df::global::world->frame_counter;
+                return true;
+            } else {
+                WARN(plugin).print("units vector is empty!\n");
+            }
+        }
+        return false;
     }
-    return CR_OK;
-}
 
-DFhackCExport command_result plugin_onupdate(color_ostream &out) {
+    void onUpdate(color_ostream &out) {
+        if (!World::isFortressMode() || !Maps::IsValid())
+            return;
+
         // keeps announcement pause settings locked
         World::Update(); // from pause.h
+
+        // Plugin Management
         if (lock_collision) {
-        if (unpause_enabled) {
+            if (config.unpause) {
                 // player asked for auto-unpause enabled
                 World::SaveAnnouncementSettings();
                 if (World::DisableAnnouncementPausing()) {
@@ -175,7 +344,7 @@ DFhackCExport command_result plugin_onupdate(color_ostream &out) {
             }
         }
         int failsafe = 0;
-    while (unpause_enabled && !world->status.popups.empty() && ++failsafe <= 10) {
+        while (config.unpause && !world->status.popups.empty() && ++failsafe <= 10) {
             // dismiss announcement popup(s)
             Gui::getCurViewscreen(true)->feed_key(interface_key::CLOSE_MEGA_ANNOUNCEMENT);
             if (World::ReadPauseState()) {
@@ -186,63 +355,83 @@ DFhackCExport command_result plugin_onupdate(color_ostream &out) {
         if (failsafe >= 10) {
             out.printerr("spectate encountered a problem dismissing a popup!\n");
         }
-    if (disengage_enabled && !World::ReadPauseState()) {
+
-        if (our_dorf && our_dorf->id != df::global::ui->follow_unit) {
+        // plugin logic
+        static int32_t last_tick = -1;
+        int32_t tick = world->frame_counter;
+        if (!World::ReadPauseState() && tick - last_tick >= 1) {
+            last_tick = tick;
+            // validate follow state
+            if (!following_dwarf || !our_dorf || df::global::ui->follow_unit < 0 || tick - timestamp >= config.tick_threshold) {
+                // we're not following anyone
+                following_dwarf = false;
+                if (!config.disengage) {
+                    // try to
+                    following_dwarf = FollowADwarf();
+                } else if (!World::ReadPauseState()) {
                     plugin_enable(out, false);
                 }
             }
+        }
+    }
+};
+
+DFhackCExport command_result plugin_init (color_ostream &out, std::vector <PluginCommand> &commands) {
+    commands.push_back(PluginCommand("spectate",
+                                     "Automated spectator mode.",
+                                     spectate,
+                                     false));
+    pause_lock = new AnnouncementLock("spectate");
+    return CR_OK;
+}
+
+DFhackCExport command_result plugin_shutdown (color_ostream &out) {
+    delete pause_lock;
+    return CR_OK;
+}
+
+DFhackCExport command_result plugin_load_data (color_ostream &out) {
+    SP::LoadSettings();
+    SP::following_dwarf = SP::FollowADwarf();
+    SP::PrintStatus(out);
     return DFHack::CR_OK;
 }
 
-void enable_auto_unpause(color_ostream &out, bool state) {
+DFhackCExport command_result plugin_enable(color_ostream &out, bool enable) {
-    // we don't need to do any of this yet if the plugin isn't enabled
+    if (enable && !enabled) {
-    if (enabled) {
+        out.print("Spectate mode enabled!\n");
-        // todo: R.E. UNDEAD_ATTACK event [still pausing regardless of announcement settings]
+        enabled = true; // enable_auto_unpause won't do anything without this set now
-        // lock_collision == true means: enable_auto_unpause() was already invoked and didn't complete
+        SP::SetUnpauseState(config.unpause);
-        // The onupdate function above ensure the procedure properly completes, thus we only care about
+    } else if (!enable && enabled) {
-        // state reversal here ergo `enabled != state`
+        // warp 8, engage!
-        if (lock_collision && unpause_enabled != state) {
+        out.print("Spectate mode disabled!\n");
-            out.print("handling collision\n");
+        // we need to retain whether auto-unpause is enabled, but we also need to disable its effect
-            // if unpaused_enabled is true, then a lock collision means: we couldn't save/disable the pause settings,
+        bool temp = config.unpause;
-            // therefore nothing to revert and the lock won't even be engaged (nothing to unlock)
+        SP::SetUnpauseState(false);
-            lock_collision = false;
+        config.unpause = temp;
-            unpause_enabled = state;
-            if (unpause_enabled) {
-                // a collision means we couldn't restore the pause settings, therefore we only need re-engage the lock
-                pause_lock->lock();
-            }
-            return;
-        }
-        // update the announcement settings if we can
-        if (state) {
-            if (World::SaveAnnouncementSettings()) {
-                World::DisableAnnouncementPausing();
-                announcements_disabled = true;
-                pause_lock->lock();
-            } else {
-                out.printerr("lock collision enabling auto-unpause\n");
-                lock_collision = true;
-            }
-        } else {
-            pause_lock->unlock();
-            if (announcements_disabled) {
-                if (!World::RestoreAnnouncementSettings()) {
-                    // this in theory shouldn't happen, if others use the lock like we do in spectate
-                    out.printerr("lock collision disabling auto-unpause\n");
-                    lock_collision = true;
-                } else {
-                    announcements_disabled = false;
-                }
-            }
     }
-        if (lock_collision) {
+    enabled = enable;
-            out.printerr(
+    return DFHack::CR_OK;
-                    "auto-unpause: must wait for another Pausing::AnnouncementLock to be lifted.\n"
+}
-                    "The action you were attempting will complete when the following lock or locks lift.\n");
+
-            pause_lock->reportLocks(out);
+DFhackCExport command_result plugin_onstatechange(color_ostream &out, state_change_event event) {
+    if (enabled) {
+        switch (event) {
+            case SC_MAP_UNLOADED:
+            case SC_BEGIN_UNLOAD:
+            case SC_WORLD_UNLOADED:
+                SP::our_dorf = nullptr;
+                SP::following_dwarf = false;
+            default:
+                break;
         }
     }
-    unpause_enabled = state;
+    return CR_OK;
+}
+
+DFhackCExport command_result plugin_onupdate(color_ostream &out) {
+    SP::onUpdate(out);
+    return DFHack::CR_OK;
 }
 
 command_result spectate (color_ostream &out, std::vector <std::string> & parameters) {
@@ -260,14 +449,18 @@ command_result spectate (color_ostream &out, std::vector <std::string> & paramet
                 return DFHack::CR_WRONG_USAGE;
             }
             if(parameters[1] == "auto-unpause"){
-                enable_auto_unpause(out, state);
+                SP::SetUnpauseState(state);
             } else if (parameters[1] == "auto-disengage") {
-                disengage_enabled = state;
+                config.disengage = state;
-            } else if (parameters[1] == "focus-jobs") {
+            } else if (parameters[1] == "animals") {
-                focus_jobs_enabled = state;
+                config.animals = state;
+            } else if (parameters[1] == "hostiles") {
+                config.hostiles = state;
+            } else if (parameters[1] == "visiting") {
+                config.visitors = state;
             } else if (parameters[1] == "tick-threshold" && set && parameters.size() == 3) {
                 try {
-                    tick_threshold = std::abs(std::stol(parameters[2]));
+                    config.tick_threshold = std::abs(std::stol(parameters[2]));
                 } catch (const std::exception &e) {
                     out.printerr("%s\n", e.what());
                 }
@@ -276,91 +469,8 @@ command_result spectate (color_ostream &out, std::vector <std::string> & paramet
             }
         }
     } else {
-        out.print("Spectate is %s\n", enabled ? "ENABLED." : "DISABLED.");
+        SP::PrintStatus(out);
-        out.print("tick-threshold: %" PRIu64 "\n", tick_threshold);
-        out.print("focus-jobs: %s\n", focus_jobs_enabled ? "on." : "off.");
-        out.print("auto-unpause: %s\n", unpause_enabled ? "on." : "off.");
-        out.print("auto-disengage: %s\n", disengage_enabled ? "on." : "off.");
     }
-    saveConfig();
+    SP::SaveSettings();
     return DFHack::CR_OK;
 }
-
-// every tick check whether to decide to follow a dwarf
-void onTick(color_ostream& out, void* ptr) {
-    int32_t tick = df::global::world->frame_counter;
-    if (our_dorf) {
-        if (!Units::isAlive(our_dorf)) {
-            following_dwarf = false;
-            df::global::ui->follow_unit = -1;
-        }
-    }
-    if (!following_dwarf || (focus_jobs_enabled && !job_watched) || (tick - timestamp) > (int32_t) tick_threshold) {
-        std::vector<df::unit*> dwarves;
-        for (auto unit: df::global::world->units.active) {
-            if (!Units::isCitizen(unit)) {
-                continue;
-            }
-            dwarves.push_back(unit);
-        }
-        std::uniform_int_distribution<uint64_t> follow_any(0, dwarves.size() - 1);
-        // if you're looking at a warning about a local address escaping, it means the unit* from dwarves (which aren't local)
-        our_dorf = dwarves[follow_any(RNG)];
-        df::global::ui->follow_unit = our_dorf->id;
-        job_watched = our_dorf->job.current_job;
-        following_dwarf = true;
-        if (!job_watched) {
-            timestamp = tick;
-        }
-    }
-}
-
-// every new worked job needs to be considered
-void onJobStart(color_ostream& out, void* job_ptr) {
-    // todo: detect mood jobs
-    int32_t tick = df::global::world->frame_counter;
-    auto job = (df::job*) job_ptr;
-    // don't forget about it
-    int zcount = ++freq[job->pos.z];
-    job_tracker.emplace(job->id);
-    // if we're not doing anything~ then let's pick something
-    if ((focus_jobs_enabled && !job_watched) || (tick - timestamp) > (int32_t) tick_threshold) {
-        following_dwarf = true;
-        // todo: allow the user to configure b, and also revise the math
-        const double b = base;
-        double p = b * ((double) zcount / job_tracker.size());
-        std::bernoulli_distribution follow_job(p);
-        if (!job->flags.bits.special && follow_job(RNG)) {
-            job_watched = job;
-            if (df::unit* unit = Job::getWorker(job)) {
-                our_dorf = unit;
-                df::global::ui->follow_unit = unit->id;
-            }
-        } else {
-            timestamp = tick;
-            std::vector<df::unit*> nonworkers;
-            for (auto unit: df::global::world->units.active) {
-                if (!Units::isCitizen(unit) || unit->job.current_job) {
-                    continue;
-                }
-                nonworkers.push_back(unit);
-            }
-            std::uniform_int_distribution<> follow_drunk(0, nonworkers.size() - 1);
-            df::global::ui->follow_unit = nonworkers[follow_drunk(RNG)]->id;
-        }
-    }
-}
-
-// every job completed can be forgotten about
-void onJobCompletion(color_ostream &out, void* job_ptr) {
-    auto job = (df::job*) job_ptr;
-    // forget about it
-    freq[job->pos.z]--;
-    freq[job->pos.z] = freq[job->pos.z] < 0 ? 0 : freq[job->pos.z];
-    // the job doesn't exist, so we definitely need to get rid of that
-    job_tracker.erase(job->id);
-    // the event manager clones jobs and returns those clones for completed jobs. So the pointers won't match without a refactor of EM passing clones to both events
-    if (job_watched && job_watched->id == job->id) {
-        job_watched = nullptr;
-    }
-}