//! MainThread::suspend keeps the main DF thread suspended from Core::Init to

//! thread exit.

static CoreSuspenderBase& suspend() {

static thread_local CoreSuspenderBase lock{};

return lock;

}

*this = {};

ignore_pause_state = ignorePauseState;

baseline_elapsed_ms = Core::getInstance().p->getTickCount();

if (!ignore_pause_state && (!World::isFortressMode() || World::ReadPauseState()))

return;

counter += Core::getInstance().p->getTickCount() - baseline_ms;

if (!World::isFortressMode() || World::ReadPauseState()) {

last_tick_baseline_ms = 0;

return 0;

}

// only update when the tick counter has advanced

if (!world || last_frame_counter == world->frame_counter)

return 0;

last_frame_counter = world->frame_counter;

if (last_tick_baseline_ms == 0) {

last_tick_baseline_ms = baseline_ms;

return 0;

}

uint32_t elapsed_ms = baseline_ms - last_tick_baseline_ms;

last_tick_baseline_ms = baseline_ms;

recent_ticks.head_idx = (recent_ticks.head_idx + 1) % RECENT_TICKS_HISTORY_SIZE;

if (recent_ticks.full)

recent_ticks.sum_ms -= recent_ticks.history[recent_ticks.head_idx];

else if (recent_ticks.head_idx == 0)

recent_ticks.full = true;

recent_ticks.history[recent_ticks.head_idx] = elapsed_ms;

recent_ticks.sum_ms += elapsed_ms;

return elapsed_ms;

uint32_t seconds = recent_ticks.sum_ms / 1000;

if (seconds == 0)

return 0;

size_t num_frames = recent_ticks.full ? RECENT_TICKS_HISTORY_SIZE : recent_ticks.head_idx;

return num_frames / seconds;

