textures = Textures::loadTileset(Core::getInstance().getHackPath() / "data" / "art" / "damp_dig_map.png", 32, 32, true);

commands.push_back(PluginCommand(

"digv",

"Dig a whole vein.",

digv,

Gui::cursor_hotkey));

commands.push_back(PluginCommand(

"digvx",

"Dig a whole vein, following through z-levels.",

digvx,

Gui::cursor_hotkey));

commands.push_back(PluginCommand(

"digl",

"Dig layerstone.",

digl,

Gui::cursor_hotkey));

commands.push_back(PluginCommand(

"diglx",

"Dig layerstone, following through z-levels.",

diglx,

Gui::cursor_hotkey));

commands.push_back(PluginCommand(

"digexp",

"Select or designate an exploratory pattern.",

digexp));

commands.push_back(PluginCommand(

"digcircle",

"Dig designate a circle (filled or hollow)",

digcircle));

commands.push_back(PluginCommand(

"digtype",

"Dig all veins of a given type.",

digtype,Gui::cursor_hotkey));

return CR_OK;

if (enable != is_enabled) {

is_enabled = enable;

DEBUG(log).print("{}\n", is_enabled ? "enabled" : "disabled");

if (enable) {

EventManager::registerListener(EventManager::EventType::JOB_STARTED,

EventManager::EventHandler(plugin_self, unhide_surrounding_tagged_tiles, 0));

} else {

EventManager::unregisterAll(plugin_self);

}

}

else {

DEBUG(log).print("{}, but already {}; no action\n",

is_enabled ? "enabled" : "disabled", is_enabled ? "enabled" : "disabled");

}

cycle_timestamp = 0;

is_painting_warm = false;

is_painting_damp = false;

warm_config = World::GetPersistentSiteData(WARM_CONFIG_KEY);

damp_config = World::GetPersistentSiteData(DAMP_CONFIG_KEY);

if (!warm_config.isValid()) {

DEBUG(log,out).print("no warm dig config found in this save; initializing\n");

warm_config = World::AddPersistentSiteData(WARM_CONFIG_KEY);

}

if (!damp_config.isValid()) {

DEBUG(log,out).print("no damp dig config found in this save; initializing\n");

damp_config = World::AddPersistentSiteData(DAMP_CONFIG_KEY);

}

for (auto & block : world->map.map_blocks) {

auto warm_mask = World::getPersistentTilemask(warm_config, block);

auto damp_mask = World::getPersistentTilemask(damp_config, block);

if (warm_mask || damp_mask) {

do_enable(true);

break;

}

}

return CR_OK;

if (event == DFHack::SC_WORLD_UNLOADED) {

is_painting_warm = false;

is_painting_damp = false;

do_enable(false);

}

return CR_OK;

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)

continue;

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

}

cycle_timestamp = world->frame_counter;

std::unordered_map<df::coord, df::job *> dig_jobs;

fill_dig_jobs(dig_jobs);

bool has_assignment = false;

uint32_t scrubbed = 0;

for (auto & block : world->map.map_blocks) {

auto warm_mask = World::getPersistentTilemask(warm_config, block);

auto damp_mask = World::getPersistentTilemask(damp_config, block);

if (!warm_mask && !damp_mask)

continue;

bool used = false;

const auto & block_pos = block->map_pos;

for (uint32_t x = 0; x < 16; x++) for (uint32_t y = 0; y < 16; y++) {

if ((!warm_mask || !warm_mask->getassignment(x, y)) &&

(!damp_mask || !damp_mask->getassignment(x, y)))

{

continue;

}

if (!block->designation[x][y].bits.dig &&

!dig_jobs.contains(block_pos + df::coord(x, y, 0)))

{

if (warm_mask) warm_mask->setassignment(x, y, false);

if (damp_mask) damp_mask->setassignment(x, y, false);

++scrubbed;

} else {

has_assignment = true;

used = true;

}

}

if (!used) {

// delete the tile masks so we can skip over this block in the future

World::deletePersistentTilemask(warm_config, block);

World::deletePersistentTilemask(damp_config, block);

}

}

DEBUG(log,out).print("scrubbed {} tagged tiles\n", scrubbed);

if (!has_assignment){

DEBUG(log,out).print("no more active tagged tiles; disabling\n");

do_enable(false);

}

if (world->frame_counter - cycle_timestamp >= CYCLE_TICKS)

