/**

* Translates a region of tiles specified by the cursor and arguments/prompts

* into a series of blueprint files suitable for replay via quickfort.

*

* Written by cdombroski.

*/

#include "Console.h"

#include "Core.h"

#include "DataDefs.h"

#include "DataFuncs.h"

#include "DataIdentity.h"

#include "Debug.h"

#include "LuaTools.h"

#include "PluginManager.h"

#include "PluginLua.h"

#include "TileTypes.h"

#include "modules/Buildings.h"

#include "modules/Constructions.h"

#include "modules/Filesystem.h"

#include "modules/Gui.h"

#include "modules/Hotkey.h"

#include "modules/Maps.h"

#include "modules/World.h"

#include "df/building_axle_horizontalst.h"

#include "df/building_bridgest.h"

#include "df/building_civzonest.h"

#include "df/building_constructionst.h"

#include "df/building_furnacest.h"

#include "df/building_rollersst.h"

#include "df/building_screw_pumpst.h"

#include "df/building_siegeenginest.h"

#include "df/building_stockpilest.h"

#include "df/building_trapst.h"

#include "df/building_water_wheelst.h"

#include "df/building_workshopst.h"

#include "df/construction.h"

#include "df/engraving.h"

#include "df/entity_position.h"

#include "df/tile_bitmask.h"

#include "df/tile_designation.h"

#include "df/tile_occupancy.h"

#include "df/world.h"

#include <queue>

#include <sstream>

#include <unordered_map>

using std::endl;

using std::map;

using std::ofstream;

using std::ostringstream;

using std::pair;

using std::string;

using std::vector;

using namespace DFHack;

DFHACK_PLUGIN("blueprint");

REQUIRE_GLOBAL(world);

namespace DFHack {

DBG_DECLARE(blueprint,log);

}

struct blueprint_options {

// whether to display help

bool help = false;

// starting tile coordinate of the translation area (if not set then all

// coordinates are set to -30000)

df::coord start;

// output file format. this could be an enum if we set up the boilerplate

// for it.

string format;

// whether to skip generating meta blueprints

bool nometa = false;

// offset and comment to write in the quickfort start() modeline marker

// if not set, coordinates are set to 0 and the comment will be empty

df::coord2d playback_start = df::coord2d(0, 0);

string playback_start_comment;

// file splitting strategy. this could be an enum if we set up the

// boilerplate for it.

string split_strategy;

// dimensions of translation area. width and height are guaranteed to be

// greater than 0. depth can be positive or negative, but not zero.

int32_t width = 0;

int32_t height = 0;

int32_t depth = 0;

// base name to use for generated files

string name;

// whether to capture all smoothed tiles

bool smooth = false;

// whether to capture engravings and smooth the tiles that will be engraved

bool engrave = false;

// whether to autodetect which phases to output

bool auto_phase = false;

// if not autodetecting, which phases to output

bool dig = false;

bool carve = false;

bool construct = false;

bool build = false;

bool place = false;

bool zone = false;

static struct_identity _identity;

};

