{

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;

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 %i\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;

CoreSuspender suspend;

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;