do_cycle(out);

return CR_OK;

auto block = Maps::getTileBlock(pos);

if (!block)

return false;

return block->temperature_1[pos.x&15][pos.y&15] >= 10075;

df::tiletype *tt = Maps::getTileType(x, y, z);

if (!tt)

return false;

return tileShape(*tt) == df::tiletype_shape::WALL &&

tileSpecial(*tt) != df::tiletype_special::SMOOTH;

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

return tt && tileSpecial(*tt) == df::tiletype_special::SMOOTH

&& tileShape(*tt) == df::tiletype_shape::WALL;

if (!des)

des = Maps::getTileDesignation(x, y, z);

if (!des)

return false;

return des->bits.water_table && is_rough_wall(x, y, z);

if (!block)

block = Maps::getTileBlock(x, y, z);

if (!block || !block->flags.bits.has_aquifer)

return false;

auto occ = Maps::getTileOccupancy(x, y, z);

if (!occ)

return false;

return occ->bits.heavy_aquifer;

auto des = Maps::getTileDesignation(x, y, z);

if (!des)

return false;

if (des->bits.liquid_type == df::tile_liquid::Water && des->bits.flow_size >= 1)

return true;

if (is_aquifer(x, y, z, des))

return true;

return false;

return is_wet(pos.x-1, pos.y-1, pos.z) ||

is_wet(pos.x, pos.y-1, pos.z) ||

is_wet(pos.x+1, pos.y-1, pos.z) ||

is_wet(pos.x-1, pos.y, pos.z) ||

is_wet(pos.x+1, pos.y, pos.z) ||

is_wet(pos.x-1, pos.y+1, pos.z) ||

is_wet(pos.x, pos.y+1, pos.z) ||

is_wet(pos.x+1, pos.y+1, pos.z) ||

is_wet(pos.x, pos.y, pos.z+1);

int16_t mat, bool warm, bool damp, const df::coord & pos)