{

static const int MAX_DEPTH = 20;

static thread_local int depth;

CommandDepthCounter() { depth++; }

~CommandDepthCounter() { depth--; }

bool ok() { return depth < MAX_DEPTH; }

{

std::string *cur = NULL;

size_t i = 0;

// Check the first non-space character

while (i < input.size() && isspace(input[i])) i++;

// Special verbatim argument mode?

if (i < input.size() && input[i] == ':')

{

// Read the command

std::string cmd;

i++;

while (i < input.size() && !isspace(input[i]))

cmd.push_back(input[i++]);

if (!cmd.empty())

output.push_back(cmd);

// Find the argument

while (i < input.size() && isspace(input[i])) i++;

if (i < input.size())

output.push_back(input.substr(i));

return;

}

// Otherwise, parse in the regular quoted mode

for (; i < input.size(); i++)

{

unsigned char c = input[i];

if (isspace(c)) {

cur = NULL;

} else {

if (!cur) {

output.push_back("");

cur = &output.back();

}

if (c == '"') {

for (i++; i < input.size(); i++) {

c = input[i];

if (c == '"')

break;

else if (c == '\\') {

if (++i < input.size())

cur->push_back(input[i]);

}

else

cur->push_back(c);

}

} else {

cur->push_back(c);

}

}

}

{

Core * core;

PluginManager * plug_mgr;

{

Core * core = iodata->core;

PluginManager * plug_mgr = iodata->plug_mgr;

if(plug_mgr == 0 || core == 0)

{

std::cerr << "Hotkey thread has croaked." << std::endl;

return;

}

bool keep_going = true;

while(keep_going)

{

std::string stuff = core->getHotkeyCmd(keep_going); // waits on mutex!

if(!stuff.empty())

{

color_ostream_proxy out(core->getConsole());

auto rv = core->runCommand(out, stuff);

if (rv == CR_NOT_IMPLEMENTED)

out.printerr("Invalid hotkey command: '%s'\n", stuff.c_str());

}

}

{

bool recolor;

std::string name;

std::string description;

//FIXME: Nuke when MSVC stops failing at being C++11 compliant

sortable(bool recolor_,const std::string& name_,const std::string & description_): recolor(recolor_), name(name_), description(description_){};

bool operator <(const sortable & rhs) const

{

if( name < rhs.name )

return true;

return false;

};

{

std::stringstream s;

s << Version::dfhack_version() << " ";

if (Version::is_release())

s << "(release)";

else

s << "(git: " << Version::git_commit(true) << ")";

s << " on " << (sizeof(void*) == 8 ? "x86_64" : "x86");

if (strlen(Version::dfhack_build_id()))

s << " [build ID: " << Version::dfhack_build_id() << "]";

return s.str();

{

if (!lua_checkstack(state, pargs.size()+10))

return false;

Lua::PushDFHack(state);

lua_getfield(state, -1, "run_script");

lua_remove(state, -2);

lua_pushstring(state, pcmd.c_str());

for (auto& arg : pargs)

lua_pushstring(state, arg.c_str());

return true;

{

using namespace std::placeholders;

auto init_fn = std::bind(init_run_script, _1, _2, name, args);

bool ok = Lua::RunCoreQueryLoop(out, DFHack::Core::getInstance().getLuaState(true), init_fn);

return ok ? CR_OK : CR_FAILURE;

{

if (!lua_checkstack(state, 4))

return false;

Lua::PushDFHack(state);

lua_getfield(state, -1, "enable_script");

lua_remove(state, -2);

lua_pushstring(state, name.c_str());

lua_pushboolean(state, enable);

return true;

{

using namespace std::placeholders;

auto init_fn = std::bind(init_enable_script, _1, _2, name, state);

bool ok = Lua::RunCoreQueryLoop(out, DFHack::Core::getInstance().getLuaState(), init_fn);

return ok ? CR_OK : CR_FAILURE;

{

if (!command.empty())

{

std::vector <std::string> parts;

Core::cheap_tokenise(command,parts);

if(parts.size() == 0)

return CR_NOT_IMPLEMENTED;

std::string first = parts[0];

parts.erase(parts.begin());

if (first[0] == '#')

return CR_OK;

std::cerr << "Invoking: " << command << std::endl;

return runCommand(out, first, parts);

}

else

return CR_NOT_IMPLEMENTED;

CoreSuspender suspend;

auto L = DFHack::Core::getInstance().getLuaState();

Lua::StackUnwinder top(L);

if (!lua_checkstack(L, 1) ||

!Lua::PushModulePublic(con, L, "helpdb", "is_builtin")) {

con.printerr("Failed to load helpdb Lua code\n");

return false;

}

Lua::Push(L, command);

if (!Lua::SafeCall(con, L, 1, 1)) {

con.printerr("Failed Lua call to helpdb.is_builtin.\n");

return false;

}

return lua_toboolean(L, -1);

ConditionalCoreSuspender suspend{};

if (!suspend) {

con.printerr("Cannot acquire core lock in helpdb.get_commands\n");

commands.clear();

return;

}

auto L = DFHack::Core::getInstance().getLuaState();

Lua::StackUnwinder top(L);

if (!lua_checkstack(L, 1) ||

!Lua::PushModulePublic(con, L, "helpdb", "get_commands")) {

con.printerr("Failed to load helpdb Lua code\n");

return;

}

if (!Lua::SafeCall(con, L, 0, 1)) {

con.printerr("Failed Lua call to helpdb.get_commands.\n");

}

Lua::GetVector(L, commands, top + 1);

{

std::vector<std::string> commands, possible;

get_commands(con, commands);

for (auto &command : commands)

if (command.substr(0, first.size()) == first)

possible.push_back(command);

if (possible.size() == 1)

{

completed = possible[0];

//fprintf(stderr, "Autocompleted %s to %s\n", , );

con.printerr("%s is not recognized. Did you mean %s?\n", first.c_str(), completed.c_str());

return true;

}

if (possible.size() > 1 && possible.size() < 8)

{

std::string out;

for (size_t i = 0; i < possible.size(); i++)

out += " " + possible[i];

con.printerr("%s is not recognized. Possible completions:%s\n", first.c_str(), out.c_str());

return true;

}

return false;

{

std::lock_guard<std::mutex> lock(script_path_mutex);

auto &vec = script_paths[search_before ? 0 : 1];

if (std::find(vec.begin(), vec.end(), path) != vec.end())

return false;

if (!Filesystem::isdir(path))

return false;

vec.push_back(path);

return true;

std::lock_guard<std::mutex> lock(script_path_mutex);

script_paths[2] = mod_script_paths;

return true;

{

std::lock_guard<std::mutex> lock(script_path_mutex);

bool found = false;

for (int i = 0; i < 2; i++)

{

auto &vec = script_paths[i];

while (1)

{

auto it = std::find(vec.begin(), vec.end(), path);

if (it == vec.end())

break;

vec.erase(it);

found = true;

}

}

return found;

{

std::lock_guard<std::mutex> lock(script_path_mutex);

dest->clear();

std::filesystem::path df_pref_path = Filesystem::getBaseDir();

std::filesystem::path df_install_path = Filesystem::getInstallDir();

for (auto & path : script_paths[0])

dest->emplace_back(path);

// should this be df_pref_path? probably

dest->push_back(getConfigPath() / "scripts");

if (df::global::world && isWorldLoaded()) {

std::string save = World::ReadWorldFolder();

if (save.size())

dest->emplace_back(df_pref_path / "save" / save / "scripts");

}

dest->emplace_back(df_install_path / "hack" / "scripts");

for (auto & path : script_paths[2])

dest->emplace_back(path);

for (auto & path : script_paths[1])

dest->emplace_back(path);

{

std::vector<std::filesystem::path> paths;

getScriptPaths(&paths);

for (auto it = paths.begin(); it != paths.end(); ++it)

{

std::filesystem::path path = std::filesystem::weakly_canonical(*it / name);

if (Filesystem::isfile(path))

return path;

}

return {};

{

std::filesystem::path filename{ getConfigPath() / "script-paths.txt" };

std::ifstream file(filename);

if (!file)

{

if (!silent)

out.printerr("Could not load %s\n", filename.c_str());

return false;

}

std::string raw;

int line = 0;

while (getline(file, raw))

{

++line;

std::istringstream ss(raw);

char ch;

ss >> std::skipws;

if (!(ss >> ch) || ch == '#')

continue;

ss >> std::ws; // discard whitespace

std::string path;

getline(ss, path);

if (ch == '+' || ch == '-')

{

if (!Core::getInstance().addScriptPath(path, ch == '+') && !silent)

out.printerr("%s:%i: Failed to add path: %s\n", filename.c_str(), line, path.c_str());

}

else if (!silent)

out.printerr("%s:%i: Illegal character: %c\n", filename.c_str(), line, ch);

}

return true;

std::vector<std::string> mod_script_paths_str;

std::vector<std::filesystem::path> mod_script_paths;

Lua::CallLuaModuleFunction(out, "script-manager", "get_mod_script_paths", {}, 1,

[&](lua_State *L) {

Lua::GetVector(L, mod_script_paths_str);

});

DEBUG(script,out).print("final mod script paths:\n");

for (auto& path : mod_script_paths_str)

{

DEBUG(script, out).print(" %s\n", path.c_str());

mod_script_paths.push_back(std::filesystem::weakly_canonical(std::filesystem::path{ path }));

}

Core::getInstance().setModScriptPaths(mod_script_paths);

if (!state_change_event_map.size())

{

#define insert(name) state_change_event_map.insert(std::pair<std::string, state_change_event>(#name, name))

insert(SC_WORLD_LOADED);

insert(SC_WORLD_UNLOADED);

insert(SC_MAP_LOADED);

insert(SC_MAP_UNLOADED);

insert(SC_VIEWSCREEN_CHANGED);

insert(SC_PAUSED);

insert(SC_UNPAUSED);

#undef insert

}

sc_event_map_init();

auto it = state_change_event_map.find(name);

if (it != state_change_event_map.end())

return it->second;

if (name.find("SC_") != 0)

return sc_event_id(std::string("SC_") + name);

return SC_UNKNOWN;

sc_event_map_init();

for (auto it = state_change_event_map.begin(); it != state_change_event_map.end(); ++it)

{

if (it->second == id)

return it->first;

}

return "SC_UNKNOWN";

ConditionalCoreSuspender suspend{};

if (!suspend) {

con.printerr("Failed Lua call to helpdb.help (could not acquire core lock).\n");

return;

}

auto L = DFHack::Core::getInstance().getLuaState();

Lua::StackUnwinder top(L);

if (!lua_checkstack(L, 2) ||

!Lua::PushModulePublic(con, L, "helpdb", "help")) {

con.printerr("Failed to load helpdb Lua code\n");

return;

}

Lua::Push(L, entry_name);

if (!Lua::SafeCall(con, L, 1, 0)) {

con.printerr("Failed Lua call to helpdb.help.\n");

}

ConditionalCoreSuspender suspend{};

if (!suspend) {

con.printerr("Failed Lua call to helpdb.help (could not acquire core lock).\n");

return;

}

auto L = DFHack::Core::getInstance().getLuaState();

Lua::StackUnwinder top(L);

if (!lua_checkstack(L, 1) ||

!Lua::PushModulePublic(con, L, "helpdb", "tags")) {

con.printerr("Failed to load helpdb Lua code\n");

return;

}

Lua::Push(L, tag);

if (!Lua::SafeCall(con, L, 1, 0)) {

con.printerr("Failed Lua call to helpdb.tags.\n");

}

std::vector<std::string> filter;

bool skip_tags = false;

bool show_dev_commands = false;

std::string exclude_strs = "";

bool in_exclude = false;

for (auto str : params) {

if (in_exclude)

exclude_strs = str;

else if (str == "--notags")

skip_tags = true;

else if (str == "--dev")

show_dev_commands = true;

else if (str == "--exclude")

in_exclude = true;

else

filter.push_back(str);

}

ConditionalCoreSuspender suspend{};

if (!suspend) {

con.printerr("Failed Lua call to helpdb.help (could not acquire core lock).\n");

return;

}

auto L = DFHack::Core::getInstance().getLuaState();

Lua::StackUnwinder top(L);

if (!lua_checkstack(L, 5) ||

!Lua::PushModulePublic(con, L, "helpdb", "ls")) {

con.printerr("Failed to load helpdb Lua code\n");

return;

}

Lua::PushVector(L, filter);

Lua::Push(L, skip_tags);

Lua::Push(L, show_dev_commands);

Lua::Push(L, exclude_strs);

if (!Lua::SafeCall(con, L, 4, 0)) {

con.printerr("Failed Lua call to helpdb.ls.\n");

}

{

std::string first = first_;

CommandDepthCounter counter;

if (!counter.ok())

{

con.printerr("Cannot invoke \"%s\": maximum command depth exceeded (%i)\n",

first.c_str(), CommandDepthCounter::MAX_DEPTH);

return CR_FAILURE;

}

if (first.empty())

return CR_NOT_IMPLEMENTED;

if (first.find('\\') != std::string::npos)

{

con.printerr("Replacing backslashes with forward slashes in \"%s\"\n", first.c_str());

for (size_t i = 0; i < first.size(); i++)

{

if (first[i] == '\\')

first[i] = '/';

}

}

// let's see what we actually got

command_result res;

if (first == "help" || first == "man" || first == "?")

{

if(!parts.size())

{

if (con.is_console())

{

con.print("This is the DFHack console. You can type commands in and manage DFHack plugins from it.\n"

"Some basic editing capabilities are included (single-line text editing).\n"

"The console also has a command history - you can navigate it with Up and Down keys.\n"

"On Windows, you may have to resize your console window. The appropriate menu is accessible\n"

"by clicking on the program icon in the top bar of the window.\n\n");

}

con.print("Here are some basic commands to get you started:\n"

" help|?|man - This text.\n"

" help <tool> - Usage help for the given plugin, command, or script.\n"

" tags - List the tags that the DFHack tools are grouped by.\n"

" ls|dir [<filter>] - List commands, optionally filtered by a tag or substring.\n"

" Optional parameters:\n"

" --notags: skip printing tags for each command.\n"

" --dev: include commands intended for developers and modders.\n"

" cls|clear - Clear the console.\n"

" fpause - Force DF to pause.\n"

" die - Force DF to close immediately, without saving.\n"

" keybinding - Modify bindings of commands to in-game key shortcuts.\n"

"\n"

"See more commands by running 'ls'.\n\n"

);

con.print("DFHack version %s\n", dfhack_version_desc().c_str());

}

else

{

help_helper(con, parts[0]);

}

}

else if (first == "tags")

{

tags_helper(con, parts.size() ? parts[0] : "");

}

else if (first == "load" || first == "unload" || first == "reload")

{

bool all = false;

bool load = (first == "load");

bool unload = (first == "unload");

bool reload = (first == "reload");

if (parts.size())

{

for (auto p = parts.begin(); p != parts.end(); p++)

{

if (p->size() && (*p)[0] == '-')

{

if (p->find('a') != std::string::npos)

all = true;

}

}

auto ret = CR_OK;

if (all)

{

if (load && !plug_mgr->loadAll())

ret = CR_FAILURE;

else if (unload && !plug_mgr->unloadAll())

ret = CR_FAILURE;

else if (reload && !plug_mgr->reloadAll())

ret = CR_FAILURE;

}

else

{

for (auto p = parts.begin(); p != parts.end(); p++)

{

if (!p->size() || (*p)[0] == '-')

continue;

if (load && !plug_mgr->load(*p))

ret = CR_FAILURE;

else if (unload && !plug_mgr->unload(*p))

ret = CR_FAILURE;

else if (reload && !plug_mgr->reload(*p))

ret = CR_FAILURE;

}

}

if (ret != CR_OK)

con.printerr("%s failed\n", first.c_str());

return ret;

}

else {

con.printerr("%s: no arguments\n", first.c_str());

return CR_FAILURE;

}

}

else if( first == "enable" || first == "disable" )

{

CoreSuspender suspend;

bool enable = (first == "enable");

if(parts.size())

{

for (size_t i = 0; i < parts.size(); i++)

{

std::string part = parts[i];

if (part.find('\\') != std::string::npos)

{

con.printerr("Replacing backslashes with forward slashes in \"%s\"\n", part.c_str());

for (size_t j = 0; j < part.size(); j++)

{

if (part[j] == '\\')

part[j] = '/';

}

}

part = GetAliasCommand(part, true);

Plugin * plug = (*plug_mgr)[part];

if(!plug)

{

std::filesystem::path lua = findScript(part + ".lua");

if (!lua.empty())

{

res = enableLuaScript(con, part, enable);

}

else

{

res = CR_NOT_FOUND;

con.printerr("No such plugin or Lua script: %s\n", part.c_str());

}

}

else if (!plug->can_set_enabled())

{

res = CR_NOT_IMPLEMENTED;

con.printerr("Cannot %s plugin: %s\n", first.c_str(), part.c_str());

}

else

{

res = plug->set_enabled(con, enable);

if (res != CR_OK || plug->is_enabled() != enable)

con.printerr("Could not %s plugin: %s\n", first.c_str(), part.c_str());

}

}

return res;

}

else

{

for (auto it = plug_mgr->begin(); it != plug_mgr->end(); ++it)

{

Plugin * plug = it->second;

if (!plug->can_be_enabled()) continue;

con.print(

"%21s %-3s%s\n",

(plug->getName()+":").c_str(),

plug->is_enabled() ? "on" : "off",

plug->can_set_enabled() ? "" : " (controlled internally)"

);

}

Lua::CallLuaModuleFunction(con, "script-manager", "list");

}

}

else if (first == "ls" || first == "dir")

{

ls_helper(con, parts);

}

else if (first == "plug")

{

const char *header_format = "%30s %10s %4s %8s\n";

const char *row_format = "%30s %10s %4i %8s\n";

con.print(header_format, "Name", "State", "Cmds", "Enabled");

plug_mgr->refresh();

for (auto it = plug_mgr->begin(); it != plug_mgr->end(); ++it)

{

Plugin * plug = it->second;

if (!plug)

continue;

if (parts.size() && std::find(parts.begin(), parts.end(), plug->getName()) == parts.end())

continue;

color_value color;

switch (plug->getState())

{

case Plugin::PS_LOADED:

color = COLOR_RESET;

break;

case Plugin::PS_UNLOADED:

case Plugin::PS_UNLOADING:

color = COLOR_YELLOW;

break;

case Plugin::PS_LOADING:

color = COLOR_LIGHTBLUE;

break;

case Plugin::PS_BROKEN:

color = COLOR_LIGHTRED;

break;

default:

color = COLOR_LIGHTMAGENTA;

break;

}

con.color(color);

con.print(row_format,

plug->getName().c_str(),

Plugin::getStateDescription(plug->getState()),

plug->size(),

(plug->can_be_enabled()

? (plug->is_enabled() ? "enabled" : "disabled")

: "n/a")

);

con.color(COLOR_RESET);

}

}

else if (first == "type")

{

if (!parts.size())

{

con.printerr("type: no argument\n");

return CR_WRONG_USAGE;

}

con << parts[0];

bool builtin = is_builtin(con, parts[0]);

std::filesystem::path lua_path = findScript(parts[0] + ".lua");

Plugin *plug = plug_mgr->getPluginByCommand(parts[0]);

if (builtin)

{

con << " is a built-in command";

con << std::endl;

}

else if (IsAlias(parts[0]))

{

con << " is an alias: " << GetAliasCommand(parts[0]) << std::endl;

}

else if (plug)

{

con << " is a command implemented by the plugin " << plug->getName() << std::endl;

}

else if (!lua_path.empty())

{

con << " is a Lua script: " << lua_path << std::endl;

}

else

{

con << " is not a recognized command." << std::endl;

plug = plug_mgr->getPluginByName(parts[0]);

if (plug)

con << "Plugin " << parts[0] << " exists and implements " << plug->size() << " commands." << std::endl;

return CR_FAILURE;

}

}

else if (first == "keybinding")

{

if (parts.size() >= 3 && (parts[0] == "set" || parts[0] == "add"))

{