static const struct_field_info blueprint_options_fields[] = {

{ struct_field_info::PRIMITIVE, "help", offsetof(blueprint_options, help), &df::identity_traits<bool>::identity, 0, 0 },

{ struct_field_info::SUBSTRUCT, "start", offsetof(blueprint_options, start), df::identity_traits<df::coord>::get(), 0, 0},

{ struct_field_info::PRIMITIVE, "format", offsetof(blueprint_options, format), df::identity_traits<string>::get(), 0, 0 },

{ struct_field_info::PRIMITIVE, "nometa", offsetof(blueprint_options, nometa), &df::identity_traits<bool>::identity, 0, 0 },

{ struct_field_info::SUBSTRUCT, "playback_start", offsetof(blueprint_options, playback_start), df::identity_traits<df::coord2d>::get(),0, 0 },

{ struct_field_info::PRIMITIVE, "playback_start_comment", offsetof(blueprint_options, playback_start_comment), df::identity_traits<string>::get(), 0, 0 },

{ struct_field_info::PRIMITIVE, "split_strategy", offsetof(blueprint_options, split_strategy), df::identity_traits<string>::get(), 0, 0 },

{ struct_field_info::PRIMITIVE, "width", offsetof(blueprint_options, width), &df::identity_traits<int32_t>::identity, 0, 0 },

{ struct_field_info::PRIMITIVE, "height", offsetof(blueprint_options, height), &df::identity_traits<int32_t>::identity, 0, 0 },

{ struct_field_info::PRIMITIVE, "depth", offsetof(blueprint_options, depth), &df::identity_traits<int32_t>::identity, 0, 0 },

{ struct_field_info::PRIMITIVE, "name", offsetof(blueprint_options, name), df::identity_traits<string>::get(), 0, 0 },

{ struct_field_info::PRIMITIVE, "smooth", offsetof(blueprint_options, smooth), &df::identity_traits<bool>::identity, 0, 0 },

{ struct_field_info::PRIMITIVE, "engrave", offsetof(blueprint_options, engrave), &df::identity_traits<bool>::identity, 0, 0 },

{ struct_field_info::PRIMITIVE, "auto_phase", offsetof(blueprint_options, auto_phase), &df::identity_traits<bool>::identity, 0, 0 },

{ struct_field_info::PRIMITIVE, "dig", offsetof(blueprint_options, dig), &df::identity_traits<bool>::identity, 0, 0 },

{ struct_field_info::PRIMITIVE, "carve", offsetof(blueprint_options, carve), &df::identity_traits<bool>::identity, 0, 0 },

{ struct_field_info::PRIMITIVE, "construct", offsetof(blueprint_options, construct), &df::identity_traits<bool>::identity, 0, 0 },

{ struct_field_info::PRIMITIVE, "build", offsetof(blueprint_options, build), &df::identity_traits<bool>::identity, 0, 0 },

{ struct_field_info::PRIMITIVE, "place", offsetof(blueprint_options, place), &df::identity_traits<bool>::identity, 0, 0 },

{ struct_field_info::PRIMITIVE, "zone", offsetof(blueprint_options, zone), &df::identity_traits<bool>::identity, 0, 0 },

{ struct_field_info::END }

};

struct_identity blueprint_options::_identity(sizeof(blueprint_options), &df::allocator_fn<blueprint_options>, NULL, "blueprint_options", NULL, blueprint_options_fields);

command_result blueprint(color_ostream &, vector<string> &);

DFhackCExport command_result plugin_init(color_ostream &, vector<PluginCommand> &commands) {

commands.push_back(

PluginCommand("blueprint",

"Record a live game map in a quickfort blueprint.",

blueprint));

return CR_OK;

}

DFhackCExport command_result plugin_shutdown(color_ostream &) {

return CR_OK;

}

struct blueprint_processor;

struct tile_context {

blueprint_processor *processor;

bool pretty = false;

df::building* b = NULL;

};

typedef vector<const char *> bp_row; // index is x coordinate

typedef map<int16_t, bp_row> bp_area; // key is y coordinate

typedef map<int16_t, bp_area> bp_volume; // key is z coordinate

typedef const char * (get_tile_fn)(color_ostream &out, const df::coord &pos, const tile_context &ctx);

typedef void (init_ctx_fn)(const df::coord &pos, tile_context &ctx);

struct blueprint_processor {

bp_volume mapdata;

const string mode;

const string phase;

const bool force_create;

get_tile_fn * const get_tile;

init_ctx_fn * const init_ctx;

std::set<df::building *> seen;

blueprint_processor(const string &mode, const string &phase,

bool force_create, get_tile_fn *get_tile,

init_ctx_fn *init_ctx)

: mode(mode), phase(phase), force_create(force_create),

get_tile(get_tile), init_ctx(init_ctx) { }

};

// global caches, lazily initialized and cleared at the end of each blueprint

// this assumes that no two blueprints are being generated at the same time,

// which is currently ensured by the higher-level DFHack command handling code.

// if this assumption ever becomes untrue, we'll need to protect the caches

// with thread synchronization primitives or make the caches per-blueprint.

static std::set<string> string_cache;

static std::unordered_map<df::coord, df::engraving *> engravings_cache;

static std::unordered_map<df::coord, df::job *> dig_job_cache;

static PersistentDataItem warm_config, damp_config;