{

auto block = Maps::getTileBlock(pos);

if (!block)

return;

INFO(log,out).print("testing adjacent tile at ({},{},{}), mat:{}",

pos.x, pos.y, pos.z, mc.veinMaterialAt(pos));

if (mat != mc.veinMaterialAt(pos))

return;

auto des = Maps::getTileDesignation(pos);

auto occ = Maps::getTileOccupancy(pos);

if (!des || !occ || !is_wall(pos))

return;

if (des->bits.hidden && ((warm && is_warm(pos)) || (damp && is_damp(pos)))) {

des->bits.dig = df::tile_dig_designation::Default;

occ->bits.dig_auto = true;

}

if (warm) {

if (auto warm_mask = World::getPersistentTilemask(warm_config, block, true))

warm_mask->setassignment(pos, true);

}

if (damp) {

if (auto damp_mask = World::getPersistentTilemask(damp_config, block, true))

damp_mask->setassignment(pos, true);

}

MapExtras::MapCache mc;

int16_t mat = mc.veinMaterialAt(pos);

if (mat == -1)

return;

DEBUG(log,out).print("processing autodig tile at ({},{},{}), warm:{}, damp:{}, mat:{}\n",

pos.x, pos.y, pos.z, warm, damp, mat);

propagate_if_material_match(out, mc, mat, warm, damp, pos + df::coord(-1, -1, 0));

propagate_if_material_match(out, mc, mat, warm, damp, pos + df::coord( 0, -1, 0));

propagate_if_material_match(out, mc, mat, warm, damp, pos + df::coord( 1, -1, 0));

propagate_if_material_match(out, mc, mat, warm, damp, pos + df::coord(-1, 0, 0));

propagate_if_material_match(out, mc, mat, warm, damp, pos + df::coord( 1, 0, 0));

propagate_if_material_match(out, mc, mat, warm, damp, pos + df::coord(-1, 1, 0));

propagate_if_material_match(out, mc, mat, warm, damp, pos + df::coord( 0, 1, 0));

propagate_if_material_match(out, mc, mat, warm, damp, pos + df::coord( 1, 1, 0));

auto block = Maps::getTileBlock(pos);

if (!block)

return;

bool warm = false, damp = false;

if (auto warm_mask = World::getPersistentTilemask(warm_config, block)) {

warm = warm_mask->getassignment(pos);

warm_mask->setassignment(pos, false);

}

if (auto damp_mask = World::getPersistentTilemask(damp_config, block)) {

damp = damp_mask->getassignment(pos);

damp_mask->setassignment(pos, false);

}

auto occ = Maps::getTileOccupancy(pos);

if (!occ || !occ->bits.dig_auto || (!warm && !damp))

return;

do_autodig(out, warm, damp, pos);

auto block = Maps::getTileBlock(pos);

if (!block)

return;

if (auto warm_mask = World::getPersistentTilemask(warm_config, block)) {

TRACE(log,out).print("testing tile at ({},{},{}); mask:{}, warm:{}\n", pos.x, pos.y, pos.z,

warm_mask->getassignment(pos), is_warm(pos));

if (warm_mask->getassignment(pos) && is_warm(pos)) {

DEBUG(log,out).print("revealing warm dig tile at ({},{},{})\n", pos.x, pos.y, pos.z);

block->designation[pos.x&15][pos.y&15].bits.hidden = false;

}

}

if (auto damp_mask = World::getPersistentTilemask(damp_config, block)) {

TRACE(log,out).print("testing tile at ({},{},{}); mask:{}, damp:{}\n", pos.x, pos.y, pos.z,

damp_mask->getassignment(pos), is_damp(pos));

if (damp_mask->getassignment(pos) && is_damp(pos)) {

DEBUG(log,out).print("revealing damp dig tile at ({},{},{})\n", pos.x, pos.y, pos.z);

block->designation[pos.x&15][pos.y&15].bits.hidden = false;

}

}

df::job *job = (df::job *)job_ptr;

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

if (type != job_type_class::Digging)

return;

const auto & pos = job->pos;

TRACE(log,out).print("handing dig job at ({},{},{})\n", pos.x, pos.y, pos.z);

process_taken_dig_job(out, pos);

unhide_tagged(out, pos + df::coord(-1, -1, 0));

unhide_tagged(out, pos + df::coord( 0, -1, 0));

unhide_tagged(out, pos + df::coord( 1, -1, 0));

unhide_tagged(out, pos + df::coord(-1, 0, 0));

unhide_tagged(out, pos + df::coord( 1, 0, 0));

unhide_tagged(out, pos + df::coord(-1, 1, 0));

unhide_tagged(out, pos + df::coord( 0, 1, 0));

unhide_tagged(out, pos + df::coord( 1, 1, 0));

switch (job->job_type) {

case df::job_type::CarveUpDownStaircase:

unhide_tagged(out, pos + df::coord(0, 0, -1));

unhide_tagged(out, pos + df::coord(0, 0, 1));

break;

case df::job_type::CarveDownwardStaircase:

unhide_tagged(out, pos + df::coord(0, 0, -1));

break;

case df::job_type::CarveUpwardStaircase:

unhide_tagged(out, pos + df::coord(0, 0, 1));

break;

case df::job_type::DigChannel:

unhide_tagged(out, pos + df::coord(-1, -1, -1));

unhide_tagged(out, pos + df::coord( 0, -1, -1));

unhide_tagged(out, pos + df::coord( 1, -1, -1));

unhide_tagged(out, pos + df::coord(-1, 0, -1));

unhide_tagged(out, pos + df::coord( 1, 0, -1));

unhide_tagged(out, pos + df::coord(-1, 1, -1));

unhide_tagged(out, pos + df::coord( 0, 1, -1));

unhide_tagged(out, pos + df::coord( 1, 1, -1));

break;

case df::job_type::CarveRamp:

unhide_tagged(out, pos + df::coord(-1, -1, 1));

unhide_tagged(out, pos + df::coord( 0, -1, 1));

unhide_tagged(out, pos + df::coord( 1, -1, 1));

unhide_tagged(out, pos + df::coord(-1, 0, 1));

unhide_tagged(out, pos + df::coord( 1, 0, 1));

unhide_tagged(out, pos + df::coord(-1, 1, 1));

unhide_tagged(out, pos + df::coord( 0, 1, 1));

unhide_tagged(out, pos + df::coord( 1, 1, 1));

break;

default:

break;

}

const std::string& s,

std::ios_base& (*f)(std::ios_base&))

