{

commands.push_back(PluginCommand(

"digv","Dig a whole vein.",digv,Gui::cursor_hotkey,

" Designates a whole vein under the cursor for digging.\n"

"Options:\n"

" x - follow veins through z-levels with stairs.\n"

));

commands.push_back(PluginCommand(

"digvx","Dig a whole vein, following through z-levels.",digvx,Gui::cursor_hotkey,

" Designates a whole vein under the cursor for digging.\n"

" Also follows the vein between z-levels with stairs, like 'digv x' would.\n"

));

commands.push_back(PluginCommand(

"digl","Dig layerstone.",digl,Gui::cursor_hotkey,

" Designates layerstone under the cursor for digging.\n"

" Veins will not be touched.\n"

"Options:\n"

" x - follow layer through z-levels with stairs.\n"

" undo - clear designation (can be used together with 'x').\n"

));

commands.push_back(PluginCommand(

"diglx","Dig layerstone, following through z-levels.",diglx,Gui::cursor_hotkey,

" Designates layerstone under the cursor for digging.\n"

" Also follows the stone between z-levels with stairs, like 'digl x' would.\n"

));

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("digauto","Mark a tile for continuous digging.",autodig));

commands.push_back(PluginCommand("digtype", "Dig all veins of a given type.", digtype,Gui::cursor_hotkey,

"For every tile on the map of the same vein type as the selected tile, this command designates it to have the same designation as the selected tile. If the selected tile has no designation, they will be dig designated.\n"

"If an argument is given, the designation of the selected tile is ignored, and all appropriate tiles are set to the specified designation.\n"

"Options:\n"

" dig\n"

" channel\n"

" ramp\n"

" updown - up/down stairs\n"

" up - up stairs\n"

" down - down stairs\n"

" clear - clear designation\n"

));

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 = ui_sidebar_menus->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;