static void init_caches(DFHack::color_ostream &out, bool cache_engravings) {

if (cache_engravings) {

// initialize the engravings cache

for (auto engraving : world->event.engravings) {

engravings_cache.emplace(engraving->pos, engraving);

}

}

df::job_list_link *link = world->jobs.list.next;

for (; link; link = link->next) {

auto job = link->item;

auto type = ENUM_ATTR(job_type, type, job->job_type);

if (type != job_type_class::Digging && type != job_type_class::Carving && type != job_type_class::Gathering)

continue;

dig_job_cache.emplace(job->pos, job);

}

Lua::CallLuaModuleFunction(out, "plugins.dig", "getWarmConfigKey", {}, 1, [&](lua_State *L){

string warm_key = lua_tostring(L, -1);

warm_config = World::GetPersistentSiteData(warm_key);

});

Lua::CallLuaModuleFunction(out, "plugins.dig", "getDampConfigKey", {}, 1, [&](lua_State *L){

string damp_key = lua_tostring(L, -1);

damp_config = World::GetPersistentSiteData(damp_key);

});

}

static void clear_caches() {

string_cache.clear();

engravings_cache.clear();

dig_job_cache.clear();

warm_config = PersistentDataItem();

damp_config = PersistentDataItem();

}

// We use const char * throughout this code instead of std::string to avoid

// having to allocate memory for all the small string literals. This

// significantly speeds up processing and allows us to handle very large maps

// (e.g. 16x16 embarks) without running out of memory. This cache provides a

// mechanism for storing dynamically created strings so their memory stays

// allocated until we write out the blueprints at the end.

// If NULL is passed as the str, the cache is cleared.

static const char * cache(const char *str) {

if (!str)

return NULL;

return string_cache.emplace(str).first->c_str();

}

// Convenience wrapper for std::string.

static const char * cache(const string &str) {

return cache(str.c_str());

}

// Convenience wrapper for std::ostringstream.

static const char * cache(ostringstream &str) {

return cache(str.str());

}

static const char * add_markers(const df::coord &pos, const char *sym) {

if (!sym)

return NULL;

string str;

if (auto occ = Maps::getTileOccupancy(pos); occ && occ->bits.dig_marked)

str += "mb";

auto block = Maps::getTileBlock(pos);

if (auto warm_mask = World::getPersistentTilemask(warm_config, block); warm_mask && warm_mask->getassignment(pos))

str += "mw";

if (auto damp_mask = World::getPersistentTilemask(damp_config, block); damp_mask && damp_mask->getassignment(pos))

str += "md";

if (str.size()) {

str += sym;

return cache(str);

}

return sym;

}

static const char * get_tile_dig_default(const df::coord &pos, df::tiletype *tt) {

switch (tileShape(*tt)) {

case df::tiletype_shape::WALL:

if (auto tmat = tileMaterial(*tt))

if (tmat == df::tiletype_material::TREE)

return "t";

return "d";

case df::tiletype_shape::STAIR_UP:

case df::tiletype_shape::STAIR_UPDOWN:

case df::tiletype_shape::RAMP:

return "z";

case df::tiletype_shape::SHRUB:

return "p";

default:

return "d";

}

}

static const char * get_tile_dig_designation(const df::coord &pos, const df::tile_dig_designation &tdd) {

switch (tdd) {

case df::tile_dig_designation::Default:

if (auto tt = Maps::getTileType(pos))

return get_tile_dig_default(pos, tt);

return NULL;

case df::tile_dig_designation::UpDownStair:

return "i";

case df::tile_dig_designation::Channel:

return "h";

case df::tile_dig_designation::Ramp:

return "r";

case df::tile_dig_designation::DownStair:

if (auto tt = Maps::getTileType(pos))

if (tileShape(*tt) == tiletype_shape::STAIR_UP)

return "i";

return "j";

case df::tile_dig_designation::UpStair:

return "u";

default:

return NULL;

}

}

static const char * get_tile_dig_job(df::tile_designation *td, df::job *job) {

switch (job->job_type) {

case df::job_type::DigChannel:

return "h";

case df::job_type::Dig:

return "d";

case df::job_type::CarveUpwardStaircase:

return "u";

case df::job_type::CarveDownwardStaircase:

return "j";

case df::job_type::CarveUpDownStaircase:

return "i";

case df::job_type::CarveRamp:

return "r";

case df::job_type::FellTree:

return "t";

case df::job_type::GatherPlants:

return "p";

case df::job_type::RemoveStairs:

return "z";

default:

return NULL;

}

}

