2022-11-06 01:12:35 -06:00
|
|
|
/* Prevent channeling down into known open space.
|
|
|
|
Author: Josh Cooper
|
|
|
|
Created: Aug. 4 2020
|
2022-11-06 14:16:27 -07:00
|
|
|
Updated: Nov. 6 2022
|
2022-11-06 01:12:35 -06:00
|
|
|
|
|
|
|
Enable plugin:
|
|
|
|
-> build groups
|
|
|
|
-> manage designations
|
|
|
|
|
|
|
|
Unpause event:
|
|
|
|
-> build groups
|
|
|
|
-> manage designations
|
|
|
|
|
|
|
|
Manage Designation(s):
|
|
|
|
-> for each group in groups:
|
2022-11-06 14:16:27 -07:00
|
|
|
-> does any tile in group have a group above
|
|
|
|
-> Yes: set entire group to marker mode
|
|
|
|
-> No: activate entire group (still checks is_safe_to_dig_down before activating each designation)
|
2022-11-06 01:12:35 -06:00
|
|
|
|
|
|
|
Job started event:
|
|
|
|
-> validate job type (channel)
|
|
|
|
-> check pathing:
|
|
|
|
-> Can: add job/worker to tracking
|
|
|
|
-> Can: set tile to restricted
|
|
|
|
-> Cannot: remove worker
|
|
|
|
-> Cannot: insta-dig & delete job
|
|
|
|
-> Cannot: set designation to Marker Mode (no insta-digging)
|
|
|
|
|
|
|
|
OnUpdate:
|
|
|
|
-> check worker location:
|
|
|
|
-> CanFall: check if a fall would be safe:
|
|
|
|
-> Safe: do nothing
|
|
|
|
-> Unsafe: remove worker
|
|
|
|
-> Unsafe: insta-dig & delete job (presumes the job is only accessible from directly on the tile)
|
|
|
|
-> Unsafe: set designation to Marker Mode (no insta-digging)
|
|
|
|
-> check tile occupancy:
|
|
|
|
-> HasUnit: check if a fall would be safe:
|
|
|
|
-> Safe: do nothing, let them fall
|
|
|
|
-> Unsafe: remove worker for 1 tick (test if this "pauses" or cancels the job)
|
|
|
|
-> Unsafe: Add feature to teleport unit?
|
|
|
|
|
|
|
|
Job completed event:
|
|
|
|
-> validate job type (channel)
|
|
|
|
-> verify completion:
|
|
|
|
-> IsOpenSpace: mark done
|
|
|
|
-> IsOpenSpace: manage tile below
|
|
|
|
-> NotOpenSpace: check for designation
|
|
|
|
-> HasDesignation: do nothing
|
|
|
|
-> NoDesignation: mark done (erases from group)
|
|
|
|
-> NoDesignation: manage tile below
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <plugin.h>
|
|
|
|
#include <inlines.h>
|
|
|
|
#include <channel-manager.h>
|
2022-11-06 16:59:30 -07:00
|
|
|
#include <tile-cache.h>
|
2022-11-06 01:12:35 -06:00
|
|
|
|
|
|
|
#include <Debug.h>
|
|
|
|
#include <LuaTools.h>
|
|
|
|
#include <LuaWrapper.h>
|
|
|
|
#include <PluginManager.h>
|
|
|
|
#include <modules/EventManager.h>
|
2022-11-07 15:54:39 -07:00
|
|
|
#include <modules/Units.h>
|
|
|
|
#include <df/world.h>
|
|
|
|
#include <df/report.h>
|
|
|
|
#include <df/tile_traffic.h>
|
|
|
|
#include <df/block_square_event_designation_priorityst.h>
|
2022-11-06 01:12:35 -06:00
|
|
|
|
|
|
|
#include <cinttypes>
|
|
|
|
#include <unordered_map>
|
|
|
|
#include <unordered_set>
|
|
|
|
|
|
|
|
// Debugging
|
|
|
|
namespace DFHack {
|
2022-11-07 15:54:39 -07:00
|
|
|
DBG_DECLARE(channelsafely, plugin, DebugCategory::LINFO);
|
2022-11-06 18:02:11 -07:00
|
|
|
DBG_DECLARE(channelsafely, monitor, DebugCategory::LERROR);
|
|
|
|
DBG_DECLARE(channelsafely, manager, DebugCategory::LERROR);
|
|
|
|
DBG_DECLARE(channelsafely, groups, DebugCategory::LERROR);
|
|
|
|
DBG_DECLARE(channelsafely, jobs, DebugCategory::LERROR);
|
2022-11-06 01:12:35 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
DFHACK_PLUGIN("channel-safely");
|
|
|
|
DFHACK_PLUGIN_IS_ENABLED(enabled);
|
|
|
|
REQUIRE_GLOBAL(world);
|
|
|
|
|
|
|
|
namespace EM = EventManager;
|
|
|
|
using namespace DFHack;
|
|
|
|
using namespace EM::EventType;
|
|
|
|
|
|
|
|
int32_t mapx, mapy, mapz;
|
|
|
|
Configuration config;
|
2022-11-07 15:54:39 -07:00
|
|
|
PersistentDataItem psetting;
|
|
|
|
PersistentDataItem pfeature;
|
|
|
|
const std::string FCONFIG_KEY = std::string(plugin_name) + "/feature";
|
|
|
|
const std::string SCONFIG_KEY = std::string(plugin_name) + "/setting";
|
2022-11-06 01:12:35 -06:00
|
|
|
//std::unordered_set<int32_t> active_jobs;
|
|
|
|
|
2022-11-07 15:54:39 -07:00
|
|
|
enum FeatureConfigData {
|
2022-11-06 01:12:35 -06:00
|
|
|
VISION,
|
2022-11-07 15:54:39 -07:00
|
|
|
MONITOR,
|
|
|
|
RESURRECT,
|
|
|
|
INSTADIG
|
2022-11-06 01:12:35 -06:00
|
|
|
};
|
|
|
|
|
2022-11-07 15:54:39 -07:00
|
|
|
enum SettingConfigData {
|
|
|
|
REFRESH_RATE,
|
|
|
|
MONITOR_RATE,
|
|
|
|
IGNORE_THRESH,
|
|
|
|
FALL_THRESH
|
|
|
|
};
|
2022-11-06 01:12:35 -06:00
|
|
|
|
|
|
|
// executes dig designations for the specified tile coordinates
|
|
|
|
inline bool dig_now(color_ostream &out, const df::coord &map_pos) {
|
|
|
|
auto L = Lua::Core::State;
|
|
|
|
Lua::StackUnwinder top(L);
|
|
|
|
|
|
|
|
if (!lua_checkstack(L, 2) ||
|
|
|
|
!Lua::PushModulePublic(out, L, "plugins.dig-now", "dig_now_tile"))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Lua::Push(L, map_pos);
|
|
|
|
|
|
|
|
if (!Lua::SafeCall(out, L, 1, 1))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
return lua_toboolean(L, -1);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2022-11-07 15:54:39 -07:00
|
|
|
// fully heals the unit specified, resurrecting if need be
|
|
|
|
inline void resurrect(color_ostream &out, const int32_t &unit) {
|
|
|
|
std::vector<std::string> params{"-r", "--unit", std::to_string(unit)};
|
|
|
|
Core::getInstance().runCommand(out,"full-heal", params);
|
|
|
|
}
|
|
|
|
|
2022-11-06 01:12:35 -06:00
|
|
|
namespace CSP {
|
2022-11-07 15:54:39 -07:00
|
|
|
std::unordered_set<df::unit*> endangered_workers;
|
|
|
|
std::unordered_map<df::job*, int32_t> job_ids;
|
|
|
|
std::unordered_map<int32_t, df::job*> active_jobs;
|
|
|
|
std::unordered_map<int32_t, df::unit*> active_workers;
|
|
|
|
|
2022-11-06 01:12:35 -06:00
|
|
|
std::unordered_map<int32_t, df::coord> last_safe;
|
|
|
|
std::unordered_set<df::coord> dignow_queue;
|
|
|
|
|
2022-11-07 15:54:39 -07:00
|
|
|
void SaveSettings() {
|
|
|
|
if (pfeature.isValid() && psetting.isValid()) {
|
|
|
|
try {
|
|
|
|
pfeature.ival(MONITOR) = config.monitor_active;
|
|
|
|
pfeature.ival(VISION) = config.require_vision;
|
|
|
|
pfeature.ival(INSTADIG) = config.insta_dig;
|
|
|
|
pfeature.ival(RESURRECT) = config.resurrect;
|
|
|
|
|
|
|
|
psetting.ival(REFRESH_RATE) = config.refresh_freq;
|
|
|
|
psetting.ival(MONITOR_RATE) = config.monitor_freq;
|
|
|
|
psetting.ival(IGNORE_THRESH) = config.ignore_threshold;
|
|
|
|
psetting.ival(FALL_THRESH) = config.fall_threshold;
|
|
|
|
} catch (std::exception &e) {
|
|
|
|
ERR(plugin).print("%s\n", e.what());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void LoadSettings() {
|
|
|
|
pfeature = World::GetPersistentData(FCONFIG_KEY);
|
|
|
|
psetting = World::GetPersistentData(SCONFIG_KEY);
|
|
|
|
|
|
|
|
if (!pfeature.isValid() || !psetting.isValid()) {
|
|
|
|
pfeature = World::AddPersistentData(FCONFIG_KEY);
|
|
|
|
psetting = World::AddPersistentData(SCONFIG_KEY);
|
|
|
|
SaveSettings();
|
|
|
|
} else {
|
|
|
|
try {
|
|
|
|
config.monitor_active = pfeature.ival(MONITOR);
|
|
|
|
config.require_vision = pfeature.ival(VISION);
|
|
|
|
config.insta_dig = pfeature.ival(INSTADIG);
|
|
|
|
config.resurrect = pfeature.ival(RESURRECT);
|
|
|
|
|
|
|
|
config.ignore_threshold = psetting.ival(IGNORE_THRESH);
|
|
|
|
config.fall_threshold = psetting.ival(FALL_THRESH);
|
|
|
|
config.refresh_freq = psetting.ival(REFRESH_RATE);
|
|
|
|
config.monitor_freq = psetting.ival(MONITOR_RATE);
|
|
|
|
} catch (std::exception &e) {
|
|
|
|
ERR(plugin).print("%s\n", e.what());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
active_workers.clear();
|
|
|
|
}
|
|
|
|
|
2022-11-06 01:12:35 -06:00
|
|
|
void UnpauseEvent(){
|
|
|
|
INFO(monitor).print("UnpauseEvent()\n");
|
|
|
|
ChannelManager::Get().build_groups();
|
2022-11-06 12:53:46 -07:00
|
|
|
ChannelManager::Get().manage_groups();
|
2022-11-06 01:12:35 -06:00
|
|
|
ChannelManager::Get().debug();
|
|
|
|
INFO(monitor).print("UnpauseEvent() exits\n");
|
|
|
|
}
|
|
|
|
|
2022-11-06 18:02:11 -07:00
|
|
|
void JobStartedEvent(color_ostream &out, void* j) {
|
2022-11-06 13:09:38 -07:00
|
|
|
if (enabled && World::isFortressMode() && Maps::IsValid()) {
|
2022-11-06 18:02:11 -07:00
|
|
|
INFO(jobs).print("JobStartedEvent()\n");
|
|
|
|
auto job = (df::job*) j;
|
|
|
|
// validate job type
|
|
|
|
if (is_channel_job(job)) {
|
|
|
|
DEBUG(jobs).print(" valid channel job:\n");
|
|
|
|
df::unit* worker = Job::getWorker(job);
|
|
|
|
// there is a valid worker (living citizen) on the job? right..
|
|
|
|
if (worker && Units::isAlive(worker) && Units::isCitizen(worker)) {
|
|
|
|
DEBUG(jobs).print(" valid worker:\n");
|
|
|
|
// track workers on jobs
|
2022-11-07 15:54:39 -07:00
|
|
|
if (config.monitor_active || config.resurrect) {
|
|
|
|
job_ids.emplace(job, job->id);
|
|
|
|
active_jobs.emplace(job->id, job);
|
|
|
|
active_workers[job->id] = worker;
|
2022-11-06 01:12:35 -06:00
|
|
|
}
|
2022-11-06 18:02:11 -07:00
|
|
|
// set tile to restricted
|
|
|
|
TRACE(jobs).print(" setting job tile to restricted\n");
|
|
|
|
Maps::getTileDesignation(job->pos)->bits.traffic = df::tile_traffic::Restricted;
|
2022-11-06 01:12:35 -06:00
|
|
|
}
|
|
|
|
}
|
2022-11-06 18:02:11 -07:00
|
|
|
INFO(jobs).print(" <- JobStartedEvent() exits normally\n");
|
2022-11-06 01:12:35 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-06 18:02:11 -07:00
|
|
|
void JobCompletedEvent(color_ostream &out, void* j) {
|
2022-11-06 13:04:01 -07:00
|
|
|
if (enabled && World::isFortressMode() && Maps::IsValid()) {
|
2022-11-06 17:18:39 -07:00
|
|
|
INFO(jobs).print("JobCompletedEvent()\n");
|
2022-11-06 18:02:11 -07:00
|
|
|
auto job = (df::job*) j;
|
2022-11-06 13:04:01 -07:00
|
|
|
// we only care if the job is a channeling one
|
2022-11-06 16:59:30 -07:00
|
|
|
if (ChannelManager::Get().groups.count(job->pos)) {
|
2022-11-06 13:04:01 -07:00
|
|
|
// check job outcome
|
2022-11-06 16:59:30 -07:00
|
|
|
auto block = Maps::getTileBlock(job->pos);
|
2022-11-06 13:04:01 -07:00
|
|
|
df::coord local(job->pos);
|
|
|
|
local.x = local.x % 16;
|
|
|
|
local.y = local.y % 16;
|
|
|
|
// verify completion
|
2022-11-06 18:02:11 -07:00
|
|
|
if (TileCache::Get().hasChanged(job->pos, block->tiletype[Coord(local)])) {
|
2022-11-06 13:04:01 -07:00
|
|
|
// the job can be considered done
|
|
|
|
df::coord below(job->pos);
|
|
|
|
below.z--;
|
2022-11-07 15:54:39 -07:00
|
|
|
WARN(jobs).print(" -> (" COORD ") is marked done, managing group below.\n", COORDARGS(job->pos));
|
2022-11-06 13:04:01 -07:00
|
|
|
// mark done and manage below
|
2022-11-06 16:59:30 -07:00
|
|
|
block->designation[Coord(local)].bits.traffic = df::tile_traffic::Normal;
|
2022-11-06 13:04:01 -07:00
|
|
|
ChannelManager::Get().mark_done(job->pos);
|
|
|
|
ChannelManager::Get().manage_group(below);
|
|
|
|
ChannelManager::Get().debug();
|
2022-11-07 15:54:39 -07:00
|
|
|
} else {
|
|
|
|
ERR(jobs).print(" -> (" COORD ") is not done but the job \"completed\".\n", COORDARGS(job->pos));
|
|
|
|
endangered_workers.emplace(active_workers[job->id]);
|
|
|
|
}
|
|
|
|
// clean up
|
|
|
|
if (!config.resurrect) {
|
|
|
|
auto jp = active_jobs[job->id];
|
|
|
|
job_ids.erase(jp);
|
|
|
|
active_workers.erase(job->id);
|
|
|
|
active_jobs.erase(job->id);
|
2022-11-06 01:12:35 -06:00
|
|
|
}
|
|
|
|
}
|
2022-11-06 18:02:11 -07:00
|
|
|
INFO(jobs).print("JobCompletedEvent() exits\n");
|
2022-11-06 01:12:35 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-11-06 18:02:11 -07:00
|
|
|
void NewReportEvent(color_ostream &out, void* r) {
|
2022-11-07 15:54:39 -07:00
|
|
|
auto report_id = (int32_t)(intptr_t(r));
|
2022-11-06 19:07:22 -07:00
|
|
|
if (df::global::world) {
|
2022-11-07 15:54:39 -07:00
|
|
|
std::vector<df::report*> &reports = df::global::world->status.reports;
|
|
|
|
size_t idx = -1;
|
|
|
|
idx = df::report::binsearch_index(reports, report_id);
|
|
|
|
df::report* report = reports.at(idx);
|
|
|
|
switch (report->type) {
|
|
|
|
case announcement_type::CAVE_COLLAPSE:
|
|
|
|
for (auto p : active_workers) {
|
|
|
|
endangered_workers.emplace(p.second);
|
|
|
|
}
|
|
|
|
case announcement_type::CANCEL_JOB:
|
|
|
|
out.print("%d, pos: " COORD "\n%s\n", report_id, COORDARGS(report->pos), report->text.c_str());
|
|
|
|
default:
|
|
|
|
break;
|
2022-11-06 19:07:22 -07:00
|
|
|
}
|
|
|
|
}
|
2022-11-06 18:02:11 -07:00
|
|
|
}
|
|
|
|
|
2022-11-06 01:12:35 -06:00
|
|
|
void OnUpdate(color_ostream &out) {
|
|
|
|
if (enabled && World::isFortressMode() && Maps::IsValid() && !World::ReadPauseState()) {
|
2022-11-07 15:54:39 -07:00
|
|
|
static int32_t last_tick = df::global::world->frame_counter;
|
2022-11-06 01:12:35 -06:00
|
|
|
static int32_t last_monitor_tick = df::global::world->frame_counter;
|
|
|
|
static int32_t last_refresh_tick = df::global::world->frame_counter;
|
2022-11-07 15:54:39 -07:00
|
|
|
static int32_t last_resurrect_tick = df::global::world->frame_counter;
|
2022-11-06 01:12:35 -06:00
|
|
|
int32_t tick = df::global::world->frame_counter;
|
2022-11-07 15:54:39 -07:00
|
|
|
|
|
|
|
// Refreshing the group data with full scanning
|
2022-11-06 01:12:35 -06:00
|
|
|
if (tick - last_refresh_tick >= config.refresh_freq) {
|
|
|
|
last_refresh_tick = tick;
|
2022-11-06 18:02:11 -07:00
|
|
|
TRACE(monitor).print("OnUpdate() refreshing now\n");
|
2022-11-06 01:12:35 -06:00
|
|
|
UnpauseEvent();
|
2022-11-06 14:16:27 -07:00
|
|
|
|
2022-11-06 16:59:30 -07:00
|
|
|
if (config.insta_dig) {
|
|
|
|
TRACE(monitor).print(" -> evaluate dignow queue\n");
|
|
|
|
for (const df::coord &pos: dignow_queue) {
|
|
|
|
if (!has_unit(Maps::getTileOccupancy(pos))) {
|
|
|
|
out.print("channel-safely: insta-dig: Digging now!\n");
|
|
|
|
dig_now(out, pos);
|
|
|
|
} else {
|
|
|
|
// todo: teleport?
|
|
|
|
//Units::teleport()
|
|
|
|
}
|
2022-11-06 14:16:27 -07:00
|
|
|
}
|
2022-11-06 18:02:11 -07:00
|
|
|
TRACE(monitor).print("OnUpdate() refresh done\n");
|
2022-11-06 14:16:27 -07:00
|
|
|
}
|
2022-11-06 01:12:35 -06:00
|
|
|
}
|
2022-11-07 15:54:39 -07:00
|
|
|
|
|
|
|
// Clean up stale df::job*
|
|
|
|
if ((config.monitor_active || config.resurrect) && tick - last_tick >= 1) {
|
|
|
|
last_tick = tick;
|
|
|
|
// make note of valid jobs
|
|
|
|
std::unordered_map<int32_t, df::job*> valid_jobs;
|
|
|
|
for (df::job_list_link* link = &df::global::world->jobs.list; link != nullptr; link = link->next) {
|
|
|
|
df::job* job = link->item;
|
|
|
|
if (job && active_jobs.count(job->id)) {
|
|
|
|
valid_jobs.emplace(job->id, job);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// erase the active jobs that aren't valid
|
|
|
|
std::unordered_set<df::job*> erase;
|
|
|
|
map_value_difference(active_jobs, valid_jobs, erase);
|
|
|
|
for (auto j : erase) {
|
|
|
|
auto id = job_ids[j];
|
|
|
|
job_ids.erase(j);
|
|
|
|
active_jobs.erase(id);
|
|
|
|
active_workers.erase(id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Monitoring Active and Resurrecting Dead
|
2022-11-06 01:12:35 -06:00
|
|
|
if (config.monitor_active && tick - last_monitor_tick >= config.monitor_freq) {
|
|
|
|
last_monitor_tick = tick;
|
2022-11-06 18:02:11 -07:00
|
|
|
TRACE(monitor).print("OnUpdate() monitoring now\n");
|
2022-11-07 15:54:39 -07:00
|
|
|
|
|
|
|
// iterate active jobs
|
|
|
|
for (auto pair: active_jobs) {
|
|
|
|
df::job* job = pair.second;
|
|
|
|
df::unit* unit = active_workers[job->id];
|
|
|
|
if (!unit) continue;
|
|
|
|
TRACE(monitor).print(" -> check for job in tracking\n");
|
|
|
|
if (Units::isAlive(unit)) {
|
|
|
|
if (!config.monitor_active) continue;
|
|
|
|
TRACE(monitor).print(" -> compare positions of worker and job\n");
|
|
|
|
|
|
|
|
// save position
|
|
|
|
if (unit->pos != job->pos && isFloorTerrain(*Maps::getTileType(unit->pos))) {
|
|
|
|
// worker is perfectly safe right now
|
|
|
|
last_safe[unit->id] = unit->pos;
|
|
|
|
TRACE(monitor).print(" -> save safe position\n");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
// check for fall safety
|
|
|
|
if (unit->pos == job->pos && !is_safe_fall(job->pos)) {
|
|
|
|
// unsafe
|
|
|
|
WARN(monitor).print(" -> unsafe job\n");
|
|
|
|
Job::removeWorker(job);
|
|
|
|
|
|
|
|
// decide to insta-dig or marker mode
|
|
|
|
if (config.insta_dig) {
|
|
|
|
// delete the job
|
|
|
|
Job::removeJob(job);
|
|
|
|
// queue digging the job instantly
|
|
|
|
dignow_queue.emplace(job->pos);
|
|
|
|
DEBUG(monitor).print(" -> insta-dig\n");
|
|
|
|
} else if (Maps::isValidTilePos(job->pos)) {
|
|
|
|
// set marker mode
|
|
|
|
Maps::getTileOccupancy(job->pos)->bits.dig_marked = true;
|
|
|
|
|
|
|
|
// prevent algorithm from re-enabling designation
|
|
|
|
for (auto &be: Maps::getBlock(job->pos)->block_events) { ;
|
|
|
|
if (auto bsedp = virtual_cast<df::block_square_event_designation_priorityst>(
|
|
|
|
be)) {
|
|
|
|
df::coord local(job->pos);
|
|
|
|
local.x = local.x % 16;
|
|
|
|
local.y = local.y % 16;
|
|
|
|
bsedp->priority[Coord(local)] = config.ignore_threshold * 1000 + 1;
|
|
|
|
break;
|
2022-11-06 01:12:35 -06:00
|
|
|
}
|
|
|
|
}
|
2022-11-07 15:54:39 -07:00
|
|
|
DEBUG(monitor).print(" -> set marker mode\n");
|
2022-11-06 01:12:35 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-11-06 18:02:11 -07:00
|
|
|
TRACE(monitor).print("OnUpdate() monitoring done\n");
|
2022-11-06 01:12:35 -06:00
|
|
|
}
|
2022-11-07 15:54:39 -07:00
|
|
|
|
|
|
|
if (config.resurrect && tick - last_resurrect_tick >= 1) {
|
|
|
|
last_resurrect_tick = tick;
|
|
|
|
static std::unordered_map<df::unit*, int32_t> age;
|
|
|
|
|
|
|
|
// clean up any "endangered" workers that have been tracked 100 ticks or more
|
|
|
|
for (auto iter = age.begin(); iter != age.end();) {
|
|
|
|
if (tick - iter->second >= 1200) { //keep watch 1 day
|
|
|
|
iter = age.erase(iter);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
++iter;
|
|
|
|
}
|
|
|
|
|
|
|
|
// resurrect any dead units
|
|
|
|
for (auto unit : endangered_workers) {
|
|
|
|
age.emplace(unit, tick);
|
|
|
|
if (!Units::isAlive(unit)) {
|
|
|
|
resurrect(out, unit->id);
|
|
|
|
Units::teleport(unit, last_safe[unit->id]);
|
|
|
|
WARN(plugin).print(">RESURRECTING<\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-11-06 01:12:35 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
command_result channel_safely(color_ostream &out, std::vector<std::string> ¶meters);
|
|
|
|
|
|
|
|
DFhackCExport command_result plugin_init(color_ostream &out, std::vector<PluginCommand> &commands) {
|
|
|
|
commands.push_back(PluginCommand("channel-safely",
|
|
|
|
"Automatically manage channel designations.",
|
|
|
|
channel_safely,
|
|
|
|
false));
|
|
|
|
return CR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
DFhackCExport command_result plugin_shutdown(color_ostream &out) {
|
|
|
|
EM::unregisterAll(plugin_self);
|
|
|
|
return CR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
DFhackCExport command_result plugin_load_data (color_ostream &out) {
|
2022-11-07 15:54:39 -07:00
|
|
|
CSP::LoadSettings();
|
|
|
|
if (enabled) {
|
|
|
|
std::vector<std::string> params;
|
|
|
|
channel_safely(out, params);
|
2022-11-06 01:12:35 -06:00
|
|
|
}
|
|
|
|
return DFHack::CR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
DFhackCExport command_result plugin_enable(color_ostream &out, bool enable) {
|
|
|
|
if (enable && !enabled) {
|
|
|
|
// register events to check jobs / update tracking
|
|
|
|
EM::EventHandler jobStartHandler(CSP::JobStartedEvent, 0);
|
|
|
|
EM::EventHandler jobCompletionHandler(CSP::JobCompletedEvent, 0);
|
2022-11-06 18:02:11 -07:00
|
|
|
EM::EventHandler reportHandler(CSP::NewReportEvent, 0);
|
2022-11-06 19:07:22 -07:00
|
|
|
EM::registerListener(EventType::REPORT, reportHandler, plugin_self);
|
2022-11-06 01:12:35 -06:00
|
|
|
EM::registerListener(EventType::JOB_STARTED, jobStartHandler, plugin_self);
|
|
|
|
EM::registerListener(EventType::JOB_COMPLETED, jobCompletionHandler, plugin_self);
|
|
|
|
// manage designations to start off (first time building groups [very important])
|
|
|
|
out.print("channel-safely: enabled!\n");
|
|
|
|
CSP::UnpauseEvent();
|
|
|
|
} else if (!enable) {
|
|
|
|
// don't need the groups if the plugin isn't going to be enabled
|
|
|
|
EM::unregisterAll(plugin_self);
|
|
|
|
out.print("channel-safely: disabled!\n");
|
|
|
|
}
|
|
|
|
enabled = enable;
|
|
|
|
return CR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
DFhackCExport command_result plugin_onstatechange(color_ostream &out, state_change_event event) {
|
|
|
|
if (enabled && World::isFortressMode() && Maps::IsValid()) {
|
|
|
|
switch (event) {
|
|
|
|
case SC_MAP_LOADED:
|
2022-11-07 15:54:39 -07:00
|
|
|
CSP::active_workers.clear();
|
2022-11-06 01:12:35 -06:00
|
|
|
// cache the map size
|
|
|
|
Maps::getSize(mapx, mapy, mapz);
|
|
|
|
case SC_UNPAUSED:
|
|
|
|
// manage all designations on unpause
|
|
|
|
CSP::UnpauseEvent();
|
|
|
|
default:
|
2022-11-06 12:53:46 -07:00
|
|
|
return DFHack::CR_OK;
|
2022-11-06 01:12:35 -06:00
|
|
|
}
|
|
|
|
}
|
2022-11-06 12:53:46 -07:00
|
|
|
switch (event) {
|
|
|
|
case SC_WORLD_LOADED:
|
|
|
|
case SC_WORLD_UNLOADED:
|
|
|
|
case SC_MAP_UNLOADED:
|
|
|
|
// destroy any old group data
|
|
|
|
out.print("channel-safely: unloading data!\n");
|
|
|
|
ChannelManager::Get().destroy_groups();
|
|
|
|
case SC_MAP_LOADED:
|
|
|
|
// cache the map size
|
|
|
|
Maps::getSize(mapx, mapy, mapz);
|
|
|
|
default:
|
|
|
|
return DFHack::CR_OK;
|
|
|
|
}
|
2022-11-06 01:12:35 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
DFhackCExport command_result plugin_onupdate(color_ostream &out, state_change_event event) {
|
|
|
|
CSP::OnUpdate(out);
|
|
|
|
return DFHack::CR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
command_result channel_safely(color_ostream &out, std::vector<std::string> ¶meters) {
|
|
|
|
if (!parameters.empty()) {
|
|
|
|
if (parameters.size() >= 2 && parameters.size() <= 3) {
|
|
|
|
if (parameters[0] == "run" && parameters[1] == "once") {
|
|
|
|
CSP::UnpauseEvent();
|
|
|
|
return DFHack::CR_OK;
|
|
|
|
}
|
|
|
|
bool state = false;
|
|
|
|
bool set = false;
|
|
|
|
if (parameters[0] == "enable") {
|
|
|
|
state = true;
|
|
|
|
} else if (parameters[0] == "disable") {
|
|
|
|
state = false;
|
|
|
|
} else if (parameters[0] == "set") {
|
|
|
|
set = true;
|
|
|
|
} else {
|
|
|
|
return DFHack::CR_WRONG_USAGE;
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
if (parameters[1] == "debug") {
|
|
|
|
auto level = std::abs(std::stol(parameters[2]));
|
|
|
|
config.debug = true;
|
|
|
|
switch (level) {
|
|
|
|
case 1:
|
|
|
|
DBG_NAME(manager).allowed(DFHack::DebugCategory::LDEBUG);
|
|
|
|
DBG_NAME(monitor).allowed(DFHack::DebugCategory::LINFO);
|
|
|
|
DBG_NAME(groups).allowed(DFHack::DebugCategory::LINFO);
|
|
|
|
DBG_NAME(jobs).allowed(DFHack::DebugCategory::LINFO);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
DBG_NAME(manager).allowed(DFHack::DebugCategory::LTRACE);
|
|
|
|
DBG_NAME(monitor).allowed(DFHack::DebugCategory::LINFO);
|
|
|
|
DBG_NAME(groups).allowed(DFHack::DebugCategory::LDEBUG);
|
|
|
|
DBG_NAME(jobs).allowed(DFHack::DebugCategory::LDEBUG);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
DBG_NAME(manager).allowed(DFHack::DebugCategory::LTRACE);
|
|
|
|
DBG_NAME(monitor).allowed(DFHack::DebugCategory::LINFO);
|
|
|
|
DBG_NAME(groups).allowed(DFHack::DebugCategory::LDEBUG);
|
|
|
|
DBG_NAME(jobs).allowed(DFHack::DebugCategory::LTRACE);
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
DBG_NAME(manager).allowed(DFHack::DebugCategory::LTRACE);
|
|
|
|
DBG_NAME(monitor).allowed(DFHack::DebugCategory::LINFO);
|
|
|
|
DBG_NAME(groups).allowed(DFHack::DebugCategory::LTRACE);
|
|
|
|
DBG_NAME(jobs).allowed(DFHack::DebugCategory::LTRACE);
|
|
|
|
break;
|
|
|
|
case 5:
|
|
|
|
DBG_NAME(manager).allowed(DFHack::DebugCategory::LTRACE);
|
|
|
|
DBG_NAME(monitor).allowed(DFHack::DebugCategory::LDEBUG);
|
|
|
|
DBG_NAME(groups).allowed(DFHack::DebugCategory::LTRACE);
|
|
|
|
DBG_NAME(jobs).allowed(DFHack::DebugCategory::LTRACE);
|
|
|
|
break;
|
|
|
|
case 6:
|
|
|
|
DBG_NAME(manager).allowed(DFHack::DebugCategory::LTRACE);
|
|
|
|
DBG_NAME(monitor).allowed(DFHack::DebugCategory::LTRACE);
|
|
|
|
DBG_NAME(groups).allowed(DFHack::DebugCategory::LTRACE);
|
|
|
|
DBG_NAME(jobs).allowed(DFHack::DebugCategory::LTRACE);
|
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
default:
|
|
|
|
DBG_NAME(monitor).allowed(DFHack::DebugCategory::LERROR);
|
|
|
|
DBG_NAME(manager).allowed(DFHack::DebugCategory::LERROR);
|
|
|
|
DBG_NAME(groups).allowed(DFHack::DebugCategory::LERROR);
|
|
|
|
DBG_NAME(jobs).allowed(DFHack::DebugCategory::LERROR);
|
|
|
|
}
|
2022-11-07 15:54:39 -07:00
|
|
|
} else if(parameters[1] == "monitor"){
|
|
|
|
if (state != config.monitor_active) {
|
|
|
|
config.monitor_active = state;
|
|
|
|
// if this is a fresh start
|
|
|
|
if (state && !config.resurrect) {
|
|
|
|
// we need a fresh start
|
|
|
|
CSP::active_workers.clear();
|
|
|
|
}
|
|
|
|
}
|
2022-11-06 01:12:35 -06:00
|
|
|
} else if (parameters[1] == "require-vision") {
|
|
|
|
config.require_vision = state;
|
|
|
|
} else if (parameters[1] == "insta-dig") {
|
|
|
|
config.insta_dig = state;
|
2022-11-07 15:54:39 -07:00
|
|
|
} else if (parameters[1] == "resurrect") {
|
|
|
|
if (state != config.resurrect) {
|
|
|
|
config.resurrect = state;
|
|
|
|
// if this is a fresh start
|
|
|
|
if (state && !config.monitor_active) {
|
|
|
|
// we need a fresh start
|
|
|
|
CSP::active_workers.clear();
|
|
|
|
}
|
|
|
|
}
|
2022-11-06 01:12:35 -06:00
|
|
|
} else if (parameters[1] == "refresh-freq" && set && parameters.size() == 3) {
|
|
|
|
config.refresh_freq = std::abs(std::stol(parameters[2]));
|
|
|
|
} else if (parameters[1] == "monitor-freq" && set && parameters.size() == 3) {
|
|
|
|
config.monitor_freq = std::abs(std::stol(parameters[2]));
|
|
|
|
} else if (parameters[1] == "ignore-threshold" && set && parameters.size() == 3) {
|
|
|
|
config.ignore_threshold = std::abs(std::stol(parameters[2]));
|
|
|
|
} else if (parameters[1] == "fall-threshold" && set && parameters.size() == 3) {
|
|
|
|
uint8_t t = std::abs(std::stol(parameters[2]));
|
|
|
|
if (t > 0) {
|
|
|
|
config.fall_threshold = t;
|
|
|
|
} else {
|
|
|
|
out.printerr("fall-threshold must have a value greater than 0 or the plugin does a lot of nothing.\n");
|
|
|
|
return DFHack::CR_FAILURE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return DFHack::CR_WRONG_USAGE;
|
|
|
|
}
|
|
|
|
} catch (const std::exception &e) {
|
|
|
|
out.printerr("%s\n", e.what());
|
|
|
|
return DFHack::CR_FAILURE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
out.print("Channel-Safely is %s\n", enabled ? "ENABLED." : "DISABLED.");
|
2022-11-07 15:54:39 -07:00
|
|
|
out.print(" FEATURES:\n");
|
|
|
|
out.print(" %-20s\t%s\n", "monitor-active: ", config.monitor_active ? "on." : "off.");
|
|
|
|
out.print(" %-20s\t%s\n", "require-vision: ", config.require_vision ? "on." : "off.");
|
|
|
|
out.print(" %-20s\t%s\n", "insta-dig: ", config.insta_dig ? "on." : "off.");
|
|
|
|
out.print(" %-20s\t%s\n", "resurrect: ", config.resurrect ? "on." : "off.");
|
|
|
|
out.print(" SETTINGS:\n");
|
|
|
|
out.print(" %-20s\t%" PRIi32 "\n", "refresh-freq: ", config.refresh_freq);
|
|
|
|
out.print(" %-20s\t%" PRIi32 "\n", "monitor-freq: ", config.monitor_freq);
|
|
|
|
out.print(" %-20s\t%" PRIu8 "\n", "ignore-threshold: ", config.ignore_threshold);
|
|
|
|
out.print(" %-20s\t%" PRIu8 "\n", "fall-threshold: ", config.fall_threshold);
|
2022-11-06 01:12:35 -06:00
|
|
|
}
|
2022-11-07 15:54:39 -07:00
|
|
|
CSP::SaveSettings();
|
2022-11-06 01:12:35 -06:00
|
|
|
return DFHack::CR_OK;
|
|
|
|
}
|