{

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. Use 'digexp ?' for help.",digexp));

commands.push_back(PluginCommand("digcircle","Dig designate a circle (filled or hollow) with given radius.",digcircle));

//commands.push_back(PluginCommand("digauto","Mark a tile for continuous digging.",autodig));

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 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)

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::TREE

)

{

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);

return true;

circle_what what,

df::tile_dig_designation type,

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,x,y,z, x_max, y_max);

}

return true;

circle_what what,

df::tile_dig_designation type,

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,x,y,z, x_max, y_max);

}

return true;

{

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;

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"

"\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 radius = 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, cx - r, cx + r, cy, cz,x_max,y_max);

}

else

{

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

dig(MCache, what, type,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, left, right, top , cz,x_max,y_max);

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

}

else

{

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

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

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

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

}

if(!filled && diff > 1)

{

int lright = cx + lastwhole;

int lleft = cx - lastwhole + adjust;

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

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

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

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

}

lastwhole = whole;

}

MCache.WriteAll();

return CR_OK;