static const char * get_tile_dig(color_ostream &out, const df::coord &pos, const tile_context &) {

df::tile_designation *td = Maps::getTileDesignation(pos);

if (td && td->bits.dig != df::tile_dig_designation::No)

return add_markers(pos, get_tile_dig_designation(pos, td->bits.dig));

if (dig_job_cache.contains(pos))

if (const char * ret = get_tile_dig_job(td, dig_job_cache[pos]))

return add_markers(pos, ret);

auto tt = Maps::getTileType(pos);

if (!tt)

return NULL;

switch (tileShape(*tt))

{

case tiletype_shape::EMPTY:

case tiletype_shape::RAMP_TOP:

return "h";

case tiletype_shape::FLOOR:

case tiletype_shape::BOULDER:

case tiletype_shape::PEBBLES:

case tiletype_shape::BROOK_TOP:

case tiletype_shape::SAPLING:

case tiletype_shape::SHRUB:

case tiletype_shape::TWIG:

return "d";

case tiletype_shape::STAIR_UP:

return "u";

case tiletype_shape::STAIR_DOWN:

return "j";

case tiletype_shape::STAIR_UPDOWN:

return "i";

case tiletype_shape::RAMP:

return "r";

case tiletype_shape::WALL:

default:

return NULL;

}

}

static const char * get_tile_smooth_minimal(color_ostream &out, const df::coord &pos, const tile_context &) {

if (dig_job_cache.contains(pos) && dig_job_cache[pos]->job_type == df::job_type::CarveFortification)

return "s";

auto tt = Maps::getTileType(pos);

if (!tt)

return NULL;

// detect designated fortications

if (auto td = Maps::getTileDesignation(pos); td && td->bits.smooth == 1)

if (tileSpecial(*tt) == tiletype_special::SMOOTH)

return "s";

switch (tileShape(*tt))

{

case tiletype_shape::FORTIFICATION:

return "s";

default:

break;

}

return NULL;

}

static const char * get_tile_smooth_with_engravings(color_ostream &out, const df::coord &pos, const tile_context &tc) {

const char * smooth_minimal = get_tile_smooth_minimal(out, pos, tc);

if (smooth_minimal)

return smooth_minimal;

if (dig_job_cache.contains(pos) &&

(dig_job_cache[pos]->job_type == df::job_type::DetailFloor ||

dig_job_cache[pos]->job_type == df::job_type::DetailWall))

return "s";

if (auto td = Maps::getTileDesignation(pos); td && td->bits.smooth == 2)

return "s";

auto tt = Maps::getTileType(pos);

if (!tt)

return NULL;

switch (tileShape(*tt))

{

case tiletype_shape::FLOOR:

case tiletype_shape::WALL:

if (tileSpecial(*tt) == tiletype_special::SMOOTH &&

engravings_cache.count(pos))

return "s";

break;

default:

break;

}

return NULL;

}

static const char * get_tile_smooth_all(color_ostream &out, const df::coord &pos, const tile_context &tc) {

const char * smooth_minimal = get_tile_smooth_minimal(out, pos, tc);

if (smooth_minimal)

return smooth_minimal;

if (dig_job_cache.contains(pos) &&

(dig_job_cache[pos]->job_type == df::job_type::SmoothFloor ||

dig_job_cache[pos]->job_type == df::job_type::SmoothWall))

return "s";

if (auto td = Maps::getTileDesignation(pos); td && td->bits.smooth == 1)

return "s";

df::tiletype *tt = Maps::getTileType(pos);

if (!tt)

return NULL;

switch (tileShape(*tt))

{

case tiletype_shape::FLOOR:

case tiletype_shape::WALL:

if (tileSpecial(*tt) == tiletype_special::SMOOTH)

return "s";

break;

default:

break;

}

return NULL;

}

static bool has_track_designation(df::tile_occupancy occ) {

static const uint32_t track_mask = occ.mask_carve_track_north | occ.mask_carve_track_south

| occ.mask_carve_track_east | occ.mask_carve_track_west;

return occ.whole & track_mask;

}

