Merge remote-tracking branch 'DFHack/develop' into develop

# Conflicts:
#	library/xml
#	plugins/remotefortressreader/adventure_control.cpp
#	plugins/remotefortressreader/dwarf_control.cpp

CMakeLists.txt

@@ -448,8 +448,6 @@ endif()
 file(WRITE "${CMAKE_BINARY_DIR}/dfhack_setarch.txt" ${DFHACK_SETARCH})
 install(FILES "${CMAKE_BINARY_DIR}/dfhack_setarch.txt" DESTINATION "${DFHACK_DATA_DESTINATION}")
 
-install(DIRECTORY dfhack-config/ DESTINATION dfhack-config/default)
-
 # build the plugins
 if(BUILD_PLUGINS)
     add_subdirectory(plugins)

data/CMakeLists.txt

@@ -1,20 +1,23 @@
+install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/dfhack-config/
+        DESTINATION "${DFHACK_DATA_DESTINATION}/data/dfhack-config-defaults")
+
 install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/init/
         DESTINATION "${DFHACK_DATA_DESTINATION}/init")
 
 install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/base_command_counts.json
-        DESTINATION "${DFHACK_DATA_DESTINATION}/data/base_command_counts.json")
+        DESTINATION "${DFHACK_DATA_DESTINATION}/data")
 
 install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/quickfort/
         DESTINATION "${DFHACK_DATA_DESTINATION}/data/quickfort")
 
 install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/orders/
-        DESTINATION dfhack-config/orders/library)
+        DESTINATION "${DFHACK_DATA_DESTINATION}/data/orders")
 
-install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/examples/
-        DESTINATION "${DFHACK_DATA_DESTINATION}/examples")
+install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/art/
+        DESTINATION "${DFHACK_DATA_DESTINATION}/data/art")
 
 install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/professions/
-        DESTINATION dfhack-config/professions/library)
+        DESTINATION "${DFHACK_DATA_DESTINATION}/data/professions")
 
 install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/blueprints/
         DESTINATION blueprints

data/examples/README.md

