303 lines
8.1 KiB
C++
303 lines
8.1 KiB
C++
#pragma once
|
|
#include <llimits.h>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <stack>
|
|
#include <set>
|
|
|
|
typedef vector <df::coord> coord_vec;
|
|
class Brush
|
|
{
|
|
public:
|
|
virtual ~Brush(){};
|
|
virtual coord_vec points(MapExtras::MapCache & mc,DFHack::DFCoord start) = 0;
|
|
virtual std::string str() const {
|
|
return "unknown";
|
|
}
|
|
};
|
|
/**
|
|
* generic 3D rectangle brush. you can specify the dimensions of
|
|
* the rectangle and optionally which tile is its 'center'
|
|
*/
|
|
class RectangleBrush : public Brush
|
|
{
|
|
public:
|
|
RectangleBrush(int x, int y, int z = 1, int centerx = -1, int centery = -1, int centerz = -1)
|
|
{
|
|
if(centerx == -1)
|
|
cx_ = x/2;
|
|
else
|
|
cx_ = centerx;
|
|
if(centery == -1)
|
|
cy_ = y/2;
|
|
else
|
|
cy_ = centery;
|
|
if(centerz == -1)
|
|
cz_ = z/2;
|
|
else
|
|
cz_ = centerz;
|
|
x_ = x;
|
|
y_ = y;
|
|
z_ = z;
|
|
};
|
|
coord_vec points(MapExtras::MapCache & mc, DFHack::DFCoord start)
|
|
{
|
|
coord_vec v;
|
|
DFHack::DFCoord iterstart(start.x - cx_, start.y - cy_, start.z - cz_);
|
|
DFHack::DFCoord iter = iterstart;
|
|
for(int xi = 0; xi < x_; xi++)
|
|
{
|
|
for(int yi = 0; yi < y_; yi++)
|
|
{
|
|
for(int zi = 0; zi < z_; zi++)
|
|
{
|
|
if(mc.testCoord(iter))
|
|
v.push_back(iter);
|
|
iter.z++;
|
|
}
|
|
iter.z = iterstart.z;
|
|
iter.y++;
|
|
}
|
|
iter.y = iterstart.y;
|
|
iter.x ++;
|
|
}
|
|
return v;
|
|
};
|
|
~RectangleBrush(){};
|
|
std::string str() const {
|
|
if (x_ == 1 && y_ == 1 && z_ == 1)
|
|
{
|
|
return "point";
|
|
}
|
|
else
|
|
{
|
|
std::ostringstream ss;
|
|
ss << "rect: " << x_ << "/" << y_ << "/" << z_ << std::endl;
|
|
return ss.str();
|
|
}
|
|
}
|
|
private:
|
|
int x_, y_, z_;
|
|
int cx_, cy_, cz_;
|
|
};
|
|
|
|
/**
|
|
* stupid block brush, legacy. use when you want to apply something to a whole DF map block.
|
|
*/
|
|
class BlockBrush : public Brush
|
|
{
|
|
public:
|
|
BlockBrush(){};
|
|
~BlockBrush(){};
|
|
coord_vec points(MapExtras::MapCache & mc, DFHack::DFCoord start)
|
|
{
|
|
coord_vec v;
|
|
DFHack::DFCoord blockc = start / 16;
|
|
DFHack::DFCoord iterc = blockc * 16;
|
|
if( !mc.testCoord(start) )
|
|
return v;
|
|
auto starty = iterc.y;
|
|
for(int xi = 0; xi < 16; xi++)
|
|
{
|
|
for(int yi = 0; yi < 16; yi++)
|
|
{
|
|
v.push_back(iterc);
|
|
iterc.y++;
|
|
}
|
|
iterc.y = starty;
|
|
iterc.x ++;
|
|
}
|
|
return v;
|
|
};
|
|
std::string str() const {
|
|
return "block";
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Column from a position through open space tiles
|
|
* example: create a column of magma
|
|
*/
|
|
class ColumnBrush : public Brush
|
|
{
|
|
public:
|
|
ColumnBrush(){};
|
|
~ColumnBrush(){};
|
|
coord_vec points(MapExtras::MapCache & mc, DFHack::DFCoord start)
|
|
{
|
|
coord_vec v;
|
|
bool juststarted = true;
|
|
while (mc.testCoord(start))
|
|
{
|
|
df::tiletype tt = mc.tiletypeAt(start);
|
|
if(DFHack::LowPassable(tt) || (juststarted && DFHack::HighPassable(tt)))
|
|
{
|
|
v.push_back(start);
|
|
juststarted = false;
|
|
start.z++;
|
|
}
|
|
else break;
|
|
}
|
|
return v;
|
|
};
|
|
std::string str() const {
|
|
return "column";
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Flood-fill water tiles from cursor (for wclean)
|
|
* example: remove salt flag from a river
|
|
*/
|
|
class FloodBrush : public Brush
|
|
{
|
|
public:
|
|
FloodBrush(DFHack::Core *c){c_ = c;};
|
|
~FloodBrush(){};
|
|
coord_vec points(MapExtras::MapCache & mc, DFHack::DFCoord start)
|
|
{
|
|
using namespace DFHack;
|
|
coord_vec v;
|
|
|
|
std::stack<DFCoord> to_flood;
|
|
to_flood.push(start);
|
|
|
|
std::set<DFCoord> seen;
|
|
|
|
while (!to_flood.empty()) {
|
|
DFCoord xy = to_flood.top();
|
|
to_flood.pop();
|
|
|
|
df::tile_designation des = mc.designationAt(xy);
|
|
|
|
if (seen.find(xy) == seen.end()
|
|
&& des.bits.flow_size
|
|
&& des.bits.liquid_type == tile_liquid::Water) {
|
|
v.push_back(xy);
|
|
seen.insert(xy);
|
|
|
|
maybeFlood(DFCoord(xy.x - 1, xy.y, xy.z), to_flood, mc);
|
|
maybeFlood(DFCoord(xy.x + 1, xy.y, xy.z), to_flood, mc);
|
|
maybeFlood(DFCoord(xy.x, xy.y - 1, xy.z), to_flood, mc);
|
|
maybeFlood(DFCoord(xy.x, xy.y + 1, xy.z), to_flood, mc);
|
|
|
|
df::tiletype tt = mc.tiletypeAt(xy);
|
|
if (LowPassable(tt))
|
|
{
|
|
maybeFlood(DFCoord(xy.x, xy.y, xy.z - 1), to_flood, mc);
|
|
}
|
|
if (HighPassable(tt))
|
|
{
|
|
maybeFlood(DFCoord(xy.x, xy.y, xy.z + 1), to_flood, mc);
|
|
}
|
|
}
|
|
}
|
|
|
|
return v;
|
|
}
|
|
std::string str() const {
|
|
return "flood";
|
|
}
|
|
private:
|
|
void maybeFlood(DFHack::DFCoord c, std::stack<DFHack::DFCoord> &to_flood,
|
|
MapExtras::MapCache &mc) {
|
|
if (mc.testCoord(c)) {
|
|
to_flood.push(c);
|
|
}
|
|
}
|
|
DFHack::Core *c_;
|
|
};
|
|
|
|
DFHack::command_result parseRectangle(DFHack::color_ostream & out,
|
|
vector<string> & input, int start, int end,
|
|
int & width, int & height, int & zLevels,
|
|
bool hasConsole = true)
|
|
{
|
|
using namespace DFHack;
|
|
int newWidth = 0, newHeight = 0, newZLevels = 0, rv = 0;
|
|
|
|
if (end > start + 1)
|
|
{
|
|
newWidth = atoi(input[start++].c_str());
|
|
newHeight = atoi(input[start++].c_str());
|
|
if (end > start) {
|
|
newZLevels = atoi(input[start++].c_str());
|
|
} else {
|
|
newZLevels = 1; // So 'range w h' won't ask for it.
|
|
}
|
|
}
|
|
|
|
string command = "";
|
|
std::stringstream str;
|
|
CommandHistory hist;
|
|
|
|
if (newWidth < 1) {
|
|
if (hasConsole) {
|
|
Console &con = static_cast<Console&>(out);
|
|
|
|
str.str("");
|
|
str << "Set range width <" << width << "> ";
|
|
while ((rv = con.lineedit(str.str(), command, hist))
|
|
== Console::RETRY);
|
|
if (rv <= Console::FAILURE)
|
|
return rv == Console::FAILURE ? CR_FAILURE : CR_FAILURE;
|
|
hist.add(command);
|
|
newWidth = command.empty() ? width : atoi(command.c_str());
|
|
} else {
|
|
return CR_WRONG_USAGE;
|
|
}
|
|
}
|
|
|
|
if (newHeight < 1) {
|
|
if (hasConsole) {
|
|
Console &con = static_cast<Console&>(out);
|
|
|
|
str.str("");
|
|
str << "Set range height <" << height << "> ";
|
|
while ((rv = con.lineedit(str.str(), command, hist))
|
|
== Console::RETRY);
|
|
if (rv <= Console::FAILURE)
|
|
return rv == Console::FAILURE ? CR_FAILURE : CR_OK;
|
|
hist.add(command);
|
|
newHeight = command.empty() ? height : atoi(command.c_str());
|
|
} else {
|
|
return CR_WRONG_USAGE;
|
|
}
|
|
}
|
|
|
|
if (newZLevels < 1) {
|
|
if (hasConsole) {
|
|
Console &con = static_cast<Console&>(out);
|
|
|
|
str.str("");
|
|
str << "Set range z-levels <" << zLevels << "> ";
|
|
while ((rv = con.lineedit(str.str(), command, hist))
|
|
== Console::RETRY);
|
|
if (rv <= Console::FAILURE)
|
|
return rv == Console::FAILURE ? CR_FAILURE : CR_OK;
|
|
hist.add(command);
|
|
newZLevels = command.empty() ? zLevels : atoi(command.c_str());
|
|
} else {
|
|
return CR_WRONG_USAGE;
|
|
}
|
|
}
|
|
|
|
width = newWidth < 1? 1 : newWidth;
|
|
height = newHeight < 1? 1 : newHeight;
|
|
zLevels = newZLevels < 1? 1 : newZLevels;
|
|
|
|
return CR_OK;
|
|
}
|
|
|
|
inline std::ostream &operator<<(std::ostream &stream, const Brush& brush)
|
|
{
|
|
stream << brush.str();
|
|
return stream;
|
|
}
|
|
|
|
inline std::ostream &operator<<(std::ostream &stream, const Brush* brush)
|
|
{
|
|
stream << brush->str();
|
|
return stream;
|
|
}
|