static const char * get_track_str(const char *prefix, df::tiletype tt, df::tile_occupancy occ) {

TileDirection tdir = tileDirection(tt);

string dir;

if (tdir.north || occ.bits.carve_track_north) dir += "N";

if (tdir.south || occ.bits.carve_track_south) dir += "S";

if (tdir.east || occ.bits.carve_track_east) dir += "E";

if (tdir.west || occ.bits.carve_track_west) dir += "W";

return cache(prefix + dir);

}

static const char * get_tile_carve_minimal(color_ostream &out, const df::coord &pos, const tile_context &) {

df::tiletype *tt = Maps::getTileType(pos);

if (!tt)

return NULL;

if (dig_job_cache.contains(pos)) {

df::job *job = dig_job_cache[pos];

switch (job->job_type) {

case df::job_type::CarveTrack:

switch (tileShape(*tt))

{

case tiletype_shape::FLOOR:

return get_track_str("track", *tt, job->specflag.carve_track_flags);

case tiletype_shape::RAMP:

return get_track_str("trackramp", *tt, job->specflag.carve_track_flags);

default:

break;

}

break;

case df::job_type::CarveFortification:

return "F";

default:

break;

}

}

auto td = Maps::getTileDesignation(pos);

auto occ = Maps::getTileOccupancy(pos);

switch (tileShape(*tt))

{

case tiletype_shape::WALL:

if (tileSpecial(*tt) == tiletype_special::SMOOTH && td && td->bits.smooth == 1)

return "F";

break;

case tiletype_shape::FLOOR:

if (tileSpecial(*tt) == tiletype_special::TRACK || has_track_designation(*occ))

return get_track_str("track", *tt, *occ);

break;

case tiletype_shape::RAMP:

if (tileSpecial(*tt) == tiletype_special::TRACK || has_track_designation(*occ))

return get_track_str("trackramp", *tt, *occ);

break;

case tiletype_shape::FORTIFICATION:

return "F";

default:

break;

}

return NULL;

}

static const char * get_tile_carve(color_ostream &out, const df::coord &pos, const tile_context &tc) {

const char * tile_carve_minimal = get_tile_carve_minimal(out, pos, tc);

if (tile_carve_minimal)

return tile_carve_minimal;

if (dig_job_cache.contains(pos) &&

(dig_job_cache[pos]->job_type == df::job_type::DetailFloor ||

dig_job_cache[pos]->job_type == df::job_type::DetailWall))

return "e";

if (auto td = Maps::getTileDesignation(pos); td && td->bits.smooth == 2)

return "e";

df::tiletype *tt = Maps::getTileType(pos);

if (!tt)

return NULL;

switch (tileShape(*tt))

{

case tiletype_shape::FLOOR:

case tiletype_shape::WALL:

if (tileSpecial(*tt) == tiletype_special::SMOOTH &&

engravings_cache.count(pos))

return "e";

break;

default:

break;

}

return NULL;

}

static const char * get_construction_str(df::building *b) {

df::building_constructionst *cons =

virtual_cast<df::building_constructionst>(b);

if (!cons)

return "~";

switch (cons->type) {

case construction_type::Fortification: return "CF";

case construction_type::Wall: return "Cw";

case construction_type::Floor: return "Cf";

case construction_type::UpStair: return "Cu";

case construction_type::DownStair: return "Cd";

case construction_type::UpDownStair: return "Cx";

case construction_type::Ramp: return "Cr";

case construction_type::TrackN: return "trackN";

case construction_type::TrackS: return "trackS";

case construction_type::TrackE: return "trackE";

case construction_type::TrackW: return "trackW";

case construction_type::TrackNS: return "trackNS";

case construction_type::TrackNE: return "trackNE";

case construction_type::TrackNW: return "trackNW";

case construction_type::TrackSE: return "trackSE";

case construction_type::TrackSW: return "trackSW";

case construction_type::TrackEW: return "trackEW";

case construction_type::TrackNSE: return "trackNSE";

case construction_type::TrackNSW: return "trackNSW";

case construction_type::TrackNEW: return "trackNEW";

case construction_type::TrackSEW: return "trackSEW";

case construction_type::TrackNSEW: return "trackNSEW";

case construction_type::TrackRampN: return "trackrampN";

case construction_type::TrackRampS: return "trackrampS";

case construction_type::TrackRampE: return "trackrampE";

case construction_type::TrackRampW: return "trackrampW";

case construction_type::TrackRampNS: return "trackrampNS";

case construction_type::TrackRampNE: return "trackrampNE";

case construction_type::TrackRampNW: return "trackrampNW";

case construction_type::TrackRampSE: return "trackrampSE";

case construction_type::TrackRampSW: return "trackrampSW";

case construction_type::TrackRampEW: return "trackrampEW";

case construction_type::TrackRampNSE: return "trackrampNSE";

case construction_type::TrackRampNSW: return "trackrampNSW";

case construction_type::TrackRampNEW: return "trackrampNEW";

case construction_type::TrackRampSEW: return "trackrampSEW";

case construction_type::TrackRampNSEW: return "trackrampNSEW";

case construction_type::ReinforcedWall: return "CW";

case construction_type::NONE:

default:

return "~";

}

}

