upstream

Author: shevernitskiy

docs/dev/Lua API.rst

@@ -3549,6 +3549,13 @@ parameters.
   ``tonumber(arg)``. If ``arg_name`` is specified, it is used to make error
   messages more useful.
 
+* ``argparse.boolean(arg, arg_name)``
+
+  Converts ``string.lower(arg)`` from "yes/no/on/off/true/false/etc..." to a lua
+  boolean. Throws if the value can't be converted, otherwise returns
+  ``true``/``false``. If ``arg_name`` is specified, it is used to make error
+  messages more useful.
+
 dumper
 ======
 

library/LuaApi.cpp

@@ -1368,8 +1368,8 @@ static CommandHistory * ensureCommandHistory(std::string id,
 
 static int getCommandHistory(lua_State *state)
 {
-    std::string id = lua_tostring(state, 1);
-    std::string src_file = lua_tostring(state, 2);
+    std::string id = luaL_checkstring(state, 1);
+    std::string src_file = luaL_checkstring(state, 2);
     std::vector<std::string> entries;
     ensureCommandHistory(id, src_file)->getEntries(entries);
     Lua::PushVector(state, entries);
@@ -2033,7 +2033,7 @@ static int units_getCitizens(lua_State *L) {
 }
 
 static int units_getUnitsByNobleRole(lua_State *L) {
-    std::string role_name = lua_tostring(L, -1);
+    std::string role_name = luaL_checkstring(L, -1);
     std::vector<df::unit *> units;
     Units::getUnitsByNobleRole(units, role_name);
     Lua::PushVector(L, units);

plugins/pathable.cpp

@@ -1,15 +1,21 @@
 #include "Debug.h"
+#include "MemAccess.h"
 #include "PluginManager.h"
 #include "TileTypes.h"
 
+#include "modules/EventManager.h"
 #include "modules/Gui.h"
+#include "modules/Job.h"
 #include "modules/Maps.h"
 #include "modules/Screen.h"
 #include "modules/Textures.h"
 
+#include "df/block_square_event_designation_priorityst.h"
 #include "df/init.h"
+#include "df/job_list_link.h"
 #include "df/map_block.h"
 #include "df/tile_designation.h"
+#include "df/world.h"
 
 #include <functional>
 
@@ -21,6 +27,7 @@ REQUIRE_GLOBAL(init);
 REQUIRE_GLOBAL(window_x);
 REQUIRE_GLOBAL(window_y);
 REQUIRE_GLOBAL(window_z);
+REQUIRE_GLOBAL(world);
 
 namespace DFHack {
     DBG_DECLARE(pathable, log, DebugCategory::LINFO);
@@ -209,8 +216,221 @@ static void paintScreenWarmDamp(bool show_hidden = false) {
     }
 }
 
+struct designation{
+    df::coord pos;
+    df::tile_designation td;
+    df::tile_occupancy to;
+    designation() = default;
+    designation(const df::coord &c, const df::tile_designation &td, const df::tile_occupancy &to) : pos(c), td(td), to(to) {}
+
+    bool operator==(const designation &rhs) const {
+        return pos == rhs.pos;
+    }
+
+    bool operator!=(const designation &rhs) const {
+        return !(rhs == *this);
+    }
+};
+
+namespace std {
+    template<>
+    struct hash<designation> {
+        std::size_t operator()(const designation &c) const {
+            std::hash<df::coord> hash_coord;
+            return hash_coord(c.pos);
+        }
+    };
+}
+
+class Designations {
+private:
+    std::unordered_map<df::coord, designation> designations;
+public:
+    Designations() {
+        df::job_list_link *link = world->jobs.list.next;
+        for (; link; link = link->next) {
+            df::job *job = link->item;
+
+            if(!job || !Maps::isValidTilePos(job->pos))
+                continue;
+
+            df::tile_designation td;
+            df::tile_occupancy to;
+            bool keep_if_taken = false;
+
+            switch (job->job_type) {
+                case df::job_type::SmoothWall:
+                case df::job_type::SmoothFloor:
+                    keep_if_taken = true;
+                    // fallthrough
+                case df::job_type::CarveFortification:
+                    td.bits.smooth = 1;
+                    break;
+                case df::job_type::DetailWall:
+                case df::job_type::DetailFloor:
+                    td.bits.smooth = 2;
+                    break;
+                case job_type::CarveTrack:
+                    to.bits.carve_track_north = (job->item_category.whole >> 18) & 1;
+                    to.bits.carve_track_south = (job->item_category.whole >> 19) & 1;
+                    to.bits.carve_track_west = (job->item_category.whole >> 20) & 1;
+                    to.bits.carve_track_east = (job->item_category.whole >> 21) & 1;
+                    break;
+                default:
+                    continue;
+            }
+            if (keep_if_taken || !Job::getWorker(job))
+                designations.emplace(job->pos, designation(job->pos, td, to));
+        }
+    }
+
+    // get from job; if no job, then fall back to querying map
+    designation get(const df::coord &pos) const {
+        if (designations.count(pos)) {
+            return designations.at(pos);
+        }
+        auto pdes = Maps::getTileDesignation(pos);
+        auto pocc = Maps::getTileOccupancy(pos);
+        if (!pdes || !pocc)
+            return {};
+        return designation(pos, *pdes, *pocc);
+    }
+};
+
+static bool is_designated_for_smoothing(const designation &designation) {
+    return designation.td.bits.smooth == 1;
+}
+
+static bool is_designated_for_engraving(const designation &designation) {
+    return designation.td.bits.smooth == 2;
+}
+
+static bool is_designated_for_track_carving(const designation &designation) {
+    const df::tile_occupancy &occ = designation.to;
+    return occ.bits.carve_track_east || occ.bits.carve_track_north || occ.bits.carve_track_south || occ.bits.carve_track_west;
+}
+
+static char get_track_char(const designation &designation) {
+    const df::tile_occupancy &occ = designation.to;
+    if (occ.bits.carve_track_east && occ.bits.carve_track_north && occ.bits.carve_track_south && occ.bits.carve_track_west)
+        return (char)0xCE; // NSEW
+    if (occ.bits.carve_track_east && occ.bits.carve_track_north && occ.bits.carve_track_south)
+        return (char)0xCC; // NSE
+    if (occ.bits.carve_track_east && occ.bits.carve_track_north && occ.bits.carve_track_west)
+        return (char)0xCA; // NEW
+    if (occ.bits.carve_track_east && occ.bits.carve_track_south && occ.bits.carve_track_west)
+        return (char)0xCB; // SEW
+    if (occ.bits.carve_track_north && occ.bits.carve_track_south && occ.bits.carve_track_west)
+        return (char)0xB9; // NSW
+    if (occ.bits.carve_track_north && occ.bits.carve_track_south)
+        return (char)0xBA; // NS
+    if (occ.bits.carve_track_east && occ.bits.carve_track_west)
+        return (char)0xCD; // EW
+    if (occ.bits.carve_track_east && occ.bits.carve_track_north)
+        return (char)0xC8; // NE
+    if (occ.bits.carve_track_north && occ.bits.carve_track_west)
+        return (char)0xBC; // NW
+    if (occ.bits.carve_track_east && occ.bits.carve_track_south)
+        return (char)0xC9; // SE
+    if (occ.bits.carve_track_south && occ.bits.carve_track_west)
+        return (char)0xBB; // SW
+    if (occ.bits.carve_track_north)
+        return (char)0xD0; // N
+    if (occ.bits.carve_track_south)
+        return (char)0xD2; // S
+    if (occ.bits.carve_track_east)
+        return (char)0xC6; // E
+    if (occ.bits.carve_track_west)
+        return (char)0xB5; // W
+    return (char)0xC5; // single line cross; should never happen
+}
+
+static bool is_smooth_wall(const df::coord &pos) {
+    df::tiletype *tt = Maps::getTileType(pos);
+    return tt && tileSpecial(*tt) == df::tiletype_special::SMOOTH
+                && tileShape(*tt) == df::tiletype_shape::WALL;
+}
+
+static bool blink(int delay) {
+    return (Core::getInstance().p->getTickCount()/delay) % 2 == 0;
+}
+
+static char get_tile_char(const df::coord &pos, char desig_char, bool draw_priority) {
+    if (!draw_priority)
+        return desig_char;
+
+    std::vector<df::block_square_event_designation_priorityst *> priorities;
+    Maps::SortBlockEvents(Maps::getTileBlock(pos), NULL, NULL, NULL, NULL, NULL, NULL, NULL, &priorities);
+    if (priorities.empty())
+        return desig_char;
+    switch (priorities[0]->priority[pos.x % 16][pos.y % 16] / 1000) {
+    case 1: return '1';
+    case 2: return '2';
+    case 3: return '3';
+    case 4: return '4';
+    case 5: return '5';
+    case 6: return '6';
+    case 7: return '7';
+    default:
+        return '4';
+    }
+}
+
+static void paintScreenCarve() {
+    DEBUG(log).print("entering paintScreenCarve\n");
+
+    if (Screen::inGraphicsMode() || blink(500))
+        return;
+
+    Designations designations;
+    bool draw_priority = blink(1000);
+
+    auto dims = Gui::getDwarfmodeViewDims().map();
+    for (int y = dims.first.y; y <= dims.second.y; ++y) {
+        for (int x = dims.first.x; x <= dims.second.x; ++x) {
+            df::coord map_pos(*window_x + x, *window_y + y, *window_z);
+
+            if (!Maps::isValidTilePos(map_pos))
+                continue;
+
+            if (!Maps::isTileVisible(map_pos)) {
+                TRACE(log).print("skipping hidden tile\n");
+                continue;
+            }
+
+            TRACE(log).print("scanning map tile at (%d, %d, %d) screen offset (%d, %d)\n",
+                map_pos.x, map_pos.y, map_pos.z, x, y);
+
+            Screen::Pen cur_tile;
+            cur_tile.fg = COLOR_DARKGREY;
+
+            auto des = designations.get(map_pos);
+
+            if (is_designated_for_smoothing(des)) {
+                if (is_smooth_wall(map_pos))
+                    cur_tile.ch = get_tile_char(map_pos, (char)206, draw_priority); // hash, indicating a fortification designation
+                else
+                    cur_tile.ch = get_tile_char(map_pos, (char)219, draw_priority); // solid block, indicating a smoothing designation
+            }
+            else if (is_designated_for_engraving(des)) {
+                cur_tile.ch = get_tile_char(map_pos, (char)10, draw_priority); // solid block with a circle on it
+            }
+            else if (is_designated_for_track_carving(des)) {
+                cur_tile.ch = get_tile_char(map_pos, get_track_char(des), draw_priority); // directional track
+            }
+            else {
+                TRACE(log).print("skipping tile with no carving designation\n");
+                continue;
+            }
+
+            Screen::paintTile(cur_tile, x, y, true);
+        }
+    }
+}
+
 DFHACK_PLUGIN_LUA_FUNCTIONS {
     DFHACK_LUA_FUNCTION(paintScreenPathable),
     DFHACK_LUA_FUNCTION(paintScreenWarmDamp),
+    DFHACK_LUA_FUNCTION(paintScreenCarve),
     DFHACK_LUA_END
 };