@@ -1,9 +0,0 @@
-# The DFHack Example Configuration File Library
-
-This folder contains ready-to-use examples of various DFHack configuration
-files. You can use them by copying them to appropriate folders where DFHack
-and its plugins can find them. You can use them unmodified, or you can
-customize them to better suit your preferences.
-
-For information on each of the files in this library, see the
-[DFHack Example Configuration File Guide](https://docs.dfhack.org/en/stable/docs/guides/examples-guide.html).

data/init/dfhack.tools.init

@@ -78,6 +78,9 @@
 # Display DFHack version on title screen
 #enable title-version
 
+# Allow DFHack tools to overlay functionality and information on the DF screen
+enable overlay
+
 # Dwarf Manipulator (simple in-game Dwarf Therapist replacement)
 #enable manipulator
 
@@ -89,7 +92,6 @@
 
 # Other interface improvement tools
 #enable \
-# overlay \
 # confirm \
 # dwarfmonitor \
 # mousequery \

docs/changelog.txt

@@ -40,6 +40,7 @@ changelog.txt uses a syntax similar to RST, with a few special sequences:
 ## Misc Improvements
 - Scrollable widgets now react to mouse wheel events when the mouse is over the widget
 - the ``dfhack-config/scripts/`` folder is now searched for scripts by default
+- `hotkeys`: overlay hotspot widget now shows the DFHack logo in graphics mode and "DFHack" in text mode
 
 ## Documentation
 - `overlay-dev-guide`: added troubleshooting tips and common development workflows

docs/dev/Lua API.rst

@@ -2392,13 +2392,13 @@ Supported callbacks and fields are:
   ``_STRING``
     Maps to an integer in range 0-255. Duplicates a separate "STRING_A???" code for convenience.
 
-  ``_MOUSE_L, _MOUSE_R``
-    If the left or right mouse button is being pressed.
+  ``_MOUSE_L, _MOUSE_R, _MOUSE_M``
+    If the left, right, and/or middle mouse button is being pressed.
 
-  ``_MOUSE_L_DOWN, _MOUSE_R_DOWN``
-    If the left or right mouse button was just pressed.
+  ``_MOUSE_L_DOWN, _MOUSE_R_DOWN, _MOUSE_M_DOWN``
+    If the left, right, and/or middle mouse button was just pressed.
 
-  If this method is omitted, the screen is dismissed on receival of the ``LEAVESCREEN`` key.
+  If this method is omitted, the screen is dismissed on reception of the ``LEAVESCREEN`` key.
 
 * ``function screen:onGetSelectedUnit()``
 * ``function screen:onGetSelectedItem()``

library/CMakeLists.txt

@@ -124,6 +124,7 @@ set(MODULE_HEADERS
     include/modules/Buildings.h
     include/modules/Burrows.h
     include/modules/Constructions.h
+    include/modules/DFSDL.h
     include/modules/Designations.h
     include/modules/EventManager.h
     include/modules/Filesystem.h
@@ -141,6 +142,7 @@ set(MODULE_HEADERS
     include/modules/Random.h
     include/modules/Renderer.h
     include/modules/Screen.h
+    include/modules/Textures.h
     include/modules/Translation.h
     include/modules/Units.h
     include/modules/World.h
@@ -150,6 +152,7 @@ set(MODULE_SOURCES
     modules/Buildings.cpp
     modules/Burrows.cpp
     modules/Constructions.cpp
+    modules/DFSDL.cpp
     modules/Designations.cpp
     modules/EventManager.cpp
     modules/Filesystem.cpp
@@ -166,6 +169,7 @@ set(MODULE_SOURCES
     modules/Random.cpp
     modules/Renderer.cpp
     modules/Screen.cpp
+    modules/Textures.cpp
     modules/Translation.cpp
     modules/Units.cpp
     modules/World.cpp

library/Core.cpp

@@ -49,9 +49,11 @@ using namespace std;
 #include "VersionInfo.h"
 #include "PluginManager.h"
 #include "ModuleFactory.h"
+#include "modules/DFSDL.h"
 #include "modules/EventManager.h"
 #include "modules/Filesystem.h"
 #include "modules/Gui.h"
+#include "modules/Textures.h"
 #include "modules/World.h"
 #include "modules/Persistence.h"
 #include "RemoteServer.h"
@@ -63,8 +65,8 @@ using namespace std;
 
 using namespace DFHack;
 
-#include "df/ui.h"
-#include "df/ui_sidebar_menus.h"
+#include "df/plotinfost.h"
+#include "df/gamest.h"
 #include "df/world.h"
 #include "df/world_data.h"
 #include "df/interfacest.h"
@@ -104,6 +106,9 @@ namespace DFHack {
 DBG_DECLARE(core,keybinding,DebugCategory::LINFO);
 DBG_DECLARE(core,script,DebugCategory::LINFO);
 
+static const std::string CONFIG_PATH = "dfhack-config/";
+static const std::string CONFIG_DEFAULTS_PATH = "hack/data/dfhack-config-defaults/";
+
 class MainThread {
 public:
     //! MainThread::suspend keeps the main DF thread suspended from Core::Init to
@@ -484,10 +489,10 @@ void Core::getScriptPaths(std::vector<std::string> *dest)
 {
     lock_guard<mutex> lock(script_path_mutex);
     dest->clear();
-    string df_path = this->p->getPath();
+    string df_path = this->p->getPath() + "/";
     for (auto it = script_paths[0].begin(); it != script_paths[0].end(); ++it)
         dest->push_back(*it);
-    dest->push_back(df_path + "/dfhack-config/scripts");
+    dest->push_back(df_path + CONFIG_PATH + "scripts");
     if (df::global::world && isWorldLoaded()) {
         string save = World::ReadWorldFolder();
         if (save.size())
@@ -516,7 +521,7 @@ string Core::findScript(string name)
 bool loadScriptPaths(color_ostream &out, bool silent = false)
 {
     using namespace std;
-    string filename("dfhack-config/script-paths.txt");
+    string filename(CONFIG_PATH + "script-paths.txt");
     ifstream file(filename);
     if (!file)
     {
@@ -1302,18 +1307,18 @@ bool Core::loadScriptFile(color_ostream &out, string fname, bool silent)
 static void run_dfhack_init(color_ostream &out, Core *core)
 {
     CoreSuspender lock;
-    if (!df::global::world || !df::global::ui || !df::global::gview)
+    if (!df::global::world || !df::global::plotinfo || !df::global::gview)
     {
         out.printerr("Key globals are missing, skipping loading dfhack.init.\n");
         return;
     }
 
     // load baseline defaults
-    core->loadScriptFile(out, "dfhack-config/init/default.dfhack.init", false);
+    core->loadScriptFile(out, CONFIG_PATH + "init/default.dfhack.init", false);
 
     // load user overrides
     std::vector<std::string> prefixes(1, "dfhack");
-    loadScriptFiles(core, out, prefixes, "dfhack-config/init");
+    loadScriptFiles(core, out, prefixes, CONFIG_PATH + "init");
 }
 
 // Load dfhack.init in a dedicated thread (non-interactive console mode)
@@ -1329,14 +1334,14 @@ void fInitthread(void * iodata)
 // A thread function... for the interactive console.
 void fIOthread(void * iodata)
 {
-    static const char * HISTORY_FILE = "dfhack-config/dfhack.history";
+    static const std::string HISTORY_FILE = CONFIG_PATH + "dfhack.history";
 
     IODATA * iod = ((IODATA*) iodata);
     Core * core = iod->core;
     PluginManager * plug_mgr = ((IODATA*) iodata)->plug_mgr;
 
     CommandHistory main_history;
-    main_history.load(HISTORY_FILE);
+    main_history.load(HISTORY_FILE.c_str());
 
     Console & con = core->getConsole();
     if (plug_mgr == 0)
@@ -1377,7 +1382,7 @@ void fIOthread(void * iodata)
         {
             // a proper, non-empty command was entered
             main_history.add(command);
-            main_history.save(HISTORY_FILE);
+            main_history.save(HISTORY_FILE.c_str());
         }
 
         auto rv = core->runCommand(con, command);
@@ -1612,46 +1617,44 @@ bool Core::Init()
     // initialize data defs
     virtual_identity::Init(this);
 
+    // create config directory if it doesn't already exist
+    if (!Filesystem::mkdir_recursive(CONFIG_PATH))
+        con.printerr("Failed to create config directory: '%s'\n", CONFIG_PATH.c_str());
+
     // copy over default config files if necessary
     std::map<std::string, bool> config_files;
     std::map<std::string, bool> default_config_files;
-    if (Filesystem::listdir_recursive("dfhack-config", config_files, 10, false) != 0)
-        con.printerr("Failed to list directory: dfhack-config");
-    else if (Filesystem::listdir_recursive("dfhack-config/default", default_config_files, 10, false) != 0)
-        con.printerr("Failed to list directory: dfhack-config/default");
+    if (Filesystem::listdir_recursive(CONFIG_PATH, config_files, 10, false) != 0)
+        con.printerr("Failed to list directory: '%s'\n", CONFIG_PATH.c_str());
+    else if (Filesystem::listdir_recursive(CONFIG_DEFAULTS_PATH, default_config_files, 10, false) != 0)
+        con.printerr("Failed to list directory: '%s'\n", CONFIG_DEFAULTS_PATH.c_str());
     else
     {
         // ensure all config file directories exist before we start copying files
-        for (auto it = default_config_files.begin(); it != default_config_files.end(); ++it)
-        {
+        for (auto &entry : default_config_files) {
             // skip over files
-            if (!it->second)
+            if (!entry.second)
                 continue;
-            std::string dirname = "dfhack-config/" + it->first;
+            std::string dirname = CONFIG_PATH + entry.first;
             if (!Filesystem::mkdir_recursive(dirname))
-            {
                 con.printerr("Failed to create config directory: '%s'\n", dirname.c_str());
         }
-        }
 
         // copy files from the default tree that don't already exist in the config tree
-        for (auto it = default_config_files.begin(); it != default_config_files.end(); ++it)
-        {
+        for (auto &entry : default_config_files) {
             // skip over directories
-            if (it->second)
+            if (entry.second)
                 continue;
-            std::string filename = it->first;
-            if (config_files.find(filename) == config_files.end())
-            {
-                std::string src_file = std::string("dfhack-config/default/") + filename;
+            std::string filename = entry.first;
+            if (!config_files.count(filename)) {
+                std::string src_file = CONFIG_DEFAULTS_PATH + filename;
                 if (!Filesystem::isfile(src_file))
                     continue;
-                std::string dest_file = std::string("dfhack-config/") + filename;
+                std::string dest_file = CONFIG_PATH + filename;
                 std::ifstream src(src_file, std::ios::binary);
                 std::ofstream dest(dest_file, std::ios::binary);
-                if (!src.good() || !dest.good())
-                {
-                    con.printerr("Copy failed: %s\n", filename.c_str());
+                if (!src.good() || !dest.good()) {
+                    con.printerr("Copy failed: '%s'\n", filename.c_str());
                     continue;
                 }
                 dest << src.rdbuf();
@@ -1670,8 +1673,15 @@ bool Core::Init()
         return false;
     }
 
+    cerr << "Binding to SDL.\n";
+    if (!DFSDL::init(con)) {
+        fatal("cannot bind SDL libraries");
+        return false;
+    }
+    cerr << "Initializing textures.\n";
+    Textures::init(con);
     // create mutex for syncing with interactive tasks
-    cerr << "Initializing Plugins.\n";
+    cerr << "Initializing plugins.\n";
     // create plugin manager
     plug_mgr = new PluginManager(this);
     plug_mgr->init();
@@ -1702,10 +1712,10 @@ bool Core::Init()
     if (!listen.get())
         cerr << "TCP listen failed.\n";
 
-    if (df::global::ui_sidebar_menus)
+    if (df::global::game)
     {
         vector<string> args;
-        const string & raw = df::global::ui_sidebar_menus->command_line.original;
+        const string & raw = df::global::game->command_line.original;
         size_t offset = 0;
         while (offset < raw.size())
         {
@@ -1765,12 +1775,7 @@ bool Core::Init()
 
     cerr << "DFHack is running.\n";
 
-    {
-        auto L = Lua::Core::State;
-        Lua::StackUnwinder top(L);
-        Lua::CallLuaModuleFunction(con, L, "script-manager", "reload");
     onStateChange(con, SC_CORE_INITIALIZED);
-    }
 
     return true;
 }
@@ -1874,7 +1879,7 @@ void Core::doUpdate(color_ostream &out)
         strict_virtual_cast<df::viewscreen_savegamest>(screen);
 
     // save data (do this before updating last_world_data_ptr and triggering unload events)
-    if ((df::global::ui->main.autosave_request && !d->last_autosave_request) ||
+    if ((df::global::plotinfo->main.autosave_request && !d->last_autosave_request) ||
         (is_load_save && !d->was_load_save && strict_virtual_cast<df::viewscreen_savegamest>(screen)))
     {
         doSaveData(out);
@@ -1936,7 +1941,7 @@ void Core::doUpdate(color_ostream &out)
     // Execute per-frame handlers
     onUpdate(out);
 
-    d->last_autosave_request = df::global::ui->main.autosave_request;
+    d->last_autosave_request = df::global::plotinfo->main.autosave_request;
     d->was_load_save = is_load_save;
 
     out << std::flush;
@@ -2086,9 +2091,9 @@ void Core::handleLoadAndUnloadScripts(color_ostream& out, state_change_event eve
         const std::vector<std::string>& set = i->second;
 
         // load baseline defaults
-        this->loadScriptFile(out, "dfhack-config/init/default." + set[0] + ".init", false);
+        this->loadScriptFile(out, CONFIG_PATH + "init/default." + set[0] + ".init", false);
 
-        loadScriptFiles(this, out, set, "dfhack-config/init");
+        loadScriptFiles(this, out, set, CONFIG_PATH + "init");
         loadScriptFiles(this, out, set, rawFolder);
         loadScriptFiles(this, out, set, rawFolder + "objects/");
     }
@@ -2138,6 +2143,13 @@ void Core::onStateChange(color_ostream &out, state_change_event event)
 
     switch (event)
     {
+    case SC_CORE_INITIALIZED:
+        {
+            auto L = Lua::Core::State;
+            Lua::StackUnwinder top(L);
+            Lua::CallLuaModuleFunction(con, L, "script-manager", "reload");
+        }
+        break;
     case SC_WORLD_LOADED:
     case SC_WORLD_UNLOADED:
     case SC_MAP_LOADED:
@@ -2171,6 +2183,10 @@ void Core::onStateChange(color_ostream &out, state_change_event event)
                 evtlog << std::endl;
             }
         }
+        break;
+    case SC_VIEWSCREEN_CHANGED:
+        Textures::init(out);
+        break;
     default:
         break;
     }
@@ -2248,6 +2264,8 @@ int Core::Shutdown ( void )
     }
     // invalidate all modules
     allModules.clear();
+    Textures::cleanup();
+    DFSDL::cleanup();
     memset(&(s_mods), 0, sizeof(s_mods));
     d.reset();
     return -1;
@@ -2270,14 +2288,14 @@ bool Core::ncurses_wgetch(int in, int & out)
 /* TODO: understand how this changes for v50
         int idx = in - KEY_F(1);
         // FIXME: copypasta, push into a method!
-        if(df::global::ui && df::global::gview)
+        if(df::global::plotinfo && df::global::gview)
         {
             df::viewscreen * ws = Gui::getCurViewscreen();
             if (strict_virtual_cast<df::viewscreen_dwarfmodest>(ws) &&
-                df::global::ui->main.mode != ui_sidebar_mode::Hotkeys &&
-                df::global::ui->main.hotkeys[idx].cmd == df::ui_hotkey::T_cmd::None)
+                df::global::plotinfo->main.mode != ui_sidebar_mode::Hotkeys &&
+                df::global::plotinfo->main.hotkeys[idx].cmd == df::ui_hotkey::T_cmd::None)
             {
-                setHotkeyCmd(df::global::ui->main.hotkeys[idx].name);
+                setHotkeyCmd(df::global::plotinfo->main.hotkeys[idx].name);
                 return false;
             }
             else
@@ -2404,7 +2422,7 @@ int Core::DFH_SDL_Event(SDL::Event* ev)
 bool Core::SelectHotkey(int sym, int modifiers)
 {
     // Find the topmost viewscreen
-    if (!df::global::gview || !df::global::ui)
+    if (!df::global::gview || !df::global::plotinfo)
         return false;
 
     df::viewscreen *screen = &df::global::gview->view;
@@ -2459,10 +2477,10 @@ bool Core::SelectHotkey(int sym, int modifiers)
                     idx += 8;
 
                 if (strict_virtual_cast<df::viewscreen_dwarfmodest>(screen) &&
-                    df::global::ui->main.mode != ui_sidebar_mode::Hotkeys &&
-                    df::global::ui->main.hotkeys[idx].cmd == df::ui_hotkey::T_cmd::None)
+                    df::global::plotinfo->main.mode != ui_sidebar_mode::Hotkeys &&
+                    df::global::plotinfo->main.hotkeys[idx].cmd == df::ui_hotkey::T_cmd::None)
                 {
-                    cmd = df::global::ui->main.hotkeys[idx].name;
+                    cmd = df::global::plotinfo->main.hotkeys[idx].name;
                 }
 */
             }

library/DataStatics.cpp

@@ -6,7 +6,7 @@
 
 #include "df/world.h"
 #include "df/world_data.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 
 #include "DataIdentity.h"
 

library/LuaApi.cpp

@@ -57,6 +57,7 @@ distribution.
 #include "modules/Materials.h"
 #include "modules/Random.h"
 #include "modules/Screen.h"
+#include "modules/Textures.h"
 #include "modules/Translation.h"
 #include "modules/Units.h"
 #include "modules/World.h"
@@ -1670,6 +1671,13 @@ static const luaL_Reg dfhack_job_funcs[] = {
     { NULL, NULL }
 };
 
+/***** Textures module *****/
+
+static const LuaWrapper::FunctionReg dfhack_textures_module[] = {
+    WRAPM(Textures, getDfhackLogoTexposStart),
+    { NULL, NULL }
+};
+
 /***** Units module *****/
 
 static const LuaWrapper::FunctionReg dfhack_units_module[] = {
@@ -2448,6 +2456,17 @@ static int screen_findGraphicsTile(lua_State *L)
     }
 }
 
+static int screen_raise(lua_State *L) {
+    df::viewscreen *screen = dfhack_lua_viewscreen::get_pointer(L, 1, false);
+
+    // remove screen from the stack so it doesn't get returned as an output
+    lua_remove(L, 1);
+
+    Screen::raise(screen);
+
+    return 0;
+}
+
 static int screen_hideGuard(lua_State *L) {
     df::viewscreen *screen = dfhack_lua_viewscreen::get_pointer(L, 1, false);
     luaL_checktype(L, 2, LUA_TFUNCTION);
@@ -2566,6 +2585,7 @@ static const luaL_Reg dfhack_screen_funcs[] = {
     { "paintString", screen_paintString },
     { "fillRect", screen_fillRect },
     { "findGraphicsTile", screen_findGraphicsTile },
+    CWRAP(raise, screen_raise),
     CWRAP(hideGuard, screen_hideGuard),
     CWRAP(show, screen_show),
     CWRAP(dismiss, screen_dismiss),
@@ -3357,6 +3377,7 @@ void OpenDFHackApi(lua_State *state)
     luaL_setfuncs(state, dfhack_funcs, 0);
     OpenModule(state, "gui", dfhack_gui_module, dfhack_gui_funcs);
     OpenModule(state, "job", dfhack_job_module, dfhack_job_funcs);
+    OpenModule(state, "textures", dfhack_textures_module);
     OpenModule(state, "units", dfhack_units_module, dfhack_units_funcs);
     OpenModule(state, "items", dfhack_items_module, dfhack_items_funcs);
     OpenModule(state, "maps", dfhack_maps_module, dfhack_maps_funcs);

library/LuaTools.cpp

@@ -131,9 +131,16 @@ void DFHack::Lua::GetVector(lua_State *state, std::vector<std::string> &pvec)
     }
 }
 
+static bool trigger_inhibit_l_down = false;
+static bool trigger_inhibit_r_down = false;
+static bool trigger_inhibit_m_down = false;
+static bool inhibit_l_down = false;
+static bool inhibit_r_down = false;
+static bool inhibit_m_down = false;
+
 void DFHack::Lua::PushInterfaceKeys(lua_State *L,
                             const std::set<df::interface_key> &keys) {
-    lua_createtable(L, 0, keys.size() + 5);
+    lua_createtable(L, 0, keys.size() + 7);
 
     for (auto &key : keys)
     {
@@ -154,23 +161,32 @@ void DFHack::Lua::PushInterfaceKeys(lua_State *L,
     }
 
     if (df::global::enabler) {
-        if (df::global::enabler->mouse_lbut_down) {
+        if (!inhibit_l_down && df::global::enabler->mouse_lbut_down) {
             lua_pushboolean(L, true);
             lua_setfield(L, -2, "_MOUSE_L_DOWN");
+            trigger_inhibit_l_down = true;
         }
-        if (df::global::enabler->mouse_rbut_down) {
+        if (!inhibit_r_down && df::global::enabler->mouse_rbut_down) {
             lua_pushboolean(L, true);
             lua_setfield(L, -2, "_MOUSE_R_DOWN");
+            trigger_inhibit_r_down = true;
+        }
+        if (!inhibit_m_down && df::global::enabler->mouse_mbut_down) {
+            lua_pushboolean(L, true);
+            lua_setfield(L, -2, "_MOUSE_M_DOWN");
+            trigger_inhibit_m_down = true;
         }
         if (df::global::enabler->mouse_lbut) {
             lua_pushboolean(L, true);
             lua_setfield(L, -2, "_MOUSE_L");
-            df::global::enabler->mouse_lbut_down = 0;
         }
         if (df::global::enabler->mouse_rbut) {
             lua_pushboolean(L, true);
             lua_setfield(L, -2, "_MOUSE_R");
-            df::global::enabler->mouse_rbut_down = 0;
+        }
+        if (df::global::enabler->mouse_mbut) {
+            lua_pushboolean(L, true);
+            lua_setfield(L, -2, "_MOUSE_M");
         }
     }
 }
@@ -2134,4 +2150,24 @@ void DFHack::Lua::Core::Reset(color_ostream &out, const char *where)
         out.printerr("Common lua context stack top left at %d after %s.\n", top, where);
         lua_settop(State, 0);
     }
+
+    if (trigger_inhibit_l_down) {
+        trigger_inhibit_l_down = false;
+        inhibit_l_down = true;
+    }
+    if (trigger_inhibit_r_down) {
+        trigger_inhibit_r_down = false;
+        inhibit_r_down = true;
+    }
+    if (trigger_inhibit_m_down) {
+        trigger_inhibit_m_down = false;
+        inhibit_m_down = true;
+    }
+
+    if (!df::global::enabler->mouse_lbut)
+        inhibit_l_down = false;
+    if (!df::global::enabler->mouse_rbut)
+        inhibit_r_down = false;
+    if (!df::global::enabler->mouse_mbut)
+        inhibit_m_down = false;
 }

library/RemoteTools.cpp

@@ -59,8 +59,8 @@ POSSIBILITY OF SUCH DAMAGE.
 #include "LuaTools.h"
 
 #include "DataDefs.h"
-#include "df/ui.h"
-#include "df/ui_advmode.h"
+#include "df/plotinfost.h"
+#include "df/adventurest.h"
 #include "df/world.h"
 #include "df/world_data.h"
 #include "df/unit.h"
@@ -375,11 +375,11 @@ static command_result GetDFVersion(color_ostream &stream,
 static command_result GetWorldInfo(color_ostream &stream,
                                    const EmptyMessage *, GetWorldInfoOut *out)
 {
-    using df::global::ui;
-    using df::global::ui_advmode;
+    using df::global::plotinfo;
+    using df::global::adventure;
     using df::global::world;
 
-    if (!ui || !world || !Core::getInstance().isWorldLoaded())
+    if (!plotinfo || !world || !Core::getInstance().isWorldLoaded())
         return CR_NOT_FOUND;
 
     df::game_type gt = game_type::DWARF_MAIN;
@@ -397,10 +397,10 @@ static command_result GetWorldInfo(color_ostream &stream,
     case game_type::DWARF_RECLAIM:
     case game_type::DWARF_UNRETIRE:
         out->set_mode(GetWorldInfoOut::MODE_DWARF);
-        out->set_civ_id(ui->civ_id);
-        out->set_site_id(ui->site_id);
-        out->set_group_id(ui->group_id);
-        out->set_race_id(ui->race_id);
+        out->set_civ_id(plotinfo->civ_id);
+        out->set_site_id(plotinfo->site_id);
+        out->set_group_id(plotinfo->group_id);
+        out->set_race_id(plotinfo->race_id);
         break;
 
     case game_type::ADVENTURE_MAIN:
@@ -410,10 +410,10 @@ static command_result GetWorldInfo(color_ostream &stream,
         if (auto unit = vector_get(world->units.active, 0))
             out->set_player_unit_id(unit->id);
 
-        if (!ui_advmode)
+        if (!adventure)
             break;
 
-        if (auto nemesis = vector_get(world->nemesis.all, ui_advmode->player_id))
+        if (auto nemesis = vector_get(world->nemesis.all, adventure->player_id))
         {
             if (nemesis->figure)
                 out->set_player_histfig_id(nemesis->figure->id);
@@ -613,7 +613,7 @@ static command_result ListUnits(color_ostream &stream,
 static command_result ListSquads(color_ostream &stream,
                                  const ListSquadsIn *in, ListSquadsOut *out)
 {
-    auto entity = df::historical_entity::find(df::global::ui->group_id);
+    auto entity = df::historical_entity::find(df::global::plotinfo->group_id);
     if (!entity)
         return CR_NOT_FOUND;
 

library/include/DataIdentity.h

@@ -394,6 +394,7 @@ namespace df
 
     template<class T>
     class ro_stl_container_identity : public container_identity {
+    protected:
         const char *name;
 
     public:
@@ -419,6 +420,30 @@ namespace df
         }
     };
 
+    template<class T>
+    class ro_stl_assoc_container_identity : public ro_stl_container_identity<T> {
+        type_identity *key_identity;
+        type_identity *item_identity;
+
+    public:
+        ro_stl_assoc_container_identity(const char *name, type_identity *key, type_identity *item)
+            : ro_stl_container_identity<T>(name, item),
+              key_identity(key),
+              item_identity(item)
+        {}
+
+        virtual std::string getFullName(type_identity*) override {
+            return std::string(ro_stl_assoc_container_identity<T>::name) + "<" + key_identity->getFullName() + ", " + item_identity->getFullName() + ">";
+        }
+
+    protected:
+        virtual void *item_pointer(type_identity *item, void *ptr, int idx) override {
+            auto iter = (*(T*)ptr).begin();
+            for (; idx > 0; idx--) ++iter;
+            return (void*)&iter->second;
+        }
+    };
+
     class bit_array_identity : public bit_container_identity {
     public:
         /*
@@ -609,6 +634,10 @@ namespace df
         static container_identity *get();
     };
 
+    template<class KT, class T> struct identity_traits<std::map<KT, T>> {
+        static container_identity *get();
+    };
+
     template<> struct identity_traits<BitArray<int> > {
         static bit_array_identity identity;
         static bit_container_identity *get() { return &identity; }
@@ -679,6 +708,13 @@ namespace df
         return &identity;
     }
 
+    template<class KT, class T>
+    inline container_identity *identity_traits<std::map<KT, T>>::get() {
+        typedef std::map<KT, T> container;
+        static ro_stl_assoc_container_identity<container> identity("map", identity_traits<KT>::get(), identity_traits<T>::get());
+        return &identity;
+    }
+
     template<class T>
     inline bit_container_identity *identity_traits<BitArray<T> >::get() {
         static bit_array_identity identity(identity_traits<T>::get());

library/include/DebugManager.h

@@ -42,13 +42,13 @@ class DebugCategory;
 /*!
  * \brief Container holding all registered runtime debug categories
  * Singleton DebugManager is a minor extension to std::vector that allows signal
- * callbacks to be attached from ui code that manages.
+ * callbacks to be attached from plotinfo code that manages.
  *
  * To avoid parallel plugin unload causing issues access to DebugManager must be
  * protected by mutex. The access mutex will be taken when
  * DFHack::DebugCategory::~DebugCategory performs unregister calls to
  * DFHack::DebugManager. The mutex will protect from memory disappearing while
- * ui code is accessing or changing the runtime state.
+ * plotinfo code is accessing or changing the runtime state.
  *
  * Signal emitting happens from a locked contexts. Taking the
  * DFHack::DebugManager::access_mutex_ in a signal callback will results to a

library/include/modules/DFSDL.h

@@ -0,0 +1,92 @@
+#pragma once
+
+#include "Export.h"
+#include "ColorText.h"
+
+namespace DFHack
+{
+    // SDL stand-in type definitions
+    typedef signed short SINT16;
+    typedef void DFSDL_sem;
+
+    typedef struct
+    {
+        int16_t x, y;
+        uint16_t w, h;
+    } DFSDL_Rect;
+    typedef struct
+    {
+        void *palette; // SDL_Palette*
+        uint8_t  BitsPerPixel;
+        uint8_t  BytesPerPixel;
+        uint8_t  Rloss;
+        uint8_t  Gloss;
+        uint8_t  Bloss;
+        uint8_t  Aloss;
+        uint8_t  Rshift;
+        uint8_t  Gshift;
+        uint8_t  Bshift;
+        uint8_t  Ashift;
+        uint32_t Rmask;
+        uint32_t Gmask;
+        uint32_t Bmask;
+        uint32_t Amask;
+        uint32_t colorkey;
+        uint8_t  alpha;
+    } DFSDL_PixelFormat;
+    typedef struct
+    {
+        uint32_t flags;
+        DFSDL_PixelFormat* format;
+        int w, h;
+        int pitch;
+        void* pixels;
+        void* userdata; // as far as i could see DF doesnt use this
+        int locked;
+        void* lock_data;
+        DFSDL_Rect clip_rect;
+        void* map;
+        int refcount;
+    } DFSDL_Surface;
+
+    // =========
+    struct DFTileSurface
+    {
+        bool paintOver; // draw over original tile?
+        DFSDL_Surface* surface; // from where it should be drawn
+        DFSDL_Rect* rect; // from which coords (NULL to draw whole surface)
+        DFSDL_Rect* dstResize; // if not NULL dst rect will be resized (x/y/w/h will be added to original dst)
+    };
+
+/**
+ * The DFSDL module - provides access to SDL functions without actually
+ * requiring build-time linkage to SDL
+ * \ingroup grp_modules
+ * \ingroup grp_dfsdl
+ */
+namespace DFSDL
+{
+
+/**
+ * Call this on DFHack init so we can load the SDL functions. Returns false on
+ * failure.
+ */
+bool init(DFHack::color_ostream &out);
+
+/**
+ * Call this when DFHack is being unloaded.
+ */
+void cleanup();
+
+DFHACK_EXPORT DFSDL_Surface * DFIMG_Load(const char *file);
+DFHACK_EXPORT int DFSDL_SetAlpha(DFSDL_Surface *surface, uint32_t flag, uint8_t alpha);
+DFHACK_EXPORT DFSDL_Surface * DFSDL_CreateRGBSurface(uint32_t flags, int width, int height, int depth, uint32_t Rmask, uint32_t Gmask, uint32_t Bmask, uint32_t Amask);
+DFHACK_EXPORT int DFSDL_UpperBlit(DFSDL_Surface *src, const DFSDL_Rect *srcrect, DFSDL_Surface *dst, DFSDL_Rect *dstrect);
+DFHACK_EXPORT DFSDL_Surface * DFSDL_ConvertSurface(DFSDL_Surface *src, const DFSDL_PixelFormat *fmt, uint32_t flags);
+DFHACK_EXPORT void DFSDL_FreeSurface(DFSDL_Surface *surface);
+DFHACK_EXPORT int DFSDL_SemWait(DFSDL_sem *sem);
+DFHACK_EXPORT int DFSDL_SemPost(DFSDL_sem *sem);
+
+}
+
+}

library/include/modules/Graphic.h

@@ -33,42 +33,11 @@ distribution.
 #include <stdint.h>
 #include "Export.h"
 #include "Module.h"
+#include "DFSDL.h"
 #include <vector>
 
 namespace DFHack
 {
-    // SDL stuff
-    typedef signed short SINT16;
-    typedef struct
-    {
-        int16_t x, y;
-        uint16_t w, h;
-    } DFSDL_Rect;
-    typedef struct
-    {
-        uint32_t flags;
-        void* format; // PixelFormat*
-        int w, h;
-        int pitch;
-        void* pixels;
-        void* userdata; // as far as i could see DF doesnt use this
-        int locked;
-        void* lock_data;
-        DFSDL_Rect clip_rect;
-        void* map;
-        int refcount;
-    } DFSDL_Surface;
-
-    // =========
-    struct DFTileSurface
-    {
-        bool paintOver; // draw over original tile?
-        DFSDL_Surface* surface; // from where it should be drawn
-        DFSDL_Rect* rect; // from which coords (NULL to draw whole surface)
-        DFSDL_Rect* dstResize; // if not NULL dst rect will be resized (x/y/w/h will be added to original dst)
-    };
-
-
     class DFHACK_EXPORT Graphic : public Module
     {
         public:
@@ -83,7 +52,6 @@ namespace DFHack
         private:
             std::vector<DFTileSurface* (*)(int, int)> funcs;
     };
-
 }
 
 #endif

library/include/modules/Gui.h

@@ -33,7 +33,7 @@ distribution.
 
 #include "DataDefs.h"
 #include "df/init.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/announcement_type.h"
 #include "df/announcement_flags.h"
 #include "df/report_init.h"

library/include/modules/Kitchen.h

@@ -75,7 +75,7 @@ DFHACK_EXPORT void clearLimits();
 
 DFHACK_EXPORT std::size_t size();
 
-// Finds the index of a kitchen exclusion in ui.kitchen.exc_types. Returns -1 if not found.
+// Finds the index of a kitchen exclusion in plotinfo.kitchen.exc_types. Returns -1 if not found.
 DFHACK_EXPORT int findExclusion(df::kitchen_exc_type type,
     df::item_type item_type, int16_t item_subtype,
     int16_t mat_type, int32_t mat_index);

library/include/modules/Screen.h

@@ -222,6 +222,7 @@ namespace DFHack
         DFHACK_EXPORT void dismiss(df::viewscreen *screen, bool to_first = false);
         DFHACK_EXPORT bool isDismissed(df::viewscreen *screen);
         DFHACK_EXPORT bool hasActiveScreens(Plugin *p);
+        DFHACK_EXPORT void raise(df::viewscreen *screen);
 
         /// Retrieve the string representation of the bound key.
         DFHACK_EXPORT std::string getKeyDisplay(df::interface_key key);

library/include/modules/Textures.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "Export.h"
+#include "ColorText.h"
+
+namespace DFHack {
+
+/**
+ * The Textures module - loads and provides access to DFHack textures
+ * \ingroup grp_modules
+ * \ingroup grp_textures
+ */
+namespace Textures {
+
+/**
+ * Call this on DFHack init and on every viewscreen change so we can reload
+ * and reindex textures as needed.
+ */
+void init(DFHack::color_ostream &out);
+
+/**
+ * Call this when DFHack is being unloaded.
+ *
+ */
+void cleanup();
+
+/**
+ * Get first texpos for the DFHack logo. This texpos and the next 11 make up the
+ * 4x3 grid of logo textures that can be displayed on the UI layer.
+ */
+DFHACK_EXPORT long getDfhackLogoTexposStart();
+
+}
+}

library/lua/gui.lua

@@ -14,8 +14,10 @@ CLEAR_PEN = to_pen{tile=909, ch=32, fg=0, bg=0}
 local FAKE_INPUT_KEYS = {
     _MOUSE_L = true,
     _MOUSE_R = true,
+    _MOUSE_M = true,
     _MOUSE_L_DOWN = true,
     _MOUSE_R_DOWN = true,
+    _MOUSE_M_DOWN = true,
     _STRING = true,
 }
 
@@ -482,6 +484,10 @@ function View:getMousePos(view_rect)
     end
 end
 
+function View:getMouseFramePos()
+    return self:getMousePos(ViewRect{rect=self.frame_rect})
+end
+
 function View:computeFrame(parent_rect)
     return mkdims_wh(0,0,parent_rect.width,parent_rect.height)
 end
@@ -679,9 +685,67 @@ function Screen:onRender()
     self:render(Painter.new())
 end
 
-------------------------
+-----------------------------
+-- Z-order swapping screen --
+-----------------------------
+
+ZScreen = defclass(ZScreen, Screen)
+
+function ZScreen:onIdle()
+    if self._native and self._native.parent then
+        self._native.parent:logic()
+    end
+end
+
+function ZScreen:render(dc)
+    self:renderParent()
+    ZScreen.super.render(self, dc)
+end
+
+local function zscreen_is_top(self)
+    return dfhack.gui.getCurViewscreen(true) == self._native
+end
+
+function ZScreen:onInput(keys)
+    if not zscreen_is_top(self) then
+        if keys._MOUSE_L_DOWN and self:isMouseOver() then
+            self:raise()
+        else
+            self:sendInputToParent(keys)
+            return
+        end
+    end
+
+    if ZScreen.super.onInput(self, keys) then
+        return
+    end
+    if keys.LEAVESCREEN or keys._MOUSE_R_DOWN then
+        self:dismiss()
+        return
+    end
+
+    if not keys._MOUSE_L or not self:isMouseOver() then
+        self:sendInputToParent(keys)
+    end
+end
+
+-- move this viewscreen to the top of the stack (if it's not there already)
+function ZScreen:raise()
+    if self:isDismissed() or zscreen_is_top(self) then
+        return
+    end
+    dscreen.raise(self)
+end
+
+-- subclasses should override this and return whether the mouse is over an
+-- owned screen element
+function ZScreen:isMouseOver()
+    return false
+end
+
+--------------------------
 -- Framed screen object --
-------------------------
+--------------------------
 
 -- Plain grey-colored frame.
 GREY_FRAME = {

library/lua/gui/dwarfmode.lua

@@ -49,7 +49,7 @@ function enterSidebarMode(sidebar_mode, max_esc)
     while remaining_esc > 0 do
         local screen = dfhack.gui.getCurViewscreen(true)
         focus_string = dfhack.gui.getFocusString(screen)
-        if df.global.ui.main.mode == df.ui_sidebar_mode.Default and
+        if df.global.plotinfo.main.mode == df.ui_sidebar_mode.Default and
                 focus_string == 'dwarfmode/Default' then
             if #navkey > 0 then gui.simulateInput(screen, navkey) end
             if navkey == 'D_DESIGNATE' then
@@ -275,7 +275,7 @@ end
 
 HOTKEY_KEYS = {}
 
-for i,v in ipairs(df.global.ui.main.hotkeys) do
+for i,v in ipairs(df.global.plotinfo.main.hotkeys) do
     HOTKEY_KEYS['D_HOTKEY'..(i+1)] = v
 end
 
@@ -433,7 +433,7 @@ function MenuOverlay:init()
     end
 
     if self.sidebar_mode then
-        self.saved_sidebar_mode = df.global.ui.main.mode
+        self.saved_sidebar_mode = df.global.plotinfo.main.mode
         -- what mode should we restore when this window is dismissed? ideally, we'd
         -- restore the mode that the user has set, but we should fall back to
         -- restoring the default mode if either of the following conditions are

library/lua/gui/widgets.lua

@@ -87,7 +87,7 @@ Panel.ATTRS {
 
 function Panel:init(args)
     if not self.drag_anchors then
-        self.drag_anchors = {title=true, frame=false, body=false}
+        self.drag_anchors = {title=true, frame=false, body=true}
     end
     if not self.resize_anchors then
         self.resize_anchors = {t=false, l=true, r=true, b=true}
@@ -303,8 +303,7 @@ function Panel:onInput(keys)
         return true
     end
     if not keys._MOUSE_L_DOWN then return end
-    local rect = self.frame_rect
-    local x,y = self:getMousePos(gui.ViewRect{rect=rect})
+    local x,y = self:getMouseFramePos()
     if not x then return end
 
     if self.resizable and y == 0 then

library/lua/makeown.lua

@@ -288,11 +288,11 @@ end
 function make_own(unit)
     --tweak makeown
     unit.flags2.resident = false; unit.flags1.merchant = false; unit.flags1.forest = false;
-    unit.civ_id = df.global.ui.civ_id
+    unit.civ_id = df.global.plotinfo.civ_id
     if unit.profession == df.profession.MERCHANT then unit.profession = df.profession.TRADER end
     if unit.profession2 == df.profession.MERCHANT then unit.profession2 = df.profession.TRADER end
     fix_clothing_ownership(unit)
-    if unit.race == df.global.ui.race_id then
+    if unit.race == df.global.plotinfo.race_id then
         make_citizen(unit)
     end
 end

library/modules/Buildings.cpp

@@ -81,14 +81,14 @@ using namespace DFHack;
 #include "df/job_item.h"
 #include "df/map_block.h"
 #include "df/tile_occupancy.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/ui_look_list.h"
 #include "df/unit.h"
 #include "df/unit_relationship_type.h"
 #include "df/world.h"
 
 using namespace df::enums;
-using df::global::ui;
+using df::global::plotinfo;
 using df::global::world;
 using df::global::d_init;
 using df::global::building_next_id;
@@ -425,7 +425,7 @@ df::building *Buildings::allocInstance(df::coord pos, df::building_type type, in
     bld->y1 = bld->y2 = bld->centery = pos.y;
     bld->z = pos.z;
 
-    bld->race = ui->race_id;
+    bld->race = plotinfo->race_id;
 
     if (subtype != -1)
         bld->setSubtype(subtype);
@@ -989,7 +989,7 @@ static void linkRooms(df::building *bld)
     }
 
     if (changed)
-        df::global::ui->equipment.update.bits.buildings = true;
+        df::global::plotinfo->equipment.update.bits.buildings = true;
 */
 }
 
@@ -1238,7 +1238,7 @@ bool Buildings::constructWithFilters(df::building *bld, std::vector<df::job_item
 
 bool Buildings::deconstruct(df::building *bld)
 {
-    using df::global::ui;
+    using df::global::plotinfo;
     using df::global::world;
     using df::global::ui_look_list;
 
@@ -1263,7 +1263,7 @@ bool Buildings::deconstruct(df::building *bld)
     // Assume: no parties.
     unlinkRooms(bld);
     // Assume: not unit destroy target
-    vector_erase_at(ui->tax_collection.rooms, linear_index(ui->tax_collection.rooms, bld->id));
+    vector_erase_at(plotinfo->tax_collection.rooms, linear_index(plotinfo->tax_collection.rooms, bld->id));
     // Assume: not used in punishment
     // Assume: not used in non-own jobs
     // Assume: does not affect pathfinding

library/modules/Burrows.cpp

@@ -42,14 +42,14 @@ using namespace std;
 #include "df/block_burrow_link.h"
 #include "df/burrow.h"
 #include "df/map_block.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/world.h"
 
 using namespace DFHack;
 using namespace df::enums;
 
 using df::global::world;
-using df::global::ui;
+using df::global::plotinfo;
 
 df::burrow *Burrows::findByName(std::string name)
 {
@@ -77,11 +77,11 @@ void Burrows::clearUnits(df::burrow *burrow)
     burrow->units.clear();
 
 /* TODO: understand how this changes for v50
-    // Sync ui if active
-    if (ui && ui->main.mode == ui_sidebar_mode::Burrows &&
-        ui->burrows.in_add_units_mode && ui->burrows.sel_id == burrow->id)
+    // Sync plotinfo if active
+    if (plotinfo && plotinfo->main.mode == ui_sidebar_mode::Burrows &&
+        plotinfo->burrows.in_add_units_mode && plotinfo->burrows.sel_id == burrow->id)
     {
-        auto &sel = ui->burrows.sel_units;
+        auto &sel = plotinfo->burrows.sel_units;
 
         for (size_t i = 0; i < sel.size(); i++)
             sel[i] = false;
@@ -99,7 +99,7 @@ bool Burrows::isAssignedUnit(df::burrow *burrow, df::unit *unit)
 
 void Burrows::setAssignedUnit(df::burrow *burrow, df::unit *unit, bool enable)
 {
-    using df::global::ui;
+    using df::global::plotinfo;
 
     CHECK_NULL_POINTER(unit);
     CHECK_NULL_POINTER(burrow);
@@ -116,13 +116,13 @@ void Burrows::setAssignedUnit(df::burrow *burrow, df::unit *unit, bool enable)
     }
 
 /* TODO: understand how this changes for v50
-    // Sync ui if active
-    if (ui && ui->main.mode == ui_sidebar_mode::Burrows &&
-        ui->burrows.in_add_units_mode && ui->burrows.sel_id == burrow->id)
+    // Sync plotinfo if active
+    if (plotinfo && plotinfo->main.mode == ui_sidebar_mode::Burrows &&
+        plotinfo->burrows.in_add_units_mode && plotinfo->burrows.sel_id == burrow->id)
     {
-        int idx = linear_index(ui->burrows.list_units, unit);
+        int idx = linear_index(plotinfo->burrows.list_units, unit);
         if (idx >= 0)
-            ui->burrows.sel_units[idx] = enable;
+            plotinfo->burrows.sel_units[idx] = enable;
     }
 */
 }

library/modules/DFSDL.cpp

@@ -0,0 +1,120 @@
+#include "Internal.h"
+
+#include "modules/DFSDL.h"
+
+#include "Debug.h"
+#include "PluginManager.h"
+
+namespace DFHack {
+    DBG_DECLARE(core, dfsdl, DebugCategory::LINFO);
+}
+
+using namespace DFHack;
+
+static DFLibrary *g_sdl_handle = nullptr;
+static DFLibrary *g_sdl_image_handle = nullptr;
+static const std::vector<std::string> SDL_LIBS {
+    "SDLreal.dll", // TODO: change to SDL.dll once we move to dfhooks
+    "SDL.framework/Versions/A/SDL",
+    "SDL.framework/SDL",
+    "libSDL-1.2.so.0"
+};
+static const std::vector<std::string> SDL_IMAGE_LIBS {
+    "SDL_image.dll",
+    "SDL_image.framework/Versions/A/SDL_image",
+    "SDL_image.framework/SDL_image",
+    "libSDL_image-1.2.so.0"
+};
+
+DFSDL_Surface * (*g_IMG_Load)(const char *) = nullptr;
+int (*g_SDL_SetAlpha)(DFSDL_Surface *, uint32_t, uint8_t) = nullptr;
+DFSDL_Surface * (*g_SDL_CreateRGBSurface)(uint32_t, int, int, int, uint32_t, uint32_t, uint32_t, uint32_t);
+int (*g_SDL_UpperBlit)(DFSDL_Surface *, const DFSDL_Rect *, DFSDL_Surface *, DFSDL_Rect *);
+DFSDL_Surface * (*g_SDL_ConvertSurface)(DFSDL_Surface *, const DFSDL_PixelFormat *, uint32_t);
+void (*g_SDL_FreeSurface)(DFSDL_Surface *);
+int (*g_SDL_SemWait)(DFSDL_sem *);
+int (*g_SDL_SemPost)(DFSDL_sem *);
+
+bool DFSDL::init(color_ostream &out) {
+    for (auto &lib_str : SDL_LIBS) {
+        if ((g_sdl_handle = OpenPlugin(lib_str.c_str())))
+            break;
+    }
+    if (!g_sdl_handle) {
+        out.printerr("DFHack could not find SDL\n");
+        return false;
+    }
+
+    for (auto &lib_str : SDL_IMAGE_LIBS) {
+        if ((g_sdl_image_handle = OpenPlugin(lib_str.c_str())))
+            break;
+    }
+    if (!g_sdl_image_handle) {
+        out.printerr("DFHack could not find SDL_image\n");
+        return false;
+    }
+
+    #define bind(handle, name) \
+        g_##name = (decltype(g_##name))LookupPlugin(handle, #name); \
+        if (!g_##name) { \
+            out.printerr("DFHack could not find: " #name "\n"); \
+            return false; \
+        }
+
+    bind(g_sdl_image_handle, IMG_Load);
+    bind(g_sdl_handle, SDL_SetAlpha);
+    bind(g_sdl_handle, SDL_CreateRGBSurface);
+    bind(g_sdl_handle, SDL_UpperBlit);
+    bind(g_sdl_handle, SDL_ConvertSurface);
+    bind(g_sdl_handle, SDL_FreeSurface);
+    bind(g_sdl_handle, SDL_SemWait);
+    bind(g_sdl_handle, SDL_SemPost);
+    #undef bind
+
+    DEBUG(dfsdl,out).print("sdl successfully loaded\n");
+    return true;
+}
+
+// It's ok to leave NULLs in the raws list (according to usage in g_src)
+void DFSDL::cleanup() {
+    if (g_sdl_handle) {
+        ClosePlugin(g_sdl_handle);
+        g_sdl_handle = nullptr;
+    }
+    if (g_sdl_image_handle) {
+        ClosePlugin(g_sdl_image_handle);
+        g_sdl_image_handle = nullptr;
+    }
+}
+
+DFSDL_Surface * DFSDL::DFIMG_Load(const char *file) {
+    return g_IMG_Load(file);
+}
+
+int DFSDL::DFSDL_SetAlpha(DFSDL_Surface *surface, uint32_t flag, uint8_t alpha) {
+    return g_SDL_SetAlpha(surface, flag, alpha);
+}
+
+DFSDL_Surface * DFSDL::DFSDL_CreateRGBSurface(uint32_t flags, int width, int height, int depth, uint32_t Rmask, uint32_t Gmask, uint32_t Bmask, uint32_t Amask) {
+    return g_SDL_CreateRGBSurface(flags, width, height, depth, Rmask, Gmask, Bmask, Amask);
+}
+
+int DFSDL::DFSDL_UpperBlit(DFSDL_Surface *src, const DFSDL_Rect *srcrect, DFSDL_Surface *dst, DFSDL_Rect *dstrect) {
+    return g_SDL_UpperBlit(src, srcrect, dst, dstrect);
+}
+
+DFSDL_Surface * DFSDL::DFSDL_ConvertSurface(DFSDL_Surface *src, const DFSDL_PixelFormat *fmt, uint32_t flags) {
+    return g_SDL_ConvertSurface(src, fmt, flags);
+}
+
+void DFSDL::DFSDL_FreeSurface(DFSDL_Surface *surface) {
+    g_SDL_FreeSurface(surface);
+}
+
+int DFSDL::DFSDL_SemWait(DFSDL_sem *sem) {
+    return g_SDL_SemWait(sem);
+}
+
+int DFSDL::DFSDL_SemPost(DFSDL_sem *sem) {
+    return g_SDL_SemPost(sem);
+}

library/modules/EventManager.cpp

@@ -27,7 +27,7 @@
 #include "df/job.h"
 #include "df/job_list_link.h"
 #include "df/report.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/unit.h"
 #include "df/unit_flags1.h"
 #include "df/unit_inventory_item.h"
@@ -297,14 +297,14 @@ void DFHack::EventManager::onStateChange(color_ostream& out, state_change_event
             return;
         if (!df::global::job_next_id)
             return;
-        if (!df::global::ui)
+        if (!df::global::plotinfo)
             return;
         if (!df::global::world)
             return;
 
         nextItem = *df::global::item_next_id;
         nextBuilding = *df::global::building_next_id;
-        nextInvasion = df::global::ui->invasions.next_id;
+        nextInvasion = df::global::plotinfo->invasions.next_id;
         lastJobId = -1 + *df::global::job_next_id;
 
         constructions.clear();
@@ -807,13 +807,13 @@ static void manageSyndromeEvent(color_ostream& out) {
 }
 
 static void manageInvasionEvent(color_ostream& out) {
-    if (!df::global::ui)
+    if (!df::global::plotinfo)
         return;
     multimap<Plugin*,EventHandler> copy(handlers[EventType::INVASION].begin(), handlers[EventType::INVASION].end());
 
-    if ( df::global::ui->invasions.next_id <= nextInvasion )
+    if ( df::global::plotinfo->invasions.next_id <= nextInvasion )
         return;
-    nextInvasion = df::global::ui->invasions.next_id;
+    nextInvasion = df::global::plotinfo->invasions.next_id;
 
     for (auto &key_value : copy) {
         EventHandler &handle = key_value.second;

library/modules/Gui.cpp

@@ -74,10 +74,10 @@ using namespace DFHack;
 #include "df/report_zoom_type.h"
 #include "df/route_stockpile_link.h"
 #include "df/stop_depart_condition.h"
-#include "df/ui_advmode.h"
-#include "df/ui_build_selector.h"
+#include "df/adventurest.h"
+#include "df/buildreq.h"
 #include "df/ui_look_list.h"
-#include "df/ui_sidebar_menus.h"
+#include "df/gamest.h"
 #include "df/ui_unit_view_mode.h"
 #include "df/unit.h"
 #include "df/unit_inventory_item.h"
@@ -101,9 +101,9 @@ using df::global::gps;
 using df::global::gview;
 using df::global::init;
 using df::global::selection_rect;
-using df::global::ui;
+using df::global::plotinfo;
 using df::global::ui_menu_width;
-using df::global::ui_sidebar_menus;
+using df::global::game;
 using df::global::world;
 
 /* TODO: understand how this changes for v50
@@ -158,9 +158,9 @@ DEFINE_GET_FOCUS_STRING_HANDLER(dwarfmode)
     using df::global::ui_building_assign_items;
     using df::global::ui_building_in_assign;
 
-    focus += "/" + enum_item_key(ui->main.mode);
+    focus += "/" + enum_item_key(plotinfo->main.mode);
 
-    switch (ui->main.mode)
+    switch (plotinfo->main.mode)
     {
     case QueryBuilding:
         if (df::building *selected = world->selected_building)
@@ -304,38 +304,38 @@ DEFINE_GET_FOCUS_STRING_HANDLER(dwarfmode)
         break;
 
     case Burrows:
-        if (ui->burrows.in_confirm_delete)
+        if (plotinfo->burrows.in_confirm_delete)
             focus += "/ConfirmDelete";
-        else if (ui->burrows.in_add_units_mode)
+        else if (plotinfo->burrows.in_add_units_mode)
             focus += "/AddUnits";
-        else if (ui->burrows.in_edit_name_mode)
+        else if (plotinfo->burrows.in_edit_name_mode)
             focus += "/EditName";
-        else if (ui->burrows.in_define_mode)
+        else if (plotinfo->burrows.in_define_mode)
             focus += "/Define";
         else
             focus += "/List";
         break;
 
     case Hauling:
-        if (ui->hauling.in_assign_vehicle)
+        if (plotinfo->hauling.in_assign_vehicle)
         {
-            auto vehicle = vector_get(ui->hauling.vehicles, ui->hauling.cursor_vehicle);
+            auto vehicle = vector_get(plotinfo->hauling.vehicles, plotinfo->hauling.cursor_vehicle);
             focus += "/AssignVehicle/" + std::string(vehicle ? "Some" : "None");
         }
         else
         {
-            int idx = ui->hauling.cursor_top;
-            auto route = vector_get(ui->hauling.view_routes, idx);
-            auto stop = vector_get(ui->hauling.view_stops, idx);
+            int idx = plotinfo->hauling.cursor_top;
+            auto route = vector_get(plotinfo->hauling.view_routes, idx);
+            auto stop = vector_get(plotinfo->hauling.view_stops, idx);
             std::string tag = stop ? "Stop" : (route ? "Route" : "None");
 
-            if (ui->hauling.in_name)
+            if (plotinfo->hauling.in_name)
                 focus += "/Rename/" + tag;
-            else if (ui->hauling.in_stop)
+            else if (plotinfo->hauling.in_stop)
             {
-                int sidx = ui->hauling.cursor_stop;
-                auto cond = vector_get(ui->hauling.stop_conditions, sidx);
-                auto link = vector_get(ui->hauling.stop_links, sidx);
+                int sidx = plotinfo->hauling.cursor_stop;
+                auto cond = vector_get(plotinfo->hauling.stop_conditions, sidx);
+                auto link = vector_get(plotinfo->hauling.stop_links, sidx);
 
                 focus += "/DefineStop";
 
@@ -364,12 +364,12 @@ DEFINE_GET_FOCUS_STRING_HANDLER(dwarfmode)
 /* TODO: understand how this changes for v50
 DEFINE_GET_FOCUS_STRING_HANDLER(dungeonmode)
 {
-    using df::global::ui_advmode;
+    using df::global::adventure;
 
-    if (!ui_advmode)
+    if (!adventure)
         return;
 
-    focus += "/" + enum_item_key(ui_advmode->menu);
+    focus += "/" + enum_item_key(adventure->menu);
 }
 
 DEFINE_GET_FOCUS_STRING_HANDLER(unitlist)
@@ -675,7 +675,7 @@ bool Gui::workshop_job_hotkey(df::viewscreen *top)
     using df::global::ui_workshop_in_add;
     using df::global::ui_workshop_job_cursor;
 
-    switch (ui->main.mode) {
+    switch (plotinfo->main.mode) {
     case QueryBuilding:
         {
             if (!ui_workshop_job_cursor) // allow missing
@@ -712,7 +712,7 @@ bool Gui::build_selector_hotkey(df::viewscreen *top)
     using namespace ui_sidebar_mode;
     using df::global::ui_build_selector;
 
-    switch (ui->main.mode) {
+    switch (plotinfo->main.mode) {
     case Build:
         {
             if (!ui_build_selector) // allow missing
@@ -739,7 +739,7 @@ bool Gui::view_unit_hotkey(df::viewscreen *top)
 /* TODO: understand how this changes for v50
     using df::global::ui_selected_unit;
 
-    if (ui->main.mode != ui_sidebar_mode::ViewUnits)
+    if (plotinfo->main.mode != ui_sidebar_mode::ViewUnits)
         return false;
     if (!ui_selected_unit) // allow missing
         return false;
@@ -1017,19 +1017,19 @@ df::unit *Gui::getAnyUnit(df::viewscreen *top)
     if (!Gui::dwarfmode_hotkey(top))
         return NULL;
 
-    if (!ui)
+    if (!plotinfo)
         return NULL;
 
     // general assigning units in building, i.e. (q)uery cage -> (a)ssign
     if (ui_building_in_assign && *ui_building_in_assign
         && ui_building_assign_units && ui_building_item_cursor
-        && ui->main.mode != Zones) // dont show for (i) zone
+        && plotinfo->main.mode != Zones) // dont show for (i) zone
         return vector_get(*ui_building_assign_units, *ui_building_item_cursor);
 
-    if (ui->follow_unit != -1)
-        return df::unit::find(ui->follow_unit);
+    if (plotinfo->follow_unit != -1)
+        return df::unit::find(plotinfo->follow_unit);
 
-    switch (ui->main.mode) {
+    switch (plotinfo->main.mode) {
     case ViewUnits:
     {
         if (!ui_selected_unit || !world)
@@ -1047,8 +1047,8 @@ df::unit *Gui::getAnyUnit(df::viewscreen *top)
     }
     case Burrows:
     {
-        if (ui->burrows.in_add_units_mode)
-            return vector_get(ui->burrows.list_units, ui->burrows.unit_cursor_pos);
+        if (plotinfo->burrows.in_add_units_mode)
+            return vector_get(plotinfo->burrows.list_units, plotinfo->burrows.unit_cursor_pos);
 
         return NULL;
     }
@@ -1196,16 +1196,16 @@ df::item *Gui::getAnyItem(df::viewscreen *top)
     if (!Gui::dwarfmode_hotkey(top))
         return NULL;
 
-    switch (ui->main.mode) {
+    switch (plotinfo->main.mode) {
     case ViewUnits:
     {
-        if (!ui_unit_view_mode || !ui_look_cursor || !ui_sidebar_menus)
+        if (!ui_unit_view_mode || !ui_look_cursor || !game)
             return NULL;
 
         if (ui_unit_view_mode->value != df::ui_unit_view_mode::Inventory)
             return NULL;
 
-        auto inv_item = vector_get(ui_sidebar_menus->unit.inv_items, *ui_look_cursor);
+        auto inv_item = vector_get(game->unit.inv_items, *ui_look_cursor);
         return inv_item ? inv_item->item : NULL;
     }
     case LookAround:
@@ -1271,7 +1271,7 @@ df::building *Gui::getAnyBuilding(df::viewscreen *top)
     if (!Gui::dwarfmode_hotkey(top))
         return NULL;
 
-    switch (ui->main.mode) {
+    switch (plotinfo->main.mode) {
     case LookAround:
     {
         if (!ui_look_list || !ui_look_cursor)
@@ -1293,8 +1293,8 @@ df::building *Gui::getAnyBuilding(df::viewscreen *top)
     case ZonesPitInfo:
     case ZonesHospitalInfo:
     {
-        if (ui_sidebar_menus)
-            return ui_sidebar_menus->zone.selected;
+        if (game)
+            return game->zone.selected;
         return NULL;
     }
     default:
@@ -1327,11 +1327,11 @@ df::plant *Gui::getAnyPlant(df::viewscreen *top)
 
     if (Gui::dwarfmode_hotkey(top))
     {
-        if (!cursor || !ui || !world)
+        if (!cursor || !plotinfo || !world)
             return nullptr;
 
 /* TODO: understand how this changes for v50
-        if (ui->main.mode == ui_sidebar_mode::LookAround)
+        if (plotinfo->main.mode == ui_sidebar_mode::LookAround)
         {
             return Maps::getPlantAtTile(cursor->x, cursor->y, cursor->z);
         }
@@ -1949,12 +1949,12 @@ void Gui::resetDwarfmodeView(bool pause)
 {
     using df::global::cursor;
 
-    if (ui)
+    if (plotinfo)
     {
-        ui->follow_unit = -1;
-        ui->follow_item = -1;
+        plotinfo->follow_unit = -1;
+        plotinfo->follow_item = -1;
 /* TODO: understand how this changes for v50
-        ui->main.mode = ui_sidebar_mode::Default;
+        plotinfo->main.mode = ui_sidebar_mode::Default;
 */
     }
 
@@ -2011,8 +2011,8 @@ bool Gui::revealInDwarfmodeMap(int32_t x, int32_t y, int32_t z, bool center)
     *window_x = clip_range(new_win_x, 0, (world->map.x_count - w));
     *window_y = clip_range(new_win_y, 0, (world->map.y_count - h));
     *window_z = clip_range(new_win_z, 0, (world->map.z_count - 1));
-    ui_sidebar_menus->minimap.need_render = true;
-    ui_sidebar_menus->minimap.need_scan = true;
+    game->minimap.need_render = true;
+    game->minimap.need_scan = true;
 
     return true;
 }
@@ -2058,10 +2058,10 @@ bool Gui::refreshSidebar()
 
 bool Gui::inRenameBuilding()
 {
-    if (!ui_sidebar_menus)
+    if (!game)
         return false;
     /* TODO: understand how this changes for v50
-    return ui_sidebar_menus->barracks.in_rename;
+    return game->barracks.in_rename;
     */
     return false;
 }

library/modules/Items.cpp

@@ -87,7 +87,7 @@ using namespace std;
 #include "df/reaction_product_itemst.h"
 #include "df/tool_uses.h"
 #include "df/trapcomp_flags.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/unit.h"
 #include "df/unit_inventory_item.h"
 #include "df/vehicle.h"
@@ -100,7 +100,7 @@ using namespace std;
 using namespace DFHack;
 using namespace df::enums;
 using df::global::world;
-using df::global::ui;
+using df::global::plotinfo;
 using df::global::ui_selected_unit;
 using df::global::proj_next_id;
 
@@ -924,7 +924,7 @@ static bool detachItem(MapExtras::MapCache &mc, df::item *item)
                 {
 /* TODO: understand how this changes for v50
                     // Unit view sidebar holds inventory item pointers
-                    if (ui->main.mode == ui_sidebar_mode::ViewUnits &&
+                    if (plotinfo->main.mode == ui_sidebar_mode::ViewUnits &&
                         (!ui_selected_unit ||
                          vector_get(world->units.active, *ui_selected_unit) == unit))
                         return false;
@@ -1534,7 +1534,7 @@ int32_t Items::createItem(df::item_type item_type, int16_t item_subtype, int16_t
     df::enums::game_type::game_type type = *df::global::gametype;
     prod->produce(unit, &out_products, &out_items, &in_reag, &in_items, 1, job_skill::NONE,
             0, df::historical_entity::find(unit->civ_id),
-            ((type == df::enums::game_type::DWARF_MAIN) || (type == df::enums::game_type::DWARF_RECLAIM)) ? df::world_site::find(df::global::ui->site_id) : NULL,
+            ((type == df::enums::game_type::DWARF_MAIN) || (type == df::enums::game_type::DWARF_RECLAIM)) ? df::world_site::find(df::global::plotinfo->site_id) : NULL,
             NULL);
     if ( out_items.size() != 1 )
         return -1;
@@ -1643,9 +1643,9 @@ bool Items::isRouteVehicle(df::item *item)
 bool Items::isSquadEquipment(df::item *item)
 {
     CHECK_NULL_POINTER(item);
-    if (!ui)
+    if (!plotinfo)
         return false;
 
-    auto &vec = ui->equipment.items_assigned[item->getType()];
+    auto &vec = plotinfo->equipment.items_assigned[item->getType()];
     return binsearch_index(vec, &df::item::id, item->id) >= 0;
 }

library/modules/Job.cpp

@@ -43,7 +43,7 @@ using namespace std;
 
 #include "DataDefs.h"
 #include "df/world.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/unit.h"
 #include "df/building.h"
 #include "df/job.h"

library/modules/Kitchen.cpp

@@ -20,13 +20,13 @@ using namespace DFHack;
 
 #include "DataDefs.h"
 #include "df/world.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/item_type.h"
 #include "df/plant_raw.h"
 
 using namespace df::enums;
 using df::global::world;
-using df::global::ui;
+using df::global::plotinfo;
 
 // Special values used by "seedwatch" plugin to store seed limits
 const df::enums::item_type::item_type SEEDLIMIT_ITEMTYPE = df::enums::item_type::BAR;
@@ -41,12 +41,12 @@ void Kitchen::debug_print(color_ostream &out)
     {
         out.print("%2zu: IT:%2i IS:%i MT:%3i MI:%2i ET:%i %s\n",
                        i,
-                       ui->kitchen.item_types[i],
-                       ui->kitchen.item_subtypes[i],
-                       ui->kitchen.mat_types[i],
-                       ui->kitchen.mat_indices[i],
-                       ui->kitchen.exc_types[i],
-                       (ui->kitchen.mat_types[i] >= 419 && ui->kitchen.mat_types[i] <= 618) ? world->raws.plants.all[ui->kitchen.mat_indices[i]]->id.c_str() : "n/a"
+                       plotinfo->kitchen.item_types[i],
+                       plotinfo->kitchen.item_subtypes[i],
+                       plotinfo->kitchen.mat_types[i],
+                       plotinfo->kitchen.mat_indices[i],
+                       plotinfo->kitchen.exc_types[i],
+                       (plotinfo->kitchen.mat_types[i] >= 419 && plotinfo->kitchen.mat_types[i] <= 618) ? world->raws.plants.all[plotinfo->kitchen.mat_indices[i]]->id.c_str() : "n/a"
         );
     }
     out.print("\n");
@@ -83,11 +83,11 @@ void Kitchen::fillWatchMap(std::map<int32_t, int16_t>& watchMap)
     watchMap.clear();
     for (std::size_t i = 0; i < size(); ++i)
     {
-        if (ui->kitchen.item_subtypes[i] == SEEDLIMIT_ITEMTYPE &&
-            ui->kitchen.item_subtypes[i] == SEEDLIMIT_ITEMSUBTYPE &&
-            ui->kitchen.exc_types[i] == SEEDLIMIT_EXCTYPE)
+        if (plotinfo->kitchen.item_subtypes[i] == SEEDLIMIT_ITEMTYPE &&
+            plotinfo->kitchen.item_subtypes[i] == SEEDLIMIT_ITEMSUBTYPE &&
+            plotinfo->kitchen.exc_types[i] == SEEDLIMIT_EXCTYPE)
         {
-            watchMap[ui->kitchen.mat_indices[i]] = ui->kitchen.mat_types[i];
+            watchMap[plotinfo->kitchen.mat_indices[i]] = plotinfo->kitchen.mat_types[i];
         }
     }
 }
@@ -96,10 +96,10 @@ int Kitchen::findLimit(int32_t plant_id)
 {
     for (size_t i = 0; i < size(); ++i)
     {
-        if (ui->kitchen.item_types[i] == SEEDLIMIT_ITEMTYPE &&
-            ui->kitchen.item_subtypes[i] == SEEDLIMIT_ITEMSUBTYPE &&
-            ui->kitchen.mat_indices[i] == plant_id &&
-            ui->kitchen.exc_types[i] == SEEDLIMIT_EXCTYPE)
+        if (plotinfo->kitchen.item_types[i] == SEEDLIMIT_ITEMTYPE &&
+            plotinfo->kitchen.item_subtypes[i] == SEEDLIMIT_ITEMSUBTYPE &&
+            plotinfo->kitchen.mat_indices[i] == plant_id &&
+            plotinfo->kitchen.exc_types[i] == SEEDLIMIT_EXCTYPE)
         {
             return int(i);
         }
@@ -113,11 +113,11 @@ bool Kitchen::removeLimit(int32_t plant_id)
     if (i < 0)
         return false;
 
-    ui->kitchen.item_types.erase(ui->kitchen.item_types.begin() + i);
-    ui->kitchen.item_subtypes.erase(ui->kitchen.item_subtypes.begin() + i);
-    ui->kitchen.mat_types.erase(ui->kitchen.mat_types.begin() + i);
-    ui->kitchen.mat_indices.erase(ui->kitchen.mat_indices.begin() + i);
-    ui->kitchen.exc_types.erase(ui->kitchen.exc_types.begin() + i);
+    plotinfo->kitchen.item_types.erase(plotinfo->kitchen.item_types.begin() + i);
+    plotinfo->kitchen.item_subtypes.erase(plotinfo->kitchen.item_subtypes.begin() + i);
+    plotinfo->kitchen.mat_types.erase(plotinfo->kitchen.mat_types.begin() + i);
+    plotinfo->kitchen.mat_indices.erase(plotinfo->kitchen.mat_indices.begin() + i);
+    plotinfo->kitchen.exc_types.erase(plotinfo->kitchen.exc_types.begin() + i);
     return true;
 }
 
@@ -129,15 +129,15 @@ bool Kitchen::setLimit(int32_t plant_id, int16_t limit)
     int i = findLimit(plant_id);
     if (i < 0)
     {
-        ui->kitchen.item_types.push_back(SEEDLIMIT_ITEMTYPE);
-        ui->kitchen.item_subtypes.push_back(SEEDLIMIT_ITEMSUBTYPE);
-        ui->kitchen.mat_types.push_back(limit);
-        ui->kitchen.mat_indices.push_back(plant_id);
-        ui->kitchen.exc_types.push_back(SEEDLIMIT_EXCTYPE);
+        plotinfo->kitchen.item_types.push_back(SEEDLIMIT_ITEMTYPE);
+        plotinfo->kitchen.item_subtypes.push_back(SEEDLIMIT_ITEMSUBTYPE);
+        plotinfo->kitchen.mat_types.push_back(limit);
+        plotinfo->kitchen.mat_indices.push_back(plant_id);
+        plotinfo->kitchen.exc_types.push_back(SEEDLIMIT_EXCTYPE);
     }
     else
     {
-        ui->kitchen.mat_types[i] = limit;
+        plotinfo->kitchen.mat_types[i] = limit;
     }
     return true;
 }
@@ -146,11 +146,11 @@ void Kitchen::clearLimits()
 {
     for (size_t i = 0; i < size(); ++i)
     {
-        if (ui->kitchen.item_types[i] == SEEDLIMIT_ITEMTYPE &&
-            ui->kitchen.item_subtypes[i] == SEEDLIMIT_ITEMSUBTYPE &&
-            ui->kitchen.exc_types[i] == SEEDLIMIT_EXCTYPE)
+        if (plotinfo->kitchen.item_types[i] == SEEDLIMIT_ITEMTYPE &&
+            plotinfo->kitchen.item_subtypes[i] == SEEDLIMIT_ITEMSUBTYPE &&
+            plotinfo->kitchen.exc_types[i] == SEEDLIMIT_EXCTYPE)
         {
-            removeLimit(ui->kitchen.mat_indices[i]);
+            removeLimit(plotinfo->kitchen.mat_indices[i]);
             --i;
         }
     }
@@ -158,7 +158,7 @@ void Kitchen::clearLimits()
 
 size_t Kitchen::size()
 {
-    return ui->kitchen.item_types.size();
+    return plotinfo->kitchen.item_types.size();
 }
 
 int Kitchen::findExclusion(df::kitchen_exc_type type,
@@ -167,11 +167,11 @@ int Kitchen::findExclusion(df::kitchen_exc_type type,
 {
     for (size_t i = 0; i < size(); i++)
     {
-        if (ui->kitchen.item_types[i] == item_type &&
-            ui->kitchen.item_subtypes[i] == item_subtype &&
-            ui->kitchen.mat_types[i] == mat_type &&
-            ui->kitchen.mat_indices[i] == mat_index &&
-            ui->kitchen.exc_types[i] == type)
+        if (plotinfo->kitchen.item_types[i] == item_type &&
+            plotinfo->kitchen.item_subtypes[i] == item_subtype &&
+            plotinfo->kitchen.mat_types[i] == mat_type &&
+            plotinfo->kitchen.mat_indices[i] == mat_index &&
+            plotinfo->kitchen.exc_types[i] == type)
         {
             return int(i);
         }
@@ -186,11 +186,11 @@ bool Kitchen::addExclusion(df::kitchen_exc_type type,
     if (findExclusion(type, item_type, item_subtype, mat_type, mat_index) >= 0)
         return false;
 
-    ui->kitchen.item_types.push_back(item_type);
-    ui->kitchen.item_subtypes.push_back(item_subtype);
-    ui->kitchen.mat_types.push_back(mat_type);
-    ui->kitchen.mat_indices.push_back(mat_index);
-    ui->kitchen.exc_types.push_back(type);
+    plotinfo->kitchen.item_types.push_back(item_type);
+    plotinfo->kitchen.item_subtypes.push_back(item_subtype);
+    plotinfo->kitchen.mat_types.push_back(mat_type);
+    plotinfo->kitchen.mat_indices.push_back(mat_index);
+    plotinfo->kitchen.exc_types.push_back(type);
     return true;
 }
 
@@ -202,10 +202,10 @@ bool Kitchen::removeExclusion(df::kitchen_exc_type type,
     if (i < 0)
         return false;
 
-    ui->kitchen.item_types.erase(ui->kitchen.item_types.begin() + i);
-    ui->kitchen.item_subtypes.erase(ui->kitchen.item_subtypes.begin() + i);
-    ui->kitchen.mat_types.erase(ui->kitchen.mat_types.begin() + i);
-    ui->kitchen.mat_indices.erase(ui->kitchen.mat_indices.begin() + i);
-    ui->kitchen.exc_types.erase(ui->kitchen.exc_types.begin() + i);
+    plotinfo->kitchen.item_types.erase(plotinfo->kitchen.item_types.begin() + i);
+    plotinfo->kitchen.item_subtypes.erase(plotinfo->kitchen.item_subtypes.begin() + i);
+    plotinfo->kitchen.mat_types.erase(plotinfo->kitchen.mat_types.begin() + i);
+    plotinfo->kitchen.mat_indices.erase(plotinfo->kitchen.mat_indices.begin() + i);
+    plotinfo->kitchen.exc_types.erase(plotinfo->kitchen.exc_types.begin() + i);
     return true;
 }

library/modules/Materials.cpp

@@ -42,7 +42,7 @@ using namespace std;
 #include "MiscUtils.h"
 
 #include "df/world.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/item.h"
 #include "df/creature_raw.h"
 #include "df/caste_raw.h"
@@ -68,7 +68,7 @@ using namespace DFHack;
 using namespace df::enums;
 
 using df::global::world;
-using df::global::ui;
+using df::global::plotinfo;
 
 bool MaterialInfo::decode(df::item *item)
 {
@@ -516,7 +516,7 @@ void MaterialInfo::getMatchBits(df::job_item_flags2 &ok, df::job_item_flags2 &ma
     TEST(fire_safe, material->heat.melting_point > 11000);
     TEST(magma_safe, material->heat.melting_point > 12000);
     TEST(deep_material, FLAG(inorganic, inorganic_flags::SPECIAL));
-    TEST(non_economic, !inorganic || !(ui && vector_get(ui->economic_stone, index)));
+    TEST(non_economic, !inorganic || !(plotinfo && vector_get(plotinfo->economic_stone, index)));
 
     TEST(plant, plant);
     TEST(silk, MAT_FLAG(SILK));

library/modules/Screen.cpp

@@ -502,6 +502,10 @@ bool Screen::hasActiveScreens(Plugin *plugin)
     return false;
 }
 
+void Screen::raise(df::viewscreen *screen) {
+    Hide swapper(screen, Screen::Hide::RESTORE_AT_TOP);
+}
+
 namespace DFHack { namespace Screen {
 
 Hide::Hide(df::viewscreen* screen, int flags) :

library/modules/Textures.cpp

@@ -0,0 +1,148 @@
+#include "Internal.h"
+
+#include "modules/DFSDL.h"
+#include "modules/Textures.h"
+
+#include "Debug.h"
+#include "PluginManager.h"
+
+#include "df/enabler.h"
+
+using df::global::enabler;
+using namespace DFHack;
+using namespace DFHack::DFSDL;
+
+namespace DFHack {
+    DBG_DECLARE(core, textures, DebugCategory::LINFO);
+}
+
+static bool g_loaded = false;
+static long g_num_dfhack_textures = 0;
+static long g_dfhack_logo_texpos_start = -1;
+
+// Converts an arbitrary Surface to something like the display format
+// (32-bit RGBA), and converts magenta to transparency if convert_magenta is set
+// and the source surface didn't already have an alpha channel.
+// It also deletes the source surface.
+//
+// It uses the same pixel format (RGBA, R at lowest address) regardless of
+// hardware.
+DFSDL_Surface * canonicalize_format(DFSDL_Surface *src) {
+  DFSDL_PixelFormat fmt;
+  fmt.palette = NULL;
+  fmt.BitsPerPixel = 32;
+  fmt.BytesPerPixel = 4;
+  fmt.Rloss = fmt.Gloss = fmt.Bloss = fmt.Aloss = 0;
+//#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+//  fmt.Rshift = 24; fmt.Gshift = 16; fmt.Bshift = 8; fmt.Ashift = 0;
+//#else
+  fmt.Rshift = 0; fmt.Gshift = 8; fmt.Bshift = 16; fmt.Ashift = 24;
+//#endif
+  fmt.Rmask = 255 << fmt.Rshift;
+  fmt.Gmask = 255 << fmt.Gshift;
+  fmt.Bmask = 255 << fmt.Bshift;
+  fmt.Amask = 255 << fmt.Ashift;
+  fmt.colorkey = 0;
+  fmt.alpha = 255;
+
+  DFSDL_Surface *tgt = DFSDL_ConvertSurface(src, &fmt, 0); // SDL_SWSURFACE
+  DFSDL_FreeSurface(src);
+  return tgt;
+}
+
+const uint32_t TILE_WIDTH_PX = 8;
+const uint32_t TILE_HEIGHT_PX = 12;
+
+static size_t load_textures(color_ostream & out, const char * fname,
+                            long *texpos_start) {
+    DFSDL_Surface *s = DFIMG_Load(fname);
+    if (!s) {
+        out.printerr("unable to load textures from '%s'\n", fname);
+        return 0;
+    }
+
+    s = canonicalize_format(s);
+    DFSDL_SetAlpha(s, 0, 255);
+    int dimx = s->w / TILE_WIDTH_PX;
+    int dimy = s->h / TILE_HEIGHT_PX;
+    long count = 0;
+    for (int y = 0; y < dimy; y++) {
+        for (int x = 0; x < dimx; x++) {
+            DFSDL_Surface *tile = DFSDL_CreateRGBSurface(0, // SDL_SWSURFACE
+                    TILE_WIDTH_PX, TILE_HEIGHT_PX, 32,
+                    s->format->Rmask, s->format->Gmask, s->format->Bmask,
+                    s->format->Amask);
+            DFSDL_SetAlpha(tile, 0,255);
+            DFSDL_Rect vp;
+            vp.x = TILE_WIDTH_PX * x;
+            vp.y = TILE_HEIGHT_PX * y;
+            vp.w = TILE_WIDTH_PX;
+            vp.h = TILE_HEIGHT_PX;
+            DFSDL_UpperBlit(s, &vp, tile, NULL);
+            if (!count++)
+                *texpos_start = enabler->textures.raws.size();
+            enabler->textures.raws.push_back(tile);
+        }
+    }
+    DFSDL_FreeSurface(s);
+
+    DEBUG(textures,out).print("loaded %ld textures from '%s'\n", count, fname);
+    return count;
+}
+
+// DFHack could conceivably be loaded at any time, so we need to be able to
+// handle loading textures before or after a world is loaded.
+// If a world is already loaded, then append our textures to the raws. they'll
+// be freed when the world is unloaded and we'll reload when we get to the title
+// screen. If it's pre-world, append our textures and then adjust the "init"
+// texture count so our textures will no longer be freed when worlds are
+// unloaded.
+//
+void Textures::init(color_ostream &out) {
+    auto & textures = enabler->textures;
+    long num_textures = textures.raws.size();
+    if (num_textures <= g_dfhack_logo_texpos_start)
+        g_loaded = false;
+
+    if (g_loaded)
+        return;
+
+    bool is_pre_world = num_textures == textures.init_texture_size;
+
+    g_num_dfhack_textures = load_textures(out, "hack/data/art/dfhack.png",
+                                          &g_dfhack_logo_texpos_start);
+
+    DEBUG(textures,out).print("loaded %ld textures\n", g_num_dfhack_textures);
+
+    if (is_pre_world)
+        textures.init_texture_size += g_num_dfhack_textures;
+
+    // NOTE: when GL modes are supported, we'll have to re-upload textures here
+
+    g_loaded = true;
+}
+
+// It's ok to leave NULLs in the raws list (according to usage in g_src)
+void Textures::cleanup() {
+    if (!g_loaded)
+        return;
+
+    auto & textures = enabler->textures;
+    auto &raws = textures.raws;
+    size_t texpos_end = g_dfhack_logo_texpos_start + g_num_dfhack_textures;
+    for (size_t idx = g_dfhack_logo_texpos_start; idx <= texpos_end; ++idx) {
+        DFSDL_FreeSurface((DFSDL_Surface *)raws[idx]);
+        raws[idx] = NULL;
+    }
+
+    if (g_dfhack_logo_texpos_start == textures.init_texture_size - g_num_dfhack_textures)
+        textures.init_texture_size -= g_num_dfhack_textures;
+
+    g_loaded = false;
+    g_num_dfhack_textures = 0;
+    g_dfhack_logo_texpos_start = -1;
+}
+
+long Textures::getDfhackLogoTexposStart() {
+    return g_dfhack_logo_texpos_start;
+}

library/modules/Units.cpp

@@ -73,7 +73,7 @@ using namespace std;
 #include "df/nemesis_record.h"
 #include "df/squad.h"
 #include "df/tile_occupancy.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/unit_inventory_item.h"
 #include "df/unit_misc_trait.h"
 #include "df/unit_relationship_type.h"
@@ -87,7 +87,7 @@ using namespace std;
 using namespace DFHack;
 using namespace df::enums;
 using df::global::world;
-using df::global::ui;
+using df::global::plotinfo;
 using df::global::gamemode;
 using df::global::gametype;
 
@@ -178,7 +178,7 @@ bool Units::isFortControlled(df::unit *unit)
         unit->flags2.bits.resident)
         return false;
 
-    return unit->civ_id != -1 && unit->civ_id == ui->civ_id;
+    return unit->civ_id != -1 && unit->civ_id == plotinfo->civ_id;
 }
 
 // check if creature belongs to the player's civilization
@@ -186,7 +186,7 @@ bool Units::isFortControlled(df::unit *unit)
 bool Units::isOwnCiv(df::unit* unit)
 {
     CHECK_NULL_POINTER(unit);
-    return unit->civ_id == ui->civ_id;
+    return unit->civ_id == plotinfo->civ_id;
 }
 
 // check if creature belongs to the player's group
@@ -199,7 +199,7 @@ bool Units::isOwnGroup(df::unit* unit)
     for (size_t i = 0; i < histfig->entity_links.size(); i++)
     {
         auto link = histfig->entity_links[i];
-        if (link->entity_id == ui->group_id && link->getType() == df::histfig_entity_link_type::MEMBER)
+        if (link->entity_id == plotinfo->group_id && link->getType() == df::histfig_entity_link_type::MEMBER)
             return true;
     }
     return false;
@@ -210,7 +210,7 @@ bool Units::isOwnGroup(df::unit* unit)
 bool Units::isOwnRace(df::unit* unit)
 {
     CHECK_NULL_POINTER(unit);
-    return unit->race == ui->race_id;
+    return unit->race == plotinfo->race_id;
 }
 
 
@@ -622,8 +622,8 @@ bool Units::isDwarf(df::unit *unit)
 {
     CHECK_NULL_POINTER(unit);
 
-    return unit->race == ui->race_id ||
-           unit->enemy.normal_race == ui->race_id;
+    return unit->race == plotinfo->race_id ||
+           unit->enemy.normal_race == plotinfo->race_id;
 }
 
 bool Units::isAnimal(df::unit* unit) {
@@ -1301,7 +1301,7 @@ bool Units::setLaborValidity(df::unit_labor labor, bool isValid)
         return false;
     if (labor == df::unit_labor::NONE)
         return false;
-    df::historical_entity *entity = df::historical_entity::find(ui->civ_id);
+    df::historical_entity *entity = df::historical_entity::find(plotinfo->civ_id);
     if (!entity || !entity->entity_raw)
         return false;
     entity->entity_raw->jobs.permitted_labor[labor] = isValid;
@@ -1704,7 +1704,7 @@ std::string Units::getCasteProfessionName(int race, int casteid, df::profession
 
     if (pid < (df::profession)0 || !is_valid_enum_item(pid))
         return "";
-    int16_t current_race = df::global::ui->race_id;
+    int16_t current_race = df::global::plotinfo->race_id;
     if (df::global::gamemode && *df::global::gamemode == df::game_mode::ADVENTURE)
         current_race = world->units.active[0]->race;
     bool use_race_prefix = (race >= 0 && race != current_race);

library/xml

@@ -1 +1 @@
-Subproject commit dff467dccfe77fb1dd0468ac87989d2e08227592
+Subproject commit d026f34ed1f7ab79aebb1c5bc8a36ee9b30bd13d

plugins/.gitignore

@@ -0,0 +1 @@
+!buildingplan/

plugins/add-spatter.cpp

@@ -24,7 +24,7 @@
 #include "df/job.h"
 #include "df/job_item.h"
 #include "df/job_item_ref.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/report.h"
 #include "df/reaction.h"
 #include "df/reaction_reagent_itemst.h"
@@ -45,7 +45,7 @@ DFHACK_PLUGIN("add-spatter");
 DFHACK_PLUGIN_IS_ENABLED(is_enabled);
 REQUIRE_GLOBAL(gps);
 REQUIRE_GLOBAL(world);
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 
 typedef df::reaction_product_item_improvementst improvement_product;
 

plugins/autochop.cpp

@@ -22,7 +22,7 @@
 #include "df/plant_tree_tile.h"
 #include "df/plant_raw.h"
 #include "df/tile_dig_designation.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/viewscreen_dwarfmodest.h"
 #include "df/world.h"
 
@@ -45,7 +45,7 @@ using namespace df::enums;
 #define PLUGIN_VERSION 0.3
 DFHACK_PLUGIN("autochop");
 REQUIRE_GLOBAL(world);
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 
 static int get_log_count();
 
@@ -499,7 +499,7 @@ public:
 
         burrows_column.clear();
 
-        for (df::burrow *burrow : ui->burrows.list)
+        for (df::burrow *burrow : plotinfo->burrows.list)
         {
             string name = burrow->name;
             if (name.empty())
@@ -820,7 +820,7 @@ struct autochop_hook : public df::viewscreen_dwarfmodest
     bool isInDesignationMenu()
     {
         using namespace df::enums::ui_sidebar_mode;
-        return (ui->main.mode == DesignateChopTrees);
+        return (plotinfo->main.mode == DesignateChopTrees);
     }
 
     void sendKey(const df::interface_key &key)

plugins/autofarm.cpp

@@ -5,7 +5,7 @@
 
 #include "DataDefs.h"
 #include "df/world.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/building_type.h"
 #include "df/building_farmplotst.h"
 #include "df/buildings_other_id.h"
@@ -30,7 +30,7 @@ using namespace DFHack;
 using namespace df::enums;
 
 using df::global::world;
-using df::global::ui;
+using df::global::plotinfo;
 
 static command_result autofarm(color_ostream& out, std::vector<std::string>& parameters);
 
@@ -348,7 +348,7 @@ static std::unique_ptr<AutoFarm> autofarmInstance;
 
 DFhackCExport command_result plugin_init(color_ostream& out, std::vector <PluginCommand>& commands)
 {
-    if (world && ui) {
+    if (world && plotinfo) {
         commands.push_back(
             PluginCommand("autofarm",
                           "Automatically manage farm crop selection.",

plugins/autogems.cpp

@@ -33,7 +33,7 @@ using namespace DFHack;
 DFHACK_PLUGIN("autogems");
 DFHACK_PLUGIN_IS_ENABLED(enabled);
 
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 REQUIRE_GLOBAL(world);
 
 typedef int32_t item_id;
@@ -242,7 +242,7 @@ struct autogem_hook : public df::viewscreen_dwarfmodest {
 
     bool in_menu() {
         // Determines whether we're looking at the Workshop Orders screen.
-        return ui->main.mode == ui_sidebar_mode::OrdersWorkshop;
+        return plotinfo->main.mode == ui_sidebar_mode::OrdersWorkshop;
     }
 
     bool handleInput(std::set<df::interface_key> *input) {

plugins/autolabor/autohauler.cpp

@@ -12,7 +12,7 @@
 
 // DF data structure definition headers
 #include "DataDefs.h"
-#include <df/ui.h>
+#include <df/plotinfost.h>
 #include <df/world.h>
 #include <df/unit.h>
 #include <df/unit_soul.h>
@@ -32,7 +32,7 @@
 #include <df/building_tradedepotst.h>
 #include <df/building_stockpilest.h>
 #include <df/items_other_id.h>
-#include <df/ui.h>
+#include <df/plotinfost.h>
 #include <df/activity_info.h>
 
 #include <MiscUtils.h>
@@ -47,7 +47,7 @@ using namespace DFHack;
 using namespace df::enums;
 
 DFHACK_PLUGIN("autohauler");
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 REQUIRE_GLOBAL(world);
 
 #define ARRAY_COUNT(array) (sizeof(array)/sizeof((array)[0]))

plugins/autolabor/autolabor.cpp

@@ -12,7 +12,7 @@
 
 // DF data structure definition headers
 #include "DataDefs.h"
-#include <df/ui.h>
+#include <df/plotinfost.h>
 #include <df/world.h>
 #include <df/unit.h>
 #include <df/unit_soul.h>
@@ -32,7 +32,7 @@
 #include <df/building_tradedepotst.h>
 #include <df/building_stockpilest.h>
 #include <df/items_other_id.h>
-#include <df/ui.h>
+#include <df/plotinfost.h>
 #include <df/activity_info.h>
 
 #include <MiscUtils.h>
@@ -47,7 +47,7 @@ using namespace DFHack;
 using namespace df::enums;
 
 DFHACK_PLUGIN("autolabor");
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 REQUIRE_GLOBAL(world);
 
 #define ARRAY_COUNT(array) (sizeof(array)/sizeof((array)[0]))
@@ -813,7 +813,7 @@ DFhackCExport command_result plugin_onupdate ( color_ostream &out )
 
         // identify dwarfs who are needed for meetings and mark them for exclusion
 
-        for (auto& act : ui->activities)
+        for (auto& act : plotinfo->activities)
         {
             if (!act) continue;
             bool p1 = act->unit_actor == dwarfs[dwarf];

plugins/autolabor/joblabormapper.cpp

@@ -56,7 +56,7 @@ using std::string;
 using std::endl;
 using namespace DFHack;
 using namespace df::enums;
-using df::global::ui;
+using df::global::plotinfo;
 using df::global::world;
 
 #include "labormanager.h"

plugins/autolabor/labormanager.cpp

@@ -25,7 +25,7 @@
 #include "DataDefs.h"
 #include <MiscUtils.h>
 
-#include <df/ui.h>
+#include <df/plotinfost.h>
 #include <df/world.h>
 #include <df/unit.h>
 #include <df/unit_relationship_type.h>
@@ -46,7 +46,7 @@
 #include <df/building_tradedepotst.h>
 #include <df/building_stockpilest.h>
 #include <df/items_other_id.h>
-#include <df/ui.h>
+#include <df/plotinfost.h>
 #include <df/activity_info.h>
 #include <df/tile_dig_designation.h>
 #include <df/item_weaponst.h>
@@ -64,7 +64,7 @@
 #include <df/building_design.h>
 #include <df/vehicle.h>
 #include <df/units_other_id.h>
-#include <df/ui.h>
+#include <df/plotinfost.h>
 #include <df/training_assignment.h>
 #include <df/general_ref_contains_itemst.h>
 #include <df/personality_facet_type.h>
@@ -82,7 +82,7 @@ using std::string;
 using std::endl;
 using namespace DFHack;
 using namespace df::enums;
-using df::global::ui;
+using df::global::plotinfo;
 using df::global::world;
 
 #define ARRAY_COUNT(array) (sizeof(array)/sizeof((array)[0]))
@@ -948,9 +948,9 @@ private:
 
                 // identify dwarfs who are needed for meetings and mark them for exclusion
 
-                for (size_t i = 0; i < ui->activities.size(); ++i)
+                for (size_t i = 0; i < plotinfo->activities.size(); ++i)
                 {
-                    df::activity_info *act = ui->activities[i];
+                    df::activity_info *act = plotinfo->activities[i];
                     if (!act) continue;
 
                     bool p1 = act->unit_actor == dwarf->dwarf;
@@ -996,11 +996,11 @@ private:
 
                 for (size_t j = 0; j < dwarf->dwarf->inventory.size(); j++)
                 {
-                    df::unit_inventory_item* ui = dwarf->dwarf->inventory[j];
-                    if (ui->mode == df::unit_inventory_item::Weapon && ui->item->isWeapon())
+                    df::unit_inventory_item* plotinfo = dwarf->dwarf->inventory[j];
+                    if (plotinfo->mode == df::unit_inventory_item::Weapon && plotinfo->item->isWeapon())
                     {
                         dwarf->armed = true;
-                        df::itemdef_weaponst* weapondef = ((df::item_weaponst*)(ui->item))->subtype;
+                        df::itemdef_weaponst* weapondef = ((df::item_weaponst*)(plotinfo->item))->subtype;
                         df::job_skill weaponsk = (df::job_skill) weapondef->skill_melee;
                         df::job_skill rangesk = (df::job_skill) weapondef->skill_ranged;
                         if (weaponsk == df::job_skill::AXE)
@@ -1408,8 +1408,8 @@ public:
             (isOptionEnabled(CF_ALLOW_HUNTING) && has_butchers) ? 1 : 0;
 
         /* add animal trainers */
-        for (auto a = df::global::ui->equipment.training_assignments.begin();
-            a != df::global::ui->equipment.training_assignments.end();
+        for (auto a = df::global::plotinfo->equipment.training_assignments.begin();
+            a != df::global::plotinfo->equipment.training_assignments.end();
             a++)
         {
             labor_needed[df::unit_labor::ANIMALTRAIN]++;

plugins/automaterial.cpp

@@ -21,8 +21,8 @@
 #include "df/build_req_choice_specst.h"
 #include "df/construction_type.h"
 #include "df/item.h"
-#include "df/ui.h"
-#include "df/ui_build_selector.h"
+#include "df/plotinfost.h"
+#include "df/buildreq.h"
 #include "df/viewscreen_dwarfmodest.h"
 #include "df/items_other_id.h"
 #include "df/job.h"
@@ -50,7 +50,7 @@ using namespace df::enums;
 
 DFHACK_PLUGIN("automaterial");
 REQUIRE_GLOBAL(gps);
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 REQUIRE_GLOBAL(ui_build_selector);
 
 namespace DFHack {
@@ -115,14 +115,14 @@ static inline bool in_material_choice_stage()
 {
     return Gui::build_selector_hotkey(Core::getTopViewscreen()) &&
         ui_build_selector->building_type == df::building_type::Construction &&
-        ui->main.mode == ui_sidebar_mode::Build &&
+        plotinfo->main.mode == ui_sidebar_mode::Build &&
         ui_build_selector->stage == 2;
 }
 
 static inline bool in_placement_stage()
 {
     return Gui::dwarfmode_hotkey(Core::getTopViewscreen()) &&
-        ui->main.mode == ui_sidebar_mode::Build &&
+        plotinfo->main.mode == ui_sidebar_mode::Build &&
         ui_build_selector &&
         ui_build_selector->building_type == df::building_type::Construction &&
         ui_build_selector->stage == 1;
@@ -131,7 +131,7 @@ static inline bool in_placement_stage()
 static inline bool in_type_choice_stage()
 {
     return Gui::dwarfmode_hotkey(Core::getTopViewscreen()) &&
-        ui->main.mode == ui_sidebar_mode::Build &&
+        plotinfo->main.mode == ui_sidebar_mode::Build &&
         ui_build_selector &&
         ui_build_selector->building_type < 0;
 }
@@ -713,7 +713,7 @@ struct jobutils_hook : public df::viewscreen_dwarfmodest
         if (!box_select_enabled)
             return;
 
-        if (ui->main.mode != df::ui_sidebar_mode::Build ||
+        if (plotinfo->main.mode != df::ui_sidebar_mode::Build ||
             ui_build_selector->building_type != df::building_type::Construction)
             return;
 

plugins/automelt.cpp

@@ -9,7 +9,7 @@
 #include "df/building_stockpilest.h"
 #include "modules/Buildings.h"
 #include "modules/Items.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "modules/Maps.h"
 #include "modules/World.h"
 #include "df/item_quality.h"
@@ -21,7 +21,7 @@ DFHACK_PLUGIN("automelt");
 REQUIRE_GLOBAL(gps);
 REQUIRE_GLOBAL(world);
 REQUIRE_GLOBAL(cursor);
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 
 static const string PERSISTENCE_KEY = "automelt/stockpiles";
 

plugins/autotrade.cpp

@@ -15,7 +15,7 @@
 #include "df/job.h"
 #include "df/job_item_ref.h"
 #include "modules/Job.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/mandate.h"
 #include "modules/Maps.h"
 
@@ -25,7 +25,7 @@ DFHACK_PLUGIN("autotrade");
 REQUIRE_GLOBAL(gps);
 REQUIRE_GLOBAL(world);
 REQUIRE_GLOBAL(cursor);
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 
 static const string PERSISTENCE_KEY = "autotrade/stockpiles";
 

plugins/buildingplan/buildingplan-planner.cpp

@@ -6,7 +6,7 @@
 #include "df/building_type.h"
 #include "df/general_ref_building_holderst.h"
 #include "df/job_item.h"
-#include "df/ui_build_selector.h"
+#include "df/buildreq.h"
 
 #include "modules/Buildings.h"
 #include "modules/Gui.h"

plugins/buildingplan/buildingplan.cpp

@@ -1,7 +1,7 @@
 #include "df/construction_type.h"
 #include "df/entity_position.h"
 #include "df/interface_key.h"
-#include "df/ui_build_selector.h"
+#include "df/buildreq.h"
 #include "df/viewscreen_dwarfmodest.h"
 
 #include "modules/Gui.h"
@@ -18,7 +18,7 @@
 
 DFHACK_PLUGIN("buildingplan");
 #define PLUGIN_VERSION "2.0"
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 REQUIRE_GLOBAL(ui_build_selector);
 REQUIRE_GLOBAL(world); // used in buildingplan library
 
@@ -455,8 +455,8 @@ struct buildingplan_query_hook : public df::viewscreen_dwarfmodest
 
     bool isInPlannedBuildingQueryMode()
     {
-        return (ui->main.mode == df::ui_sidebar_mode::QueryBuilding ||
-            ui->main.mode == df::ui_sidebar_mode::BuildingItems) &&
+        return (plotinfo->main.mode == df::ui_sidebar_mode::QueryBuilding ||
+            plotinfo->main.mode == df::ui_sidebar_mode::BuildingItems) &&
             planner.getPlannedBuilding(world->selected_building);
     }
 
@@ -595,7 +595,7 @@ struct buildingplan_place_hook : public df::viewscreen_dwarfmodest
 
     bool isInPlannedBuildingPlacementMode()
     {
-        return ui->main.mode == ui_sidebar_mode::Build &&
+        return plotinfo->main.mode == ui_sidebar_mode::Build &&
             df::global::ui_build_selector &&
             df::global::ui_build_selector->stage < 2 &&
             planner.isPlannableBuilding(toBuildingTypeKey(ui_build_selector));
@@ -861,7 +861,7 @@ struct buildingplan_room_hook : public df::viewscreen_dwarfmodest
     std::vector<Units::NoblePosition> getNoblePositionOfSelectedBuildingOwner()
     {
         std::vector<Units::NoblePosition> np;
-        if (ui->main.mode != df::ui_sidebar_mode::QueryBuilding ||
+        if (plotinfo->main.mode != df::ui_sidebar_mode::QueryBuilding ||
             !world->selected_building ||
             !world->selected_building->owner)
         {
@@ -1084,7 +1084,7 @@ DFhackCExport command_result plugin_onstatechange(color_ostream &out, state_chan
 static bool is_paused()
 {
     return World::ReadPauseState() ||
-        ui->main.mode > df::ui_sidebar_mode::Squads ||
+        plotinfo->main.mode > df::ui_sidebar_mode::Squads ||
         !strict_virtual_cast<df::viewscreen_dwarfmodest>(Gui::getCurViewscreen(true));
 }
 

plugins/burrows.cpp

@@ -17,7 +17,7 @@
 #include "TileTypes.h"
 
 #include "DataDefs.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/world.h"
 #include "df/unit.h"
 #include "df/burrow.h"
@@ -38,7 +38,7 @@ using namespace df::enums;
 using namespace dfproto;
 
 DFHACK_PLUGIN("burrows");
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 REQUIRE_GLOBAL(world);
 REQUIRE_GLOBAL(gamemode);
 
@@ -102,11 +102,11 @@ DEFINE_LUA_EVENT_1(onBurrowRename, handle_burrow_rename, df::burrow*);
 
 static void detect_burrow_renames(color_ostream &out)
 {
-    if (ui->main.mode == ui_sidebar_mode::Burrows &&
-        ui->burrows.in_edit_name_mode &&
-        ui->burrows.sel_id >= 0)
+    if (plotinfo->main.mode == ui_sidebar_mode::Burrows &&
+        plotinfo->burrows.in_edit_name_mode &&
+        plotinfo->burrows.sel_id >= 0)
     {
-        name_burrow_id = ui->burrows.sel_id;
+        name_burrow_id = plotinfo->burrows.sel_id;
     }
     else if (name_burrow_id >= 0)
     {
@@ -222,7 +222,7 @@ static std::map<std::string,int> name_lookup;
 
 static void parse_names()
 {
-    auto &list = ui->burrows.list;
+    auto &list = plotinfo->burrows.list;
 
     grow_burrows.clear();
     name_lookup.clear();

plugins/confirm.cpp

@@ -36,7 +36,7 @@ using std::vector;
 DFHACK_PLUGIN("confirm");
 DFHACK_PLUGIN_IS_ENABLED(is_enabled);
 REQUIRE_GLOBAL(gps);
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 
 typedef std::set<df::interface_key> ikey_set;
 command_result df_confirm (color_ostream &out, vector <string> & parameters);

plugins/createitem.cpp

@@ -16,7 +16,7 @@
 #include "DataDefs.h"
 #include "df/game_type.h"
 #include "df/world.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/unit.h"
 #include "df/historical_entity.h"
 #include "df/world_site.h"
@@ -38,7 +38,7 @@ using namespace df::enums;
 DFHACK_PLUGIN("createitem");
 REQUIRE_GLOBAL(cursor);
 REQUIRE_GLOBAL(world);
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 REQUIRE_GLOBAL(gametype);
 REQUIRE_GLOBAL(cur_year_tick);
 
@@ -78,7 +78,7 @@ bool makeItem (df::reaction_product_itemst *prod, df::unit *unit, bool second_it
 
     prod->produce(unit, &out_products, &out_items, &in_reag, &in_items, 1, job_skill::NONE,
         0, df::historical_entity::find(unit->civ_id),
-        (World::isFortressMode()) ? df::world_site::find(ui->site_id) : NULL, NULL);
+        (World::isFortressMode()) ? df::world_site::find(plotinfo->site_id) : NULL, NULL);
     if (!out_items.size())
         return false;
     // if we asked to make shoes and we got twice as many as we asked, then we're okay

plugins/debug.cpp

@@ -43,7 +43,7 @@ namespace DFHack {
 DBG_DECLARE(debug,filter);
 DBG_DECLARE(debug,init);
 DBG_DECLARE(debug,command);
-DBG_DECLARE(debug,ui);
+DBG_DECLARE(debug,plotinfo);
 DBG_DECLARE(debug,example,DebugCategory::LINFO);
 }
 

plugins/devel/kittens.cpp

@@ -33,7 +33,7 @@ using namespace DFHack;
 
 DFHACK_PLUGIN("kittens");
 DFHACK_PLUGIN_IS_ENABLED(is_enabled);
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 REQUIRE_GLOBAL(world);
 
 namespace DFHack {
@@ -119,9 +119,9 @@ DFhackCExport command_result plugin_onupdate ( color_ostream &out )
     }
     if(trackmenu_flg)
     {
-        if (last_menu != ui->main.mode)
+        if (last_menu != plotinfo->main.mode)
         {
-            last_menu = ui->main.mode;
+            last_menu = plotinfo->main.mode;
             out.print("Menu: %d\n",last_menu);
         }
     }
@@ -157,7 +157,7 @@ command_result trackmenu (color_ostream &out, vector <string> & parameters)
     else
     {
         is_enabled = true;
-        last_menu = ui->main.mode;
+        last_menu = plotinfo->main.mode;
         out.print("Menu: %d\n",last_menu);
         trackmenu_flg = true;
         return CR_OK;

plugins/devel/stockcheck.cpp

@@ -5,7 +5,7 @@
 
 #include "DataDefs.h"
 #include "df/world.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/building_stockpilest.h"
 #include "df/global_objects.h"
 #include "df/item.h"
@@ -24,7 +24,7 @@ using namespace DFHack;
 using namespace df::enums;
 
 using df::global::world;
-using df::global::ui;
+using df::global::plotinfo;
 using df::global::selection_rect;
 
 using df::building_stockpilest;
@@ -35,7 +35,7 @@ DFHACK_PLUGIN("stockcheck");
 
 DFhackCExport command_result plugin_init (color_ostream &out, std::vector <PluginCommand> &commands)
 {
-    if (world && ui) {
+    if (world && plotinfo) {
         commands.push_back(
             PluginCommand("stockcheck", "Check for unprotected rottable items.",
                 stockcheck, false,

plugins/devel/stripcaged.cpp

@@ -20,7 +20,7 @@ using namespace std;
 #include "modules/World.h"
 #include "MiscUtils.h"
 
-#include <df/ui.h>
+#include <df/plotinfost.h>
 #include "df/world.h"
 #include "df/world_raws.h"
 #include "df/building_def.h"
@@ -34,7 +34,7 @@ using namespace DFHack;
 using namespace df::enums;
 using df::global::world;
 using df::global::cursor;
-using df::global::ui;
+using df::global::plotinfo;
 
 using namespace DFHack::Gui;
 

plugins/dig-now.cpp

@@ -20,14 +20,14 @@
 #include <df/reaction_product_itemst.h>
 #include <df/tile_designation.h>
 #include <df/tile_occupancy.h>
-#include <df/ui.h>
+#include <df/plotinfost.h>
 #include <df/unit.h>
 #include <df/vermin.h>
 #include <df/world.h>
 #include <df/world_site.h>
 
 DFHACK_PLUGIN("dig-now");
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 REQUIRE_GLOBAL(world);
 
 using namespace DFHack;
@@ -678,7 +678,7 @@ static void create_boulders(color_ostream &out,
     df::unit *unit = world->units.active[0];
     df::historical_entity *civ = df::historical_entity::find(unit->civ_id);
     df::world_site *site = World::isFortressMode() ?
-            df::world_site::find(ui->site_id) : NULL;
+            df::world_site::find(plotinfo->site_id) : NULL;
 
     std::vector<df::reaction_reagent *> in_reag;
     std::vector<df::item *> in_items;

plugins/dig.cpp

@@ -16,7 +16,7 @@
 #include "modules/Maps.h"
 #include "modules/Materials.h"
 
-#include "df/ui_sidebar_menus.h"
+#include "df/gamest.h"
 
 using std::vector;
 using std::string;
@@ -33,7 +33,7 @@ command_result digcircle (color_ostream &out, vector <string> & parameters);
 command_result digtype (color_ostream &out, vector <string> & parameters);
 
 DFHACK_PLUGIN("dig");
-REQUIRE_GLOBAL(ui_sidebar_menus);
+REQUIRE_GLOBAL(game);
 REQUIRE_GLOBAL(world);
 REQUIRE_GLOBAL(window_z);
 
@@ -213,7 +213,7 @@ bool lineY (MapExtras::MapCache & MCache,
 
 int32_t parse_priority(color_ostream &out, vector<string> &parameters)
 {
-    int32_t default_priority = ui_sidebar_menus->designation.priority;
+    int32_t default_priority = game->designation.priority;
 
     for (auto it = parameters.begin(); it != parameters.end(); ++it)
     {

plugins/diggingInvaders/assignJob.cpp

@@ -25,7 +25,7 @@
 #include "df/job_type.h"
 #include "df/reaction_product_itemst.h"
 #include "df/reaction_reagent.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/unit.h"
 #include "df/unit_inventory_item.h"
 #include "df/world.h"
@@ -252,7 +252,7 @@ int32_t assignJob(color_ostream& out, Edge firstImportantEdge, unordered_map<df:
             vector<df::item*> in_items;
             prod->produce(firstInvader, &out_products, &out_items, &in_reag, &in_items, 1, df::job_skill::NONE,
                 0, df::historical_entity::find(firstInvader->civ_id),
-                df::world_site::find(df::global::ui->site_id), NULL);
+                df::world_site::find(df::global::plotinfo->site_id), NULL);
 
             if ( out_items.size() != 1 ) {
                 out.print("%s, %d: wrong size: %zu.\n", __FILE__, __LINE__, out_items.size());

plugins/diggingInvaders/diggingInvaders.cpp

@@ -47,7 +47,7 @@
 #include "df/tiletype_material.h"
 #include "df/tiletype_shape.h"
 #include "df/tiletype_shape_basic.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/unit.h"
 #include "df/unit_inventory_item.h"
 #include "df/world.h"

plugins/dwarfmonitor.cpp

@@ -4,7 +4,7 @@
 #include "DataDefs.h"
 
 #include "df/job.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/unit.h"
 #include "df/viewscreen_dwarfmodest.h"
 #include "df/world.h"
@@ -53,7 +53,7 @@ using std::deque;
 DFHACK_PLUGIN("dwarfmonitor");
 DFHACK_PLUGIN_IS_ENABLED(is_enabled);
 REQUIRE_GLOBAL(world);
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 
 typedef int16_t activity_type;
 

plugins/dwarfvet.cpp

@@ -39,7 +39,7 @@
 #include "df/job.h"
 #include "df/general_ref_unit_workerst.h"
 #include "df/profession.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/unit.h"
 #include "df/unit_health_info.h"
 #include "df/unit_health_flags.h"
@@ -58,7 +58,7 @@ using namespace std;
 DFHACK_PLUGIN("dwarfvet");
 DFHACK_PLUGIN_IS_ENABLED(dwarfvet_enabled);
 
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 REQUIRE_GLOBAL(world);
 
 static unordered_set<int32_t> tracked_units;
@@ -407,7 +407,7 @@ void tickHandler(color_ostream& out, void* data) {
     if ( !dwarfvet_enabled )
         return;
     CoreSuspender suspend;
-    int32_t own_race_id = df::global::ui->race_id;
+    int32_t own_race_id = df::global::plotinfo->race_id;
 
     /**
      * Generate a list of animal hospitals on the map

plugins/embark-assistant/finder_ui.cpp

@@ -123,7 +123,7 @@ namespace embark_assist {
 
         struct states {
             embark_assist::defs::find_callbacks find_callback;
-            uis ui;
+            uis plotinfo;
             display_maps finder_list;  //  Don't need the element key, but it's easier to use the same type.
             uint16_t finder_list_focus;
             bool finder_list_active;
@@ -171,13 +171,13 @@ namespace embark_assist {
             size_t civ = 0;
 
             while (true) {
-                for (size_t k = 0; k < state->ui[static_cast<int8_t>(i)]->list.size(); k++) {
-                    if (state->ui[static_cast<int8_t>(i) + civ]->current_value == state->ui[static_cast<int8_t>(i) + civ]->list[k].key) {
-                        fprintf(outfile, "[%s:%s]\n", state->finder_list[static_cast<int8_t>(i) + civ].text.c_str(), state->ui[static_cast<int8_t>(i) + civ]->list[k].text.c_str());
+                for (size_t k = 0; k < state->plotinfo[static_cast<int8_t>(i)]->list.size(); k++) {
+                    if (state->plotinfo[static_cast<int8_t>(i) + civ]->current_value == state->plotinfo[static_cast<int8_t>(i) + civ]->list[k].key) {
+                        fprintf(outfile, "[%s:%s]\n", state->finder_list[static_cast<int8_t>(i) + civ].text.c_str(), state->plotinfo[static_cast<int8_t>(i) + civ]->list[k].text.c_str());
                         break;
                     }
                 }
-//                fprintf(outfile, "[%s:%i]\n", state->finder_list[static_cast<int8_t>(i)].text.c_str(), state->ui[static_cast<int8_t>(i)]->current_value);
+//                fprintf(outfile, "[%s:%i]\n", state->finder_list[static_cast<int8_t>(i)].text.c_str(), state->plotinfo[static_cast<int8_t>(i)]->current_value);
                 if (i == last_fields) {
                     civ++;
 
@@ -229,10 +229,10 @@ namespace embark_assist {
 
                         found = false;
 
-                        for (size_t l = 0; l < state->ui[static_cast<int8_t>(i) + civ]->list.size(); l++) {
+                        for (size_t l = 0; l < state->plotinfo[static_cast<int8_t>(i) + civ]->list.size(); l++) {
                             for (int m = k + 1; m < count; m++) {
-                                if (state->ui[static_cast<int8_t>(i) + civ]->list[l].text.c_str()[m - (k + 1)] != line[m]) {
-                                    if (state->ui[static_cast<int8_t>(i) + civ]->list[l].text.c_str()[m - (k + 1)] == '\0' &&
+                                if (state->plotinfo[static_cast<int8_t>(i) + civ]->list[l].text.c_str()[m - (k + 1)] != line[m]) {
+                                    if (state->plotinfo[static_cast<int8_t>(i) + civ]->list[l].text.c_str()[m - (k + 1)] == '\0' &&
                                         line[m] == ']') {
                                         found = true;
                                     }
@@ -291,13 +291,13 @@ namespace embark_assist {
 
                         found = false;
 
-                        for (size_t l = 0; l < state->ui[static_cast<int8_t>(i) + civ]->list.size(); l++) {
+                        for (size_t l = 0; l < state->plotinfo[static_cast<int8_t>(i) + civ]->list.size(); l++) {
                             for (int m = k + 1; m < count; m++) {
-                                if (state->ui[static_cast<int8_t>(i) + civ]->list[l].text.c_str()[m - (k + 1)] != line[m]) {
-                                    if (state->ui[static_cast<int8_t>(i) + civ]->list[l].text.c_str()[m - (k + 1)] == '\0' &&
+                                if (state->plotinfo[static_cast<int8_t>(i) + civ]->list[l].text.c_str()[m - (k + 1)] != line[m]) {
+                                    if (state->plotinfo[static_cast<int8_t>(i) + civ]->list[l].text.c_str()[m - (k + 1)] == '\0' &&
                                         line[m] == ']') {
-                                        state->ui[static_cast<int8_t>(i) + civ]->current_value = state->ui[static_cast<int8_t>(i) + civ]->list[l].key;
-                                        state->ui[static_cast<int8_t>(i) + civ]->current_display_value = l;
+                                        state->plotinfo[static_cast<int8_t>(i) + civ]->current_value = state->plotinfo[static_cast<int8_t>(i) + civ]->list[l].key;
+                                        state->plotinfo[static_cast<int8_t>(i) + civ]->current_display_value = l;
                                         found = true;
                                     }
 
@@ -1095,7 +1095,7 @@ namespace embark_assist {
 
                         if (l < state->civs.size() - 1) {
                             element->current_value = element->list[0].key;
-                            state->ui.push_back(element);
+                            state->plotinfo.push_back(element);
                             element = new ui_lists;
                             element->current_display_value = 0;
                             element->current_index = 0;
@@ -1108,7 +1108,7 @@ namespace embark_assist {
                 }
 
                 element->current_value = element->list[0].key;
-                state->ui.push_back(element);
+                state->plotinfo.push_back(element);
 
                 switch (i) {
                 case fields::x_dim:
@@ -1333,21 +1333,21 @@ namespace embark_assist {
             //  off to compensate for the list starting with 1 at index 0.
             //
             auto screen = Gui::getViewscreenByType<df::viewscreen_choose_start_sitest>(0);
-            state->ui[static_cast<int8_t>(fields::x_dim)]->current_display_value =
+            state->plotinfo[static_cast<int8_t>(fields::x_dim)]->current_display_value =
                 screen->location.embark_pos_max.x -
                 screen->location.embark_pos_min.x;
-            state->ui[static_cast<int8_t>(fields::x_dim)]->current_index =
-                state->ui[static_cast<int8_t>(fields::x_dim)]->current_display_value;
-            state->ui[static_cast<int8_t>(fields::x_dim)]->current_value =
-                state->ui[static_cast<int8_t>(fields::x_dim)]->current_display_value + 1;
+            state->plotinfo[static_cast<int8_t>(fields::x_dim)]->current_index =
+                state->plotinfo[static_cast<int8_t>(fields::x_dim)]->current_display_value;
+            state->plotinfo[static_cast<int8_t>(fields::x_dim)]->current_value =
+                state->plotinfo[static_cast<int8_t>(fields::x_dim)]->current_display_value + 1;
 
-            state->ui[static_cast<int8_t>(fields::y_dim)]->current_display_value =
+            state->plotinfo[static_cast<int8_t>(fields::y_dim)]->current_display_value =
                 screen->location.embark_pos_max.y -
                 screen->location.embark_pos_min.y;
-            state->ui[static_cast<int8_t>(fields::y_dim)]->current_index =
-                state->ui[static_cast<int8_t>(fields::y_dim)]->current_display_value;
-            state->ui[static_cast<int8_t>(fields::y_dim)]->current_value =
-                state->ui[static_cast<int8_t>(fields::y_dim)]->current_display_value + 1;
+            state->plotinfo[static_cast<int8_t>(fields::y_dim)]->current_index =
+                state->plotinfo[static_cast<int8_t>(fields::y_dim)]->current_display_value;
+            state->plotinfo[static_cast<int8_t>(fields::y_dim)]->current_value =
+                state->plotinfo[static_cast<int8_t>(fields::y_dim)]->current_display_value + 1;
         }
 
         //==========================================================================================================
@@ -1360,234 +1360,234 @@ namespace embark_assist {
             while (true) {
                 switch (i) {
                 case fields::x_dim:
-                    finder.x_dim = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.x_dim = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::y_dim:
-                    finder.y_dim = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.y_dim = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::savagery_calm:
                     finder.savagery[0] =
-                        static_cast<embark_assist::defs::evil_savagery_values>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::evil_savagery_values>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::savagery_medium:
                     finder.savagery[1] =
-                        static_cast<embark_assist::defs::evil_savagery_values>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::evil_savagery_values>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
                 case fields::savagery_savage:
                     finder.savagery[2] =
-                        static_cast<embark_assist::defs::evil_savagery_values>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::evil_savagery_values>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::good:
                     finder.evilness[0] =
-                        static_cast<embark_assist::defs::evil_savagery_values>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::evil_savagery_values>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::neutral:
                     finder.evilness[1] =
-                        static_cast<embark_assist::defs::evil_savagery_values>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::evil_savagery_values>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::evil:
                     finder.evilness[2] =
-                        static_cast<embark_assist::defs::evil_savagery_values>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::evil_savagery_values>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::aquifer:
                     finder.aquifer =
-                        static_cast<embark_assist::defs::aquifer_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::aquifer_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::min_river:
                     finder.min_river =
-                        static_cast<embark_assist::defs::river_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::river_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::max_river:
                     finder.max_river =
-                        static_cast<embark_assist::defs::river_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::river_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::min_waterfall:
-                    finder.min_waterfall = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.min_waterfall = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::flat:
                     finder.flat =
-                        static_cast<embark_assist::defs::yes_no_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::yes_no_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::soil_min_everywhere:
                     finder.soil_min_everywhere =
-                        static_cast<embark_assist::defs::all_present_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::all_present_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::freezing:
                     finder.freezing =
-                        static_cast<embark_assist::defs::freezing_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::freezing_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::blood_rain:
                     finder.blood_rain =
-                        static_cast<embark_assist::defs::yes_no_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::yes_no_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::syndrome_rain:
                     finder.syndrome_rain =
-                        static_cast<embark_assist::defs::syndrome_rain_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::syndrome_rain_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::reanimation:
                     finder.reanimation =
-                        static_cast<embark_assist::defs::reanimation_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::reanimation_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::clay:
                     finder.clay =
-                        static_cast<embark_assist::defs::present_absent_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::present_absent_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::sand:
                     finder.sand =
-                        static_cast<embark_assist::defs::present_absent_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::present_absent_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::flux:
                     finder.flux =
-                        static_cast<embark_assist::defs::present_absent_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::present_absent_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::coal:
                     finder.coal =
-                        static_cast<embark_assist::defs::present_absent_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::present_absent_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::soil_min:
                     finder.soil_min =
-                        static_cast<embark_assist::defs::soil_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::soil_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::soil_max:
                     finder.soil_max =
-                        static_cast<embark_assist::defs::soil_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::soil_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::spire_count_min:
-                    finder.spire_count_min = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.spire_count_min = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::spire_count_max:
-                    finder.spire_count_max = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.spire_count_max = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::magma_min:
                     finder.magma_min =
-                        static_cast<embark_assist::defs::magma_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::magma_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::magma_max:
                     finder.magma_max =
-                        static_cast<embark_assist::defs::magma_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                        static_cast<embark_assist::defs::magma_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::biome_count_min:
-                    finder.biome_count_min = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.biome_count_min = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::biome_count_max:
-                    finder.biome_count_max = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.biome_count_max = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::region_type_1:
-                    finder.region_type_1 = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.region_type_1 = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::region_type_2:
-                    finder.region_type_2 = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.region_type_2 = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::region_type_3:
-                    finder.region_type_3 = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.region_type_3 = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::biome_1:
-                    finder.biome_1 = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.biome_1 = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::biome_2:
-                    finder.biome_2 = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.biome_2 = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::biome_3:
-                    finder.biome_3 = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.biome_3 = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::min_trees:
-                    finder.min_trees = static_cast<embark_assist::defs::tree_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                    finder.min_trees = static_cast<embark_assist::defs::tree_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::max_trees:
-                    finder.max_trees = static_cast<embark_assist::defs::tree_ranges>(state->ui[static_cast<uint8_t>(i)]->current_value);
+                    finder.max_trees = static_cast<embark_assist::defs::tree_ranges>(state->plotinfo[static_cast<uint8_t>(i)]->current_value);
                     break;
 
                 case fields::metal_1:
-                    finder.metal_1 = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.metal_1 = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::metal_2:
-                    finder.metal_2 = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.metal_2 = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::metal_3:
-                    finder.metal_3 = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.metal_3 = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::economic_1:
-                    finder.economic_1 = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.economic_1 = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::economic_2:
-                    finder.economic_2 = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.economic_2 = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::economic_3:
-                    finder.economic_3 = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.economic_3 = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::mineral_1:
-                    finder.mineral_1 = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.mineral_1 = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::mineral_2:
-                    finder.mineral_2 = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.mineral_2 = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::mineral_3:
-                    finder.mineral_3 = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.mineral_3 = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::min_necro_neighbors:
-                    finder.min_necro_neighbors = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.min_necro_neighbors = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::max_necro_neighbors:
-                    finder.max_necro_neighbors = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.max_necro_neighbors = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::min_civ_neighbors:
-                    finder.min_civ_neighbors = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.min_civ_neighbors = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::max_civ_neighbors:
-                    finder.max_civ_neighbors = state->ui[static_cast<uint8_t>(i)]->current_value;
+                    finder.max_civ_neighbors = state->plotinfo[static_cast<uint8_t>(i)]->current_value;
                     break;
 
                 case fields::neighbors:
                     for (size_t k = 0; k < state->civs.size(); k++) {
-                        finder.neighbors.push_back({ state->civs[k].id, static_cast<embark_assist::defs::present_absent_ranges>(state->ui[static_cast<uint8_t>(i) + k]->current_value) });
+                        finder.neighbors.push_back({ state->civs[k].id, static_cast<embark_assist::defs::present_absent_ranges>(state->plotinfo[static_cast<uint8_t>(i) + k]->current_value) });
                     }
                     break;
                 }
@@ -1641,10 +1641,10 @@ namespace embark_assist {
                     }
                 }
                 else {
-                    if (state->ui[state->finder_list_focus]->current_index > 0) {
-                        state->ui[state->finder_list_focus]->current_index--;
+                    if (state->plotinfo[state->finder_list_focus]->current_index > 0) {
+                        state->plotinfo[state->finder_list_focus]->current_index--;
                     } else {
-                        state->ui[state->finder_list_focus]->current_index = static_cast<uint16_t>(state->ui[state->finder_list_focus]->list.size()) - 1;
+                        state->plotinfo[state->finder_list_focus]->current_index = static_cast<uint16_t>(state->plotinfo[state->finder_list_focus]->list.size()) - 1;
                     }
                 }
 
@@ -1657,17 +1657,17 @@ namespace embark_assist {
                     }
                 }
                 else {
-                    if (state->ui[state->finder_list_focus]->current_index < state->ui[state->finder_list_focus]->list.size() - 1) {
-                        state->ui[state->finder_list_focus]->current_index++;
+                    if (state->plotinfo[state->finder_list_focus]->current_index < state->plotinfo[state->finder_list_focus]->list.size() - 1) {
+                        state->plotinfo[state->finder_list_focus]->current_index++;
                     } else {
-                        state->ui[state->finder_list_focus]->current_index = 0;
+                        state->plotinfo[state->finder_list_focus]->current_index = 0;
                     }
                 }
 
             } else if (input->count(df::interface_key::SELECT)) {
                 if (!state->finder_list_active) {
-                    state->ui[state->finder_list_focus]->current_display_value = state->ui[state->finder_list_focus]->current_index;
-                    state->ui[state->finder_list_focus]->current_value = state->ui[state->finder_list_focus]->list[state->ui[state->finder_list_focus]->current_index].key;
+                    state->plotinfo[state->finder_list_focus]->current_display_value = state->plotinfo[state->finder_list_focus]->current_index;
+                    state->plotinfo[state->finder_list_focus]->current_value = state->plotinfo[state->finder_list_focus]->list[state->plotinfo[state->finder_list_focus]->current_index].key;
                     state->finder_list_active = true;
                 }
 
@@ -1743,7 +1743,7 @@ namespace embark_assist {
                     embark_assist::screen::paintString(active_pen,
                         21,
                         top_row + i - offset,
-                        state->ui[i]->list[state->ui[i]->current_display_value].text);
+                        state->plotinfo[i]->list[state->plotinfo[i]->current_display_value].text);
                 }
                 else {
                     embark_assist::screen::paintString(normal_pen, 1, top_row + i - offset, state->finder_list[i].text);
@@ -1751,38 +1751,38 @@ namespace embark_assist {
                     embark_assist::screen::paintString(white_pen,
                         21,
                         top_row + i - offset,
-                        state->ui[i]->list[state->ui[i]->current_display_value].text);
+                        state->plotinfo[i]->list[state->plotinfo[i]->current_display_value].text);
                 }
             }
 
             //  Implement scrolling lists if they don't fit on the screen.
             offset = 0;
 
-            if (int32_t(state->ui[state->finder_list_focus]->list.size()) > screen_size.y - top_row - 1) {
+            if (int32_t(state->plotinfo[state->finder_list_focus]->list.size()) > screen_size.y - top_row - 1) {
                 offset = (screen_size.y - top_row - 1) / 2;
-                if (state->ui[state->finder_list_focus]->current_index < offset) {
+                if (state->plotinfo[state->finder_list_focus]->current_index < offset) {
                     offset = 0;
                 }
                 else {
-                    offset = state->ui[state->finder_list_focus]->current_index - offset;
+                    offset = state->plotinfo[state->finder_list_focus]->current_index - offset;
                 }
 
-                if (int32_t(state->ui[state->finder_list_focus]->list.size() - offset) < screen_size.y - top_row - 1) {
-                    offset = static_cast<uint16_t>(state->ui[state->finder_list_focus]->list.size()) - (screen_size.y - top_row - 1);
+                if (int32_t(state->plotinfo[state->finder_list_focus]->list.size() - offset) < screen_size.y - top_row - 1) {
+                    offset = static_cast<uint16_t>(state->plotinfo[state->finder_list_focus]->list.size()) - (screen_size.y - top_row - 1);
                 }
             }
 
-            for (uint16_t i = offset; i < state->ui[state->finder_list_focus]->list.size(); i++) {
-                if (i == state->ui[state->finder_list_focus]->current_index) {
+            for (uint16_t i = offset; i < state->plotinfo[state->finder_list_focus]->list.size(); i++) {
+                if (i == state->plotinfo[state->finder_list_focus]->current_index) {
                     if (!state->finder_list_active) {  // Negated expression to get the display lines in the same order as above.
-                        embark_assist::screen::paintString(active_pen, list_column, top_row + i - offset, state->ui[state->finder_list_focus]->list[i].text);
+                        embark_assist::screen::paintString(active_pen, list_column, top_row + i - offset, state->plotinfo[state->finder_list_focus]->list[i].text);
                     }
                     else {
-                        embark_assist::screen::paintString(passive_pen, list_column, top_row + i - offset, state->ui[state->finder_list_focus]->list[i].text);
+                        embark_assist::screen::paintString(passive_pen, list_column, top_row + i - offset, state->plotinfo[state->finder_list_focus]->list[i].text);
                     }
                 }
                 else {
-                    embark_assist::screen::paintString(normal_pen, list_column, top_row + i - offset, state->ui[state->finder_list_focus]->list[i].text);
+                    embark_assist::screen::paintString(normal_pen, list_column, top_row + i - offset, state->plotinfo[state->finder_list_focus]->list[i].text);
                 }
             }
 
@@ -1823,8 +1823,8 @@ void embark_assist::finder_ui::activate() {
 
 void embark_assist::finder_ui::shutdown() {
     if (embark_assist::finder_ui::state) {
-        for (uint16_t i = 0; i < embark_assist::finder_ui::state->ui.size(); i++) {
-            delete embark_assist::finder_ui::state->ui[i];
+        for (uint16_t i = 0; i < embark_assist::finder_ui::state->plotinfo.size(); i++) {
+            delete embark_assist::finder_ui::state->plotinfo[i];
         }
 
         delete embark_assist::finder_ui::state;

plugins/eventful.cpp

@@ -39,7 +39,7 @@ using namespace df::enums;
 DFHACK_PLUGIN("eventful");
 REQUIRE_GLOBAL(gps);
 REQUIRE_GLOBAL(world);
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 
 typedef df::reaction_product_itemst item_product;
 

plugins/getplants.cpp

@@ -14,7 +14,7 @@
 #include "df/plant_growth.h"
 #include "df/plant_raw.h"
 #include "df/tile_dig_designation.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/world.h"
 #include "df/world_data.h"
 #include "df/world_object_data.h"
@@ -32,7 +32,7 @@ using namespace DFHack;
 using namespace df::enums;
 
 DFHACK_PLUGIN("getplants");
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 REQUIRE_GLOBAL(world);
 REQUIRE_GLOBAL(cur_year);
 REQUIRE_GLOBAL(cur_year_tick);
@@ -242,7 +242,7 @@ bool ripe(int32_t x, int32_t y, int32_t start, int32_t end) {
 //  Looks in the picked growths vector to see if a matching growth has been marked as picked.
 bool picked(const df::plant *plant, int32_t growth_subtype) {
     df::world_data *world_data = world->world_data;
-    df::world_site *site = df::world_site::find(ui->site_id);
+    df::world_site *site = df::world_site::find(plotinfo->site_id);
     int32_t pos_x = site->global_min_x + plant->pos.x / 48;
     int32_t pos_y = site->global_min_y + plant->pos.y / 48;
     size_t id = pos_x + pos_y * 16 * world_data->world_width;

plugins/jobutils.cpp

@@ -11,8 +11,8 @@
 
 #include "DataDefs.h"
 #include "df/world.h"
-#include "df/ui.h"
-#include "df/ui_build_selector.h"
+#include "df/plotinfost.h"
+#include "df/buildreq.h"
 #include "df/ui_build_item_req.h"
 #include "df/build_req_choice_genst.h"
 #include "df/build_req_choice_specst.h"
@@ -33,7 +33,7 @@ using namespace df::enums;
 
 DFHACK_PLUGIN("jobutils");
 REQUIRE_GLOBAL(world);
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 REQUIRE_GLOBAL(ui_build_selector);
 REQUIRE_GLOBAL(ui_workshop_job_cursor);
 REQUIRE_GLOBAL(job_next_id);
@@ -48,7 +48,7 @@ static command_result job_cmd(color_ostream &out, vector <string> & parameters);
 
 DFhackCExport command_result plugin_init (color_ostream &out, std::vector <PluginCommand> &commands)
 {
-    if (!world || !ui)
+    if (!world || !plotinfo)
         return CR_FAILURE;
 
     commands.push_back(
@@ -232,9 +232,9 @@ static command_result job_material(color_ostream &out, vector <string> & paramet
     else
         return CR_WRONG_USAGE;
 
-    if (ui->main.mode == ui_sidebar_mode::QueryBuilding)
+    if (plotinfo->main.mode == ui_sidebar_mode::QueryBuilding)
         return job_material_in_job(out, new_mat);
-    if (ui->main.mode == ui_sidebar_mode::Build)
+    if (plotinfo->main.mode == ui_sidebar_mode::Build)
         return job_material_in_build(out, new_mat);
 
     return CR_WRONG_USAGE;

plugins/lua/buildingplan.lua

@@ -87,7 +87,7 @@ end
 -- returns a vector of constructed buildings (usually of size 1, but potentially
 -- more for constructions)
 function construct_buildings_from_ui_state()
-    local uibs = df.global.ui_build_selector
+    local uibs = df.global.buildreq
     local world = df.global.world
     local direction = world.selected_direction
     local _, width, height = dfhack.buildings.getCorrectSize(

plugins/lua/confirm.lua

@@ -1,6 +1,6 @@
 local _ENV = mkmodule('plugins.confirm')
 
-local ui = df.global.ui
+local ui = df.global.plotinfo
 
 local confs = {}
 -- Wraps df.interface_key[foo] functionality but fails with invalid keys

plugins/lua/eventful.lua

@@ -54,10 +54,10 @@ local function onPostSidebar(workshop)
     if shop_id then
         if _registeredStuff.shopNonNative and _registeredStuff.shopNonNative[shop_id]  then
             if _registeredStuff.shopNonNative[shop_id].all then
-                --[[for _,button in ipairs(df.global.ui_sidebar_menus.workshop_job.choices_all) do
+                --[[for _,button in ipairs(df.global.game.workshop_job.choices_all) do
                     button.is_hidden=true
                 end]]
-                df.global.ui_sidebar_menus.workshop_job.choices_visible:resize(0)
+                df.global.game.workshop_job.choices_visible:resize(0)
             else
                 --todo by name
             end
@@ -72,7 +72,7 @@ local function onPostSidebar(workshop)
                 new_button.job_type=df.job_type.CustomReaction --could be used for other stuff too i guess...
                 new_button.reaction_name=reaction_name
                 new_button.is_custom=true
-                local wjob=df.global.ui_sidebar_menus.workshop_job
+                local wjob=df.global.game.workshop_job
                 wjob.choices_all:insert("#",new_button)
                 wjob.choices_visible:insert("#",new_button)
             end

plugins/lua/hotkeys.lua

@@ -19,7 +19,6 @@ HotspotMenuWidget.ATTRS{
 }
 
 function HotspotMenuWidget:init()
-    self:addviews{widgets.Label{text={'!DF!', NEWLINE, '!Ha!', NEWLINE, '!ck!'}}}
     self.mouseover = false
 end
 
@@ -41,6 +40,34 @@ function HotspotMenuWidget:overlay_trigger()
         mouseover=self.mouseover}:show()
 end
 
+local dscreen = dfhack.screen
+
+function HotspotMenuWidget:onRenderBody(dc)
+    local tpos = dfhack.textures.getDfhackLogoTexposStart()
+    local x, y = dc.x, dc.y
+
+    if tpos == -1 then
+        dscreen.paintString(COLOR_WHITE, x, y+0, '!DF!')
+        dscreen.paintString(COLOR_WHITE, x, y+1, '!Ha!')
+        dscreen.paintString(COLOR_WHITE, x, y+2, '!ck!')
+    else
+        dscreen.paintTile(COLOR_WHITE, x+0, y+0, '!', tpos+0)
+        dscreen.paintTile(COLOR_WHITE, x+1, y+0, 'D', tpos+1)
+        dscreen.paintTile(COLOR_WHITE, x+2, y+0, 'F', tpos+2)
+        dscreen.paintTile(COLOR_WHITE, x+3, y+0, '!', tpos+3)
+
+        dscreen.paintTile(COLOR_WHITE, x+0, y+1, '!', tpos+4)
+        dscreen.paintTile(COLOR_WHITE, x+1, y+1, 'H', tpos+5)
+        dscreen.paintTile(COLOR_WHITE, x+2, y+1, 'a', tpos+6)
+        dscreen.paintTile(COLOR_WHITE, x+3, y+1, '!', tpos+7)
+
+        dscreen.paintTile(COLOR_WHITE, x+0, y+2, '!', tpos+8)
+        dscreen.paintTile(COLOR_WHITE, x+1, y+2, 'c', tpos+9)
+        dscreen.paintTile(COLOR_WHITE, x+2, y+2, 'k', tpos+10)
+        dscreen.paintTile(COLOR_WHITE, x+3, y+2, '!', tpos+11)
+    end
+end
+
 -- register the menu hotspot with the overlay
 OVERLAY_WIDGETS = {menu=HotspotMenuWidget}
 

plugins/lua/siege-engine.lua

@@ -146,7 +146,7 @@ function getBaseUnitWeight(unit)
             return -30
         elseif flags1.diplomat or flags1.merchant or flags1.forest then
             return -5
-        elseif flags1.tame and unit.civ_id == df.global.ui.civ_id then
+        elseif flags1.tame and unit.civ_id == df.global.plotinfo.civ_id then
             return -1
         end
     end

plugins/lua/stockflow.lua

@@ -234,7 +234,7 @@ function material_reactions(reactions, itemtypes, mat_info)
 end
 
 function clothing_reactions(reactions, mat_info, filter)
-    local resources = df.historical_entity.find(df.global.ui.civ_id).resources
+    local resources = df.historical_entity.find(df.global.plotinfo.civ_id).resources
     local itemdefs = df.global.world.raws.itemdefs
     local job_types = df.job_type
     resource_reactions(reactions, job_types.MakeArmor,  mat_info, resources.armor_type,  itemdefs.armor,  {permissible = filter})
@@ -408,7 +408,7 @@ function collect_reactions()
     -- Reactions defined in the raws.
     -- Not all reactions are allowed to the civilization.
     -- That includes "Make sharp rock" by default.
-    local entity = df.historical_entity.find(df.global.ui.civ_id)
+    local entity = df.historical_entity.find(df.global.plotinfo.civ_id)
     if not entity then
         -- No global civilization; arena mode?
         -- Anyway, skip remaining reactions, since many depend on the civ.

plugins/manipulator.cpp

@@ -19,7 +19,7 @@
 
 #include "df/activity_event.h"
 #include "df/world.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/graphic.h"
 #include "df/enabler.h"
 #include "df/viewscreen_unitlistst.h"
@@ -49,7 +49,7 @@ using namespace df::enums;
 DFHACK_PLUGIN("manipulator");
 DFHACK_PLUGIN_IS_ENABLED(is_enabled);
 REQUIRE_GLOBAL(world);
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 REQUIRE_GLOBAL(gps);
 REQUIRE_GLOBAL(enabler);
 
@@ -1972,9 +1972,9 @@ void viewscreen_unitlaborsst::render()
         Screen::paintTile(Screen::Pen(columns[col_offset].label[0], fg, bg), col_offsets[DISP_COLUMN_LABORS] + col, 1);
         Screen::paintTile(Screen::Pen(columns[col_offset].label[1], fg, bg), col_offsets[DISP_COLUMN_LABORS] + col, 2);
         df::profession profession = columns[col_offset].profession;
-        if ((profession != profession::NONE) && (ui->race_id != -1))
+        if ((profession != profession::NONE) && (plotinfo->race_id != -1))
         {
-            auto graphics = world->raws.creatures.all[ui->race_id]->graphics;
+            auto graphics = world->raws.creatures.all[plotinfo->race_id]->graphics;
             Screen::paintTile(
                 Screen::Pen(' ', fg, 0,
                     graphics.profession_add_color[creature_graphics_role::DEFAULT][profession],

plugins/misery.cpp

@@ -10,7 +10,7 @@
 #include "modules/Units.h"
 
 #include "df/emotion_type.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/unit.h"
 #include "df/unit_personality.h"
 #include "df/unit_soul.h"
@@ -24,7 +24,7 @@ DFHACK_PLUGIN("misery");
 DFHACK_PLUGIN_IS_ENABLED(is_enabled);
 
 REQUIRE_GLOBAL(world);
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 REQUIRE_GLOBAL(cur_year);
 REQUIRE_GLOBAL(cur_year_tick);
 

plugins/mousequery.cpp

@@ -6,8 +6,8 @@
 #include "df/viewscreen_dwarfmodest.h"
 #include "df/world.h"
 #include "df/items_other_id.h"
-#include "df/ui_build_selector.h"
-#include "df/ui_sidebar_menus.h"
+#include "df/buildreq.h"
+#include "df/gamest.h"
 
 #include "modules/Gui.h"
 #include "modules/World.h"
@@ -26,7 +26,7 @@ DFHACK_PLUGIN("mousequery");
 REQUIRE_GLOBAL(enabler);
 REQUIRE_GLOBAL(gps);
 REQUIRE_GLOBAL(world);
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 REQUIRE_GLOBAL(ui_build_selector);
 
 using namespace df::enums::ui_sidebar_mode;
@@ -196,7 +196,7 @@ struct mousequery_hook : public df::viewscreen_dwarfmodest
 
     bool isInDesignationMenu()
     {
-        switch (ui->main.mode)
+        switch (plotinfo->main.mode)
         {
         case DesignateMine:
         case DesignateRemoveRamps:
@@ -230,7 +230,7 @@ struct mousequery_hook : public df::viewscreen_dwarfmodest
             return true;
 
         case Burrows:
-            return ui->burrows.in_define_mode;
+            return plotinfo->burrows.in_define_mode;
 
         default:
             return false;
@@ -242,7 +242,7 @@ struct mousequery_hook : public df::viewscreen_dwarfmodest
         if (isInDesignationMenu())
             return box_designation_enabled;
 
-        switch (ui->main.mode)
+        switch (plotinfo->main.mode)
         {
         case DesignateItemsClaim:
         case DesignateItemsForbid:
@@ -281,8 +281,8 @@ struct mousequery_hook : public df::viewscreen_dwarfmodest
     {
         bool selectableMode =
             isInDesignationMenu() ||
-            ui->main.mode == Stockpiles ||
-            ui->main.mode == Zones;
+            plotinfo->main.mode == Stockpiles ||
+            plotinfo->main.mode == Zones;
 
         if (selectableMode)
         {
@@ -314,7 +314,7 @@ struct mousequery_hook : public df::viewscreen_dwarfmodest
         }
         else
         {
-            switch (ui->main.mode)
+            switch (plotinfo->main.mode)
             {
             case QueryBuilding:
                 if (cursor_still_here)
@@ -369,8 +369,8 @@ struct mousequery_hook : public df::viewscreen_dwarfmodest
         if (mx < 1 || mx > dims.map_x2 || my < 1 || my > dims.map_y2)
             return false;
 
-        if (ui->main.mode == df::ui_sidebar_mode::Zones ||
-            ui->main.mode == df::ui_sidebar_mode::Stockpiles)
+        if (plotinfo->main.mode == df::ui_sidebar_mode::Zones ||
+            plotinfo->main.mode == df::ui_sidebar_mode::Stockpiles)
         {
             int32_t x, y, z;
             if (Gui::getDesignationCoords(x, y, z))
@@ -417,8 +417,8 @@ struct mousequery_hook : public df::viewscreen_dwarfmodest
         enabler->mouse_rbut = 0;
 
         using namespace df::enums::ui_sidebar_mode;
-        if ((ui->main.mode == QueryBuilding || ui->main.mode == BuildingItems ||
-            ui->main.mode == ViewUnits || ui->main.mode == LookAround) ||
+        if ((plotinfo->main.mode == QueryBuilding || plotinfo->main.mode == BuildingItems ||
+            plotinfo->main.mode == ViewUnits || plotinfo->main.mode == LookAround) ||
             (isInTrackableMode() && tracking_enabled))
         {
             sendKey(df::interface_key::LEAVESCREEN);
@@ -707,8 +707,8 @@ struct mousequery_hook : public df::viewscreen_dwarfmodest
             if (Gui::getDesignationCoords(x, y, z))
             {
                 color = COLOR_WHITE;
-                if (ui->main.mode == df::ui_sidebar_mode::Zones ||
-                    ui->main.mode == df::ui_sidebar_mode::Stockpiles)
+                if (plotinfo->main.mode == df::ui_sidebar_mode::Zones ||
+                    plotinfo->main.mode == df::ui_sidebar_mode::Stockpiles)
                 {
                     auto dX = abs(x - mpos.x);
                     if (dX > 30)

plugins/nestboxes.cpp

@@ -5,7 +5,7 @@
 
 #include "DataDefs.h"
 #include "df/world.h"
-#include "df/ui.h"
+#include "df/plotinfost.h"
 #include "df/building_nest_boxst.h"
 #include "df/building_type.h"
 #include "df/buildings_other_id.h"
@@ -26,7 +26,7 @@ using namespace DFHack;
 using namespace df::enums;
 
 using df::global::world;
-using df::global::ui;
+using df::global::plotinfo;
 
 static command_result nestboxes(color_ostream &out, vector <string> & parameters);
 
@@ -67,7 +67,7 @@ static void eggscan(color_ostream &out)
 
 DFhackCExport command_result plugin_init (color_ostream &out, std::vector <PluginCommand> &commands)
 {
-    if (world && ui) {
+    if (world && plotinfo) {
         commands.push_back(
             PluginCommand(
                 "nestboxes",

plugins/power-meter.cpp

@@ -29,8 +29,8 @@
 #include "df/machine_info.h"
 #include "df/report.h"
 #include "df/tile_designation.h"
-#include "df/ui.h"
-#include "df/ui_build_selector.h"
+#include "df/plotinfost.h"
+#include "df/buildreq.h"
 #include "df/viewscreen_dwarfmodest.h"
 #include "df/world.h"
 
@@ -43,7 +43,7 @@ using namespace df::enums;
 DFHACK_PLUGIN("power-meter");
 REQUIRE_GLOBAL(gps);
 REQUIRE_GLOBAL(world);
-REQUIRE_GLOBAL(ui);
+REQUIRE_GLOBAL(plotinfo);
 REQUIRE_GLOBAL(ui_build_selector);
 
 static const uint32_t METER_BIT = 0x80000000U;

plugins/remotefortressreader/adventure_control.cpp

@@ -7,7 +7,7 @@
 #include "df/adventure_movement_hold_itemst.h"
 #include "df/adventure_movement_hold_tilest.h"
 #include "df/adventure_movement_optionst.h"
-#include "df/ui_advmode.h"
+#include "df/adventurest.h"
 #include "df/viewscreen.h"
 
 #include "modules/Gui.h"
@@ -39,279 +39,279 @@ void SetCoord(df::coord in, RemoteFortressReader::Coord *out)
 
 command_result MoveCommand(DFHack::color_ostream &stream, const MoveCommandParams *in)
 {
-    //auto viewScreen = getCurViewscreen();
-    //if (!in->has_direction())
-    //    return CR_WRONG_USAGE;
-    //if (!df::global::ui_advmode->menu == ui_advmode_menu::Default)
-    //    return CR_OK;
-    //auto dir = in->direction();
-    //switch (dir.x())
-    //{
-    //case -1:
-    //    switch (dir.y())
-    //    {
-    //    case -1:
-    //        switch (dir.z())
-    //        {
-    //        case -1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_NW_DOWN);
-    //            break;
-    //        case 0:
-    //            viewScreen->feed_key(interface_key::A_MOVE_NW);
-    //            break;
-    //        case 1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_NW_UP);
-    //            break;
-    //        }
-    //        break;
-    //    case 0:
-    //        switch (dir.z())
-    //        {
-    //        case -1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_W_DOWN);
-    //            break;
-    //        case 0:
-    //            viewScreen->feed_key(interface_key::A_MOVE_W);
-    //            break;
-    //        case 1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_W_UP);
-    //            break;
-    //        }
-    //        break;
-    //    case 1:
-    //        switch (dir.z())
-    //        {
-    //        case -1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_SW_DOWN);
-    //            break;
-    //        case 0:
-    //            viewScreen->feed_key(interface_key::A_MOVE_SW);
-    //            break;
-    //        case 1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_SW_UP);
-    //            break;
-    //        }
-    //        break;
-    //    }
-    //    break;
-    //case 0:
-    //    switch (dir.y())
-    //    {
-    //    case -1:
-    //        switch (dir.z())
-    //        {
-    //        case -1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_N_DOWN);
-    //            break;
-    //        case 0:
-    //            viewScreen->feed_key(interface_key::A_MOVE_N);
-    //            break;
-    //        case 1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_N_UP);
-    //            break;
-    //        }
-    //        break;
-    //    case 0:
-    //        switch (dir.z())
-    //        {
-    //        case -1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_DOWN);
-    //            break;
-    //        case 1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_UP);
-    //            break;
-    //        }
-    //        break;
-    //    case 1:
-    //        switch (dir.z())
-    //        {
-    //        case -1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_S_DOWN);
-    //            break;
-    //        case 0:
-    //            viewScreen->feed_key(interface_key::A_MOVE_S);
-    //            break;
-    //        case 1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_S_UP);
-    //            break;
-    //        }
-    //        break;
-    //    }
-    //    break;
-    //case 1:
-    //    switch (dir.y())
-    //    {
-    //    case -1:
-    //        switch (dir.z())
-    //        {
-    //        case -1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_NE_DOWN);
-    //            break;
-    //        case 0:
-    //            viewScreen->feed_key(interface_key::A_MOVE_NE);
-    //            break;
-    //        case 1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_NE_UP);
-    //            break;
-    //        }
-    //        break;
-    //    case 0:
-    //        switch (dir.z())
-    //        {
-    //        case -1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_E_DOWN);
-    //            break;
-    //        case 0:
-    //            viewScreen->feed_key(interface_key::A_MOVE_E);
-    //            break;
-    //        case 1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_E_UP);
-    //            break;
-    //        }
-    //        break;
-    //    case 1:
-    //        switch (dir.z())
-    //        {
-    //        case -1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_SE_DOWN);
-    //            break;
-    //        case 0:
-    //            viewScreen->feed_key(interface_key::A_MOVE_SE);
-    //            break;
-    //        case 1:
-    //            viewScreen->feed_key(interface_key::A_MOVE_SE_UP);
-    //            break;
-    //        }
-    //        break;
-    //    }
-    //    break;
-    //}
+    auto viewScreen = getCurViewscreen();
+    if (!in->has_direction())
+        return CR_WRONG_USAGE;
+    if (!df::global::adventure->menu == ui_advmode_menu::Default)
+        return CR_OK;
+    auto dir = in->direction();
+    switch (dir.x())
+    {
+    case -1:
+        switch (dir.y())
+        {
+        case -1:
+            switch (dir.z())
+            {
+            case -1:
+                viewScreen->feed_key(interface_key::A_MOVE_NW_DOWN);
+                break;
+            case 0:
+                viewScreen->feed_key(interface_key::A_MOVE_NW);
+                break;
+            case 1:
+                viewScreen->feed_key(interface_key::A_MOVE_NW_UP);
+                break;
+            }
+            break;
+        case 0:
+            switch (dir.z())
+            {
+            case -1:
+                viewScreen->feed_key(interface_key::A_MOVE_W_DOWN);
+                break;
+            case 0:
+                viewScreen->feed_key(interface_key::A_MOVE_W);
+                break;
+            case 1:
+                viewScreen->feed_key(interface_key::A_MOVE_W_UP);
+                break;
+            }
+            break;
+        case 1:
+            switch (dir.z())
+            {
+            case -1:
+                viewScreen->feed_key(interface_key::A_MOVE_SW_DOWN);
+                break;
+            case 0:
+                viewScreen->feed_key(interface_key::A_MOVE_SW);
+                break;
+            case 1:
+                viewScreen->feed_key(interface_key::A_MOVE_SW_UP);
+                break;
+            }
+            break;
+        }
+        break;
+    case 0:
+        switch (dir.y())
+        {
+        case -1:
+            switch (dir.z())
+            {
+            case -1:
+                viewScreen->feed_key(interface_key::A_MOVE_N_DOWN);
+                break;
+            case 0:
+                viewScreen->feed_key(interface_key::A_MOVE_N);
+                break;
+            case 1:
+                viewScreen->feed_key(interface_key::A_MOVE_N_UP);
+                break;
+            }
+            break;
+        case 0:
+            switch (dir.z())
+            {
+            case -1:
+                viewScreen->feed_key(interface_key::A_MOVE_DOWN);
+                break;
+            case 1:
+                viewScreen->feed_key(interface_key::A_MOVE_UP);
+                break;
+            }
+            break;
+        case 1:
+            switch (dir.z())
+            {
+            case -1:
+                viewScreen->feed_key(interface_key::A_MOVE_S_DOWN);
+                break;
+            case 0:
+                viewScreen->feed_key(interface_key::A_MOVE_S);
+                break;
+            case 1:
+                viewScreen->feed_key(interface_key::A_MOVE_S_UP);
+                break;
+            }
+            break;
+        }
+        break;
+    case 1:
+        switch (dir.y())
+        {
+        case -1:
+            switch (dir.z())
+            {
+            case -1:
+                viewScreen->feed_key(interface_key::A_MOVE_NE_DOWN);
+                break;
+            case 0:
+                viewScreen->feed_key(interface_key::A_MOVE_NE);
+                break;
+            case 1:
+                viewScreen->feed_key(interface_key::A_MOVE_NE_UP);
+                break;
+            }
+            break;
+        case 0:
+            switch (dir.z())
+            {
+            case -1:
+                viewScreen->feed_key(interface_key::A_MOVE_E_DOWN);
+                break;
+            case 0:
+                viewScreen->feed_key(interface_key::A_MOVE_E);
+                break;
+            case 1:
+                viewScreen->feed_key(interface_key::A_MOVE_E_UP);
+                break;
+            }
+            break;
+        case 1:
+            switch (dir.z())
+            {
+            case -1:
+                viewScreen->feed_key(interface_key::A_MOVE_SE_DOWN);
+                break;
+            case 0:
+                viewScreen->feed_key(interface_key::A_MOVE_SE);
+                break;
+            case 1:
+                viewScreen->feed_key(interface_key::A_MOVE_SE_UP);
+                break;
+            }
+            break;
+        }
+        break;
+    }
     return CR_OK;
 }
 
 command_result JumpCommand(DFHack::color_ostream &stream, const MoveCommandParams *in)
 {
-    //if (!in->has_direction())
-    //    return CR_WRONG_USAGE;
-    //if (!df::global::ui_advmode->menu == ui_advmode_menu::Default)
-    //    return CR_OK;
-    //auto dir = in->direction();
-    //keyQueue.push(interface_key::A_JUMP);
-    //int x = dir.x();
-    //int y = dir.y();
-    //if (x > 0)
-    //{
-    //    for (int i = 0; i < x; i++)
-    //    {
-    //        keyQueue.push(interface_key::CURSOR_RIGHT);
-    //    }
-    //}
-    //if (x < 0)
-    //{
-    //    for (int i = 0; i > x; i--)
-    //    {
-    //        keyQueue.push(interface_key::CURSOR_LEFT);
-    //    }
-    //}
-    //if (y > 0)
-    //{
-    //    for (int i = 0; i < y; i++)
-    //    {
-    //        keyQueue.push(interface_key::CURSOR_DOWN);
-    //    }
-    //}
-    //if (y < 0)
-    //{
-    //    for (int i = 0; i > y; i--)
-    //    {
-    //        keyQueue.push(interface_key::CURSOR_UP);
-    //    }
-    //}
-    //keyQueue.push(interface_key::SELECT);
+    if (!in->has_direction())
+        return CR_WRONG_USAGE;
+    if (!df::global::adventure->menu == ui_advmode_menu::Default)
+        return CR_OK;
+    auto dir = in->direction();
+    keyQueue.push(interface_key::A_JUMP);
+    int x = dir.x();
+    int y = dir.y();
+    if (x > 0)
+    {
+        for (int i = 0; i < x; i++)
+        {
+            keyQueue.push(interface_key::CURSOR_RIGHT);
+        }
+    }
+    if (x < 0)
+    {
+        for (int i = 0; i > x; i--)
+        {
+            keyQueue.push(interface_key::CURSOR_LEFT);
+        }
+    }
+    if (y > 0)
+    {
+        for (int i = 0; i < y; i++)
+        {
+            keyQueue.push(interface_key::CURSOR_DOWN);
+        }
+    }
+    if (y < 0)
+    {
+        for (int i = 0; i > y; i--)
+        {
+            keyQueue.push(interface_key::CURSOR_UP);
+        }
+    }
+    keyQueue.push(interface_key::SELECT);
     return CR_OK;
 }
 
 command_result MenuQuery(DFHack::color_ostream &stream, const EmptyMessage *in, MenuContents *out)
 {
-    //auto advUi = df::global::ui_advmode;
+    auto advUi = df::global::adventure;
 
-    //if (advUi == NULL)
-    //    return CR_FAILURE;
+    if (advUi == NULL)
+        return CR_FAILURE;
 
-    //out->set_current_menu((AdvmodeMenu)advUi->menu);
+    out->set_current_menu((AdvmodeMenu)advUi->menu);
 
-    ////Fixme: Needs a proper way to control it, but for now, this is the only way to allow Armok Vision to keep going without the user needing to switch to DF.
-    //if (advUi->menu == ui_advmode_menu::FallAction)
-    //{
-    //    getCurViewscreen()->feed_key(interface_key::OPTION1);
-    //}
+    //Fixme: Needs a proper way to control it, but for now, this is the only way to allow Armok Vision to keep going without the user needing to switch to DF.
+    if (advUi->menu == ui_advmode_menu::FallAction)
+    {
+        getCurViewscreen()->feed_key(interface_key::OPTION1);
+    }
 
-    //switch (advUi->menu)
-    //{
-    //case ui_advmode_menu::MoveCarefully:
-    //    for (size_t i = 0; i < advUi->movements.size(); i++)
-    //    {
-    //        auto movement = advUi->movements[i];
-    //        auto send_movement = out->add_movements();
-    //        SetCoord(movement->source, send_movement->mutable_source());
-    //        SetCoord(movement->dest, send_movement->mutable_dest());
+    switch (advUi->menu)
+    {
+    case ui_advmode_menu::MoveCarefully:
+        for (size_t i = 0; i < advUi->movements.size(); i++)
+        {
+            auto movement = advUi->movements[i];
+            auto send_movement = out->add_movements();
+            SetCoord(movement->source, send_movement->mutable_source());
+            SetCoord(movement->dest, send_movement->mutable_dest());
 
-    //        STRICT_VIRTUAL_CAST_VAR(climbMovement, df::adventure_movement_climbst, movement);
-    //        if (climbMovement)
-    //        {
-    //            SetCoord(climbMovement->grab, send_movement->mutable_grab());
-    //            send_movement->set_movement_type(CarefulMovementType::CLIMB);
-    //        }
-    //        STRICT_VIRTUAL_CAST_VAR(holdTileMovement, df::adventure_movement_hold_tilest, movement);
-    //        if (holdTileMovement)
-    //        {
-    //            SetCoord(holdTileMovement->grab, send_movement->mutable_grab());
-    //            send_movement->set_movement_type(CarefulMovementType::HOLD_TILE);
-    //        }
-    //    }
-    //default:
-    //    break;
-    //}
+            STRICT_VIRTUAL_CAST_VAR(climbMovement, df::adventure_movement_climbst, movement);
+            if (climbMovement)
+            {
+                SetCoord(climbMovement->grab, send_movement->mutable_grab());
+                send_movement->set_movement_type(CarefulMovementType::CLIMB);
+            }
+            STRICT_VIRTUAL_CAST_VAR(holdTileMovement, df::adventure_movement_hold_tilest, movement);
+            if (holdTileMovement)
+            {
+                SetCoord(holdTileMovement->grab, send_movement->mutable_grab());
+                send_movement->set_movement_type(CarefulMovementType::HOLD_TILE);
+            }
+        }
+    default:
+        break;
+    }
 
     return CR_OK;
 }
 
 command_result MovementSelectCommand(DFHack::color_ostream &stream, const dfproto::IntMessage *in)
 {
-    //if (!(df::global::ui_advmode->menu == ui_advmode_menu::MoveCarefully))
-    //    return CR_OK;
-    //int choice = in->value();
-    //int page = choice / 5;
-    //int select = choice % 5;
-    //for (int i = 0; i < page; i++)
-    //{
-    //    keyQueue.push(interface_key::SECONDSCROLL_PAGEDOWN);
-    //}
-    //keyQueue.push((interface_key::interface_key)(interface_key::OPTION1 + select));
+    if (!(df::global::adventure->menu == ui_advmode_menu::MoveCarefully))
+        return CR_OK;
+    int choice = in->value();
+    int page = choice / 5;
+    int select = choice % 5;
+    for (int i = 0; i < page; i++)
+    {
+        keyQueue.push(interface_key::SECONDSCROLL_PAGEDOWN);
+    }
+    keyQueue.push((interface_key::interface_key)(interface_key::OPTION1 + select));
     return CR_OK;
 }
 
 command_result MiscMoveCommand(DFHack::color_ostream &stream, const MiscMoveParams *in)
 {
-    //if (!df::global::ui_advmode->menu == ui_advmode_menu::Default)
-    //    return CR_OK;
+    if (!df::global::adventure->menu == ui_advmode_menu::Default)
+        return CR_OK;
 
-    //auto type = in->type();
+    auto type = in->type();
 
-    //switch (type)
-    //{
-    //case AdventureControl::SET_CLIMB:
-    //    getCurViewscreen()->feed_key(interface_key::A_HOLD);
-    //    break;
-    //case AdventureControl::SET_STAND:
-    //    getCurViewscreen()->feed_key(interface_key::A_STANCE);
-    //    break;
-    //case AdventureControl::SET_CANCEL:
-    //    getCurViewscreen()->feed_key(interface_key::LEAVESCREEN);
-    //    break;
-    //default:
-    //    break;
-    //}
+    switch (type)
+    {
+    case AdventureControl::SET_CLIMB:
+        getCurViewscreen()->feed_key(interface_key::A_HOLD);
+        break;
+    case AdventureControl::SET_STAND:
+        getCurViewscreen()->feed_key(interface_key::A_STANCE);
+        break;
+    case AdventureControl::SET_CANCEL:
+        getCurViewscreen()->feed_key(interface_key::LEAVESCREEN);
+        break;
+    default:
+        break;
+    }
 
     return CR_OK;
 }