static const char * get_constructed_track_str(df::tiletype *tt,

const char * base) {

TileDirection dir = tileDirection(*tt);

if (!dir.whole)

return "~";

ostringstream str;

str << base;

if (dir.north) str << "N";

if (dir.south) str << "S";

if (dir.east) str << "E";

if (dir.west) str << "W";

return cache(str);

}

static const char * get_constructed_wall_str(df::coord pos) {

df::construction *c = Constructions::findAtTile(pos);

if (!c || !(c->flags.bits.reinforced))

return "Cw";

return "CW";

}

static const char * get_constructed_floor_str(df::tiletype *tt) {

if (tileSpecial(*tt) != df::tiletype_special::TRACK)

return "Cf";

return get_constructed_track_str(tt, "track");

}

static const char * get_constructed_ramp_str(df::tiletype *tt) {

if (tileSpecial(*tt) != df::tiletype_special::TRACK)

return "Cr";

return get_constructed_track_str(tt, "trackramp");

}

static const char * get_tile_construct(color_ostream &out, const df::coord &pos, const tile_context &ctx) {

if (ctx.b && ctx.b->getType() == building_type::Construction)

return get_construction_str(ctx.b);

df::tiletype *tt = Maps::getTileType(pos);

if (!tt || tileMaterial(*tt) != df::tiletype_material::CONSTRUCTION)

return NULL;

switch (tileShape(*tt)) {

case tiletype_shape::WALL: return get_constructed_wall_str(pos);

case tiletype_shape::FLOOR: return get_constructed_floor_str(tt);

case tiletype_shape::RAMP: return get_constructed_ramp_str(tt);

case tiletype_shape::FORTIFICATION: return "CF";

case tiletype_shape::STAIR_UP: return "Cu";

case tiletype_shape::STAIR_DOWN: return "Cd";

case tiletype_shape::STAIR_UPDOWN: return "Cx";

default:

return "~";

}

return NULL;

}

static pair<uint32_t, uint32_t> get_building_size(const df::building *b) {

return pair<uint32_t, uint32_t>(b->x2 - b->x1 + 1, b->y2 - b->y1 + 1);

}

static const char * if_pretty(const tile_context &ctx, const char *c) {

return ctx.pretty ? c : NULL;

}

static bool is_rectangular(const df::building *bld) {

const df::building::T_room &room = bld->room;

if (!room.extents)

return true;

for (int32_t y = 0; y < room.height; ++y) {

for (int32_t x = 0; x < room.width; ++x) {

if (!room.extents[y * room.width + x])

return false;

}

}

return true;

}

static bool is_rectangular(const tile_context &ctx) {

return is_rectangular(ctx.b);

}

static const char * do_block_building(const tile_context &ctx, const char *s,

bool at_target_pos,

bool *add_size = NULL) {

if(!at_target_pos) {

return if_pretty(ctx, "`");

}

if (add_size)

*add_size = true;

return s;

}

static const char * do_extent_building(const tile_context &ctx, const char *s,

bool at_target_pos,

bool *add_size = NULL) {

// use expansion syntax for rectangular or one-tile buildings

if (is_rectangular(ctx))

return do_block_building(ctx, s, at_target_pos, add_size);

return s;

}

static const char * get_bridge_str(df::building *b) {

df::building_bridgest *bridge = virtual_cast<df::building_bridgest>(b);

if (!bridge)

return "g";

switch(bridge->direction) {

case df::building_bridgest::T_direction::Retracting: return "gs";

case df::building_bridgest::T_direction::Left: return "ga";

case df::building_bridgest::T_direction::Right: return "gd";

case df::building_bridgest::T_direction::Up: return "gw";

case df::building_bridgest::T_direction::Down: return "gx";

default:

return "g";

}

}