{

std::istringstream iss(s);

return !(iss >> f >> t).fail();

{

circle_set,

circle_unset,

circle_invert,

circle_what what,

df::tile_dig_designation type,

int32_t priority,

int32_t x, int32_t y, int32_t z,

int x_max, int y_max

)

{

DFCoord at (x,y,z);

auto b = MCache.BlockAt(at/16);

if(!b || !b->is_valid())

return false;

if(x == 0 || x == x_max * 16 - 1)

{

//out.print("not digging map border\n");

return false;

}

if(y == 0 || y == y_max * 16 - 1)

{

//out.print("not digging map border\n");

return false;

}

df::tiletype tt = MCache.tiletypeAt(at);

df::tile_designation des = MCache.designationAt(at);

// could be potentially used to locate hidden constructions?

if(tileMaterial(tt) == tiletype_material::CONSTRUCTION && !des.bits.hidden)

return false;

df::tiletype_shape ts = tileShape(tt);

if (ts == tiletype_shape::EMPTY && !des.bits.hidden)

return false;

if(!des.bits.hidden)

{

do

{

df::tiletype_shape_basic tsb = ENUM_ATTR(tiletype_shape, basic_shape, ts);

if(tsb == tiletype_shape_basic::Wall)

{

//std::cerr << "allowing tt" << (int)tt << ", is wall\n";

break;

}

if (tsb == tiletype_shape_basic::Floor

&& (type == tile_dig_designation::DownStair || type == tile_dig_designation::Channel)

&& ts != tiletype_shape::BRANCH

&& ts != tiletype_shape::TRUNK_BRANCH

&& ts != tiletype_shape::TWIG

)

{

//std::cerr << "allowing tt" << (int)tt << ", is floor\n";

break;

}

if (tsb == tiletype_shape_basic::Stair && type == tile_dig_designation::Channel )

break;

return false;

}

while(0);

}

switch(what)

{

case circle_set:

if(des.bits.dig == tile_dig_designation::No)

{

des.bits.dig = type;

}

break;

case circle_unset:

if (des.bits.dig != tile_dig_designation::No)

{

des.bits.dig = tile_dig_designation::No;

}

break;

case circle_invert:

if(des.bits.dig == tile_dig_designation::No)

{

des.bits.dig = type;

}

else

{

des.bits.dig = tile_dig_designation::No;

}

break;

}

//std::cerr << "allowing tt" << (int)tt << "\n";

MCache.setDesignationAt(at,des,priority);

return true;

circle_what what,

df::tile_dig_designation type,

int32_t priority,

int32_t y1, int32_t y2, int32_t x, int32_t z,

int x_max, int y_max

)

{

for(int32_t y = y1; y <= y2; y++)

{

dig(MCache, what, type, priority, x,y,z, x_max, y_max);

}

return true;

circle_what what,

df::tile_dig_designation type,

int32_t priority,

int32_t x1, int32_t x2, int32_t y, int32_t z,

int x_max, int y_max

)

{

for(int32_t x = x1; x <= x2; x++)

{

dig(MCache, what, type, priority, x,y,z, x_max, y_max);

}

return true;

{

int32_t default_priority = game->main_interface.designation.priority;

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

{

const string &s = *it;

if (s.substr(0, 2) == "p=" || s.substr(0, 2) == "-p")

{

if (s.size() >= 3)

{

auto priority = int32_t(1000 * atof(s.c_str() + 2));

parameters.erase(it);

return priority;

}

else if (it + 1 != parameters.end())

{

auto priority = int32_t(1000 * atof((*(it + 1)).c_str()));

parameters.erase(it, it + 2);

return priority;

}

else

{

out.printerr("invalid priority specified; reverting to {}\n", default_priority);

break;

}

}

}

return default_priority;

{

static bool filled = false;

static circle_what what = circle_set;

static df::tile_dig_designation type = tile_dig_designation::Default;

static int diameter = 0;

auto saved_d = diameter;

bool force_help = false;

int32_t priority = parse_priority(out, parameters);

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

{

if(parameters[i] == "help" || parameters[i] == "?")

{

force_help = true;

}

else if(parameters[i] == "hollow")

{

filled = false;

}

else if(parameters[i] == "filled")

{

filled = true;

}

else if(parameters[i] == "set")

{

what = circle_set;

}

else if(parameters[i] == "unset")

{

what = circle_unset;

}

else if(parameters[i] == "invert")

{

what = circle_invert;

}

else if(parameters[i] == "dig")

{

type = tile_dig_designation::Default;

}

else if(parameters[i] == "ramp")

{

type = tile_dig_designation::Ramp;

}

else if(parameters[i] == "dstair")

{

type = tile_dig_designation::DownStair;

}

else if(parameters[i] == "ustair")

{

type = tile_dig_designation::UpStair;

}

else if(parameters[i] == "xstair")

{

type = tile_dig_designation::UpDownStair;

}

else if(parameters[i] == "chan")

{

type = tile_dig_designation::Channel;

}

else if (!from_string(diameter,parameters[i], std::dec))

{

diameter = saved_d;

}

}

if(diameter < 0)

diameter = -diameter;

if(force_help || diameter == 0)

{

out.print(

"A command for easy designation of filled and hollow circles.\n"

"\n"

"Options:\n"

" hollow = Set the circle to hollow (default)\n"

" filled = Set the circle to filled\n"

"\n"

" set = set designation\n"

" unset = unset current designation\n"

" invert = invert current designation\n"

"\n"

" dig = normal digging\n"

" ramp = ramp digging\n"

" ustair = staircase up\n"

" dstair = staircase down\n"

" xstair = staircase up/down\n"

" chan = dig channel\n"

"\n"

" # = diameter in tiles (default = 0)\n"

" -p # = designation priority (default = 4)\n"

"\n"

"After you have set the options, the command called with no options\n"

"repeats with the last selected parameters:\n"

"'digcircle filled 3' = Dig a filled circle with diameter = 3.\n"

"'digcircle' = Do it again.\n"

);

return CR_OK;

}

int32_t cx, cy, cz;

if (!Maps::IsValid())

{

out.printerr("Map is not available!\n");

return CR_FAILURE;

}

uint32_t x_max, y_max, z_max;

Maps::getSize(x_max,y_max,z_max);

MapExtras::MapCache MCache;

if(!Gui::getCursorCoords(cx,cy,cz) || cx == -30000)

{

out.printerr("Can't get the cursor coords...\n");

return CR_FAILURE;

}

int r = diameter / 2;

int iter;

bool adjust;

if(diameter % 2)

{

// paint center

if(filled)

{

lineY(MCache, what, type, priority, cx - r, cx + r, cy, cz, x_max, y_max);

}

else

{

dig(MCache, what, type, priority, cx - r, cy, cz, x_max, y_max);

dig(MCache, what, type, priority, cx + r, cy, cz, x_max, y_max);

}

adjust = false;

iter = 2;

}

else

{

adjust = true;

iter = 1;

}

int lastwhole = r;

for(; iter <= diameter - 1; iter +=2)

{

// top, bottom coords

int top = cy - ((iter + 1) / 2) + adjust;

int bottom = cy + ((iter + 1) / 2);

// see where the current 'line' intersects the circle

double val = std::sqrt(double(diameter*diameter - iter*iter));

// adjust for circles with odd diameter

if(!adjust)

val -= 1;

// map the found value to the DF grid

double whole;

double fraction = std::modf(val / 2.0, & whole);

if (fraction > 0.5)

whole += 1.0;

int right = cx + whole;

int left = cx - whole + adjust;

int diff = lastwhole - whole;

// paint

if(filled || iter == diameter - 1)

{

lineY(MCache, what, type, priority, left, right, top, cz, x_max, y_max);

lineY(MCache, what, type, priority, left, right, bottom, cz, x_max, y_max);

}

else

{

dig(MCache, what, type, priority, left, top, cz, x_max, y_max);

dig(MCache, what, type, priority, left, bottom, cz, x_max, y_max);

dig(MCache, what, type, priority, right, top, cz, x_max, y_max);

dig(MCache, what, type, priority, right, bottom, cz, x_max, y_max);

}

if(!filled && diff > 1)

{

int lright = cx + lastwhole;

int lleft = cx - lastwhole + adjust;

lineY(MCache, what, type, priority, lleft + 1, left - 1, top + 1 , cz, x_max, y_max);

lineY(MCache, what, type, priority, right + 1, lright - 1, top + 1 , cz, x_max, y_max);

lineY(MCache, what, type, priority, lleft + 1, left - 1, bottom - 1 , cz, x_max, y_max);

lineY(MCache, what, type, priority, right + 1, lright - 1, bottom - 1 , cz, x_max, y_max);

}

lastwhole = whole;

}

MCache.WriteAll();

return CR_OK;