static const char * get_siege_str(df::building *b) {

df::building_siegeenginest *se =

virtual_cast<df::building_siegeenginest>(b);

if (!se)

return "ic";

switch(se->type) {

case df::siegeengine_type::Catapult: return "ic";

case df::siegeengine_type::Ballista: return "ib";

case df::siegeengine_type::BoltThrower: return "it";

default:

return "ic";

}

}

static const char * get_workshop_str(df::building *b) {

df::building_workshopst *ws = virtual_cast<df::building_workshopst>(b);

if (!ws)

return "~";

switch (ws->type) {

case workshop_type::Leatherworks: return "we";

case workshop_type::Quern: return "wq";

case workshop_type::Millstone: return "wM";

case workshop_type::Loom: return "wo";

case workshop_type::Clothiers: return "wk";

case workshop_type::Bowyers: return "wb";

case workshop_type::Carpenters: return "wc";

case workshop_type::MetalsmithsForge: return "wf";

case workshop_type::MagmaForge: return "wv";

case workshop_type::Jewelers: return "wj";

case workshop_type::Masons: return "wm";

case workshop_type::Butchers: return "wu";

case workshop_type::Tanners: return "wn";

case workshop_type::Craftsdwarfs: return "wr";

case workshop_type::Siege: return "ws";

case workshop_type::Mechanics: return "wt";

case workshop_type::Still: return "wl";

case workshop_type::Farmers: return "ww";

case workshop_type::Kitchen: return "wz";

case workshop_type::Fishery: return "wh";

case workshop_type::Ashery: return "wy";

case workshop_type::Dyers: return "wd";

case workshop_type::Kennels: return "k";

case workshop_type::Custom:

{

int32_t custom = b->getCustomType();

if (custom == 0) return "wS";

if (custom == 1) return "wp";

}

// fallthrough

case workshop_type::Tool:

default:

return "~";

}

}

static const char * get_furnace_str(df::building *b) {

df::building_furnacest *furnace = virtual_cast<df::building_furnacest>(b);

if (!furnace)

return "~";

switch (furnace->type) {

case furnace_type::WoodFurnace: return "ew";

case furnace_type::Smelter: return "es";

case furnace_type::GlassFurnace: return "eg";

case furnace_type::Kiln: return "ek";

case furnace_type::MagmaSmelter: return "el";

case furnace_type::MagmaGlassFurnace: return "ea";

case furnace_type::MagmaKiln: return "en";

case furnace_type::Custom:

default:

return "~";

}

}

static const char * get_trap_str(df::building *b) {

df::building_trapst *trap = virtual_cast<df::building_trapst>(b);

if (!trap)

return "~";

switch (trap->trap_type) {

case trap_type::StoneFallTrap: return "Ts";

case trap_type::WeaponTrap: return "Tw";

case trap_type::Lever: return "Tl";

case trap_type::PressurePlate: return "Tp";

case trap_type::CageTrap: return "Tc";

case trap_type::TrackStop:

{

ostringstream buf;

buf << "CS";

if (trap->track_stop_info.track_flags.bits.use_dump) {

if (trap->track_stop_info.dump_x_shift == 0) {

buf << "d";

if (trap->track_stop_info.dump_y_shift > 0)

buf << "d";

} else {

buf << "ddd";

if (trap->track_stop_info.dump_x_shift < 0)

buf << "d";

}

}

// each case falls through and is additive

switch (trap->track_stop_info.friction) {

case 10: buf << "a";

case 50: buf << "a";

case 500: buf << "a";

case 10000: buf << "a";

}

return cache(buf);

}

default:

return "~";

}

}

static const char * get_screw_pump_str(df::building *b) {

df::building_screw_pumpst *sp = virtual_cast<df::building_screw_pumpst>(b);

if (!sp)

return "~";

switch (sp->direction)

{

case screw_pump_direction::FromNorth: return "Msu";

case screw_pump_direction::FromEast: return "Msk";

case screw_pump_direction::FromSouth: return "Msm";

case screw_pump_direction::FromWest: return "Msh";

default:

return "~";

}

}

static const char * get_water_wheel_str(df::building *b) {

df::building_water_wheelst *ww =

virtual_cast<df::building_water_wheelst>(b);

if (!ww)

return "~";

return ww->is_vertical ? "Mw" : "Mws";

}

static const char * get_axle_str(df::building *b) {

df::building_axle_horizontalst *ah =

virtual_cast<df::building_axle_horizontalst>(b);

if (!ah)

return "~";

return ah->is_vertical ? "Mhs" : "Mh";

}

static const char * add_speed_suffix(df::building_rollersst *r,

const char *prefix) {

int32_t speed = r->speed;

if (speed >= 50000) return prefix;

string sprefix(prefix);

if (speed >= 40000) return cache(sprefix + "q");

if (speed >= 30000) return cache(sprefix + "qq");

if (speed >= 20000) return cache(sprefix + "qqq");

return cache(sprefix + "qqqq");

}

static const char * get_roller_str(df::building *b) {

df::building_rollersst *r = virtual_cast<df::building_rollersst>(b);

if (!r)

return "~";

switch (r->direction) {

case screw_pump_direction::FromNorth: return add_speed_suffix(r, "Mr");

case screw_pump_direction::FromEast: return add_speed_suffix(r, "Mrs");

case screw_pump_direction::FromSouth: return add_speed_suffix(r, "Mrss");

case screw_pump_direction::FromWest: return add_speed_suffix(r, "Mrsss");

default:

return "~";

}

}

static const char * get_build_keys(const df::coord &pos,

const tile_context &ctx,

bool &add_size) {

bool at_nw_corner = static_cast<int32_t>(pos.x) == ctx.b->x1

&& static_cast<int32_t>(pos.y) == ctx.b->y1;

bool at_se_corner = static_cast<int32_t>(pos.x) == ctx.b->x2

&& static_cast<int32_t>(pos.y) == ctx.b->y2;

bool at_center = static_cast<int32_t>(pos.x) == ctx.b->centerx

&& static_cast<int32_t>(pos.y) == ctx.b->centery;

// building_type::Construction is handled by the construction phase

switch(ctx.b->getType()) {

case building_type::Armorstand:

return "a";

case building_type::Bed:

return "b";

case building_type::Chair:

return "c";

case building_type::Door:

return "d";

case building_type::Floodgate:

return "x";

case building_type::Cabinet:

return "f";

case building_type::Box:

return "h";

case building_type::FarmPlot:

return do_extent_building(ctx, "p", at_nw_corner, &add_size);

case building_type::Weaponrack:

return "r";

case building_type::Statue:

return "s";

case building_type::Table:

return "t";

case building_type::Coffin:

return "n";

case building_type::RoadPaved:

return do_extent_building(ctx, "o", at_nw_corner, &add_size);

case building_type::RoadDirt:

return do_extent_building(ctx, "O", at_nw_corner, &add_size);

case building_type::Bridge:

return do_block_building(ctx, get_bridge_str(ctx.b), at_nw_corner,

&add_size);

case building_type::Well:

return "l";

case building_type::SiegeEngine:

return do_block_building(ctx, get_siege_str(ctx.b), at_center);

case building_type::Workshop:

return do_block_building(ctx, get_workshop_str(ctx.b), at_center);

case building_type::Furnace:

return do_block_building(ctx, get_furnace_str(ctx.b), at_center);

case building_type::WindowGlass:

return "y";

case building_type::WindowGem:

return "Y";

case building_type::Shop:

return do_block_building(ctx, "z", at_center);

case building_type::AnimalTrap:

return "m";

case building_type::Chain:

return "v";

case building_type::Cage:

return "j";

case building_type::TradeDepot:

return do_block_building(ctx, "D", at_center);

case building_type::Trap:

return get_trap_str(ctx.b);

case building_type::Weapon:

return "TS";

case building_type::ScrewPump:

return do_block_building(ctx, get_screw_pump_str(ctx.b), at_se_corner);

case building_type::WaterWheel:

return do_block_building(ctx, get_water_wheel_str(ctx.b), at_center);

case building_type::Windmill:

return do_block_building(ctx, "Mm", at_center);

case building_type::GearAssembly:

return "Mg";

case building_type::AxleHorizontal:

return do_block_building(ctx, get_axle_str(ctx.b), at_nw_corner,

&add_size);

case building_type::AxleVertical: