MetzNet
/
dfhack
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fixed line endings (visual studio bugged me about it)

develop
mizipzor 2010-02-19 18:17:58 +01:00
parent b81d6d6744
commit 53d32e6076
1 changed files with 297 additions and 290 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

587
tools/digger.cpp
Unescape Escape View File

@ -1,39 +1,40 @@
// digger.cpp // digger.cpp
// Usage: Call with a list of TileClass ids separated by a space, // Usage: Call with a list of TileClass ids separated by a space,
// every (visible) tile on the map with that id will be designated for digging. // every (visible) tile on the map with that id will be designated for digging.
// NOTE currently only works with trees // NOTE currently only works with trees
// TODO add a sort of "sub-target" to dig() to make it able to designate stone as well // TODO add a sort of "sub-target" to dig() to make it able to designate stone as well
// TODO add proper cli // TODO add proper cli
// TODO add interactive text based menu // TODO add interactive text based menu
// TODO add ability to mark num closest to cursor // TODO add ability to mark num closest to cursor
#include <iostream> #include <iostream>
#include <integers.h> #include <integers.h>
#include <vector> #include <vector>
#include <list> #include <list>
#include <cstdlib> #include <cstdlib>
#include <algorithm> #include <algorithm>
#include <assert.h> #include <assert.h>
using namespace std; using namespace std;
#include <DFTypes.h> #include <DFTypes.h>
#include <DFTileTypes.h> #include <DFTileTypes.h>
#include <DFHackAPI.h> #include <DFHackAPI.h>
#include <gopt/gopt.h>
// counts the occurances of a certain element in a vector
int vec_count(vector<uint16_t>& vec, uint16_t t) // counts the occurances of a certain element in a vector
{ int vec_count(vector<uint16_t>& vec, uint16_t t)
int count = 0; {
for (uint32_t i = 0; i < vec.size(); ++i) int count = 0;
{ for (uint32_t i = 0; i < vec.size(); ++i)
if (vec[i] == t) {
++count; if (vec[i] == t)
} ++count;
return count; }
} return count;
}
// splits a string on a certain char // splits a string on a certain char
// //
@ -52,257 +53,263 @@ void string_split(vector<string>& tokens, const std::string& src, const std::str
break; break;
start = end + delim.size(); // skip next delim start = end + delim.size(); // skip next delim
} }
} }
// calculates the manhattan distance between two coords // calculates the manhattan distance between two coords
int manhattan_distance(int x, int y, int z, int xx, int yy, int zz) int manhattan_distance(int x, int y, int z, int xx, int yy, int zz)
{ {
return abs(x-xx)+abs(y-yy)+abs(z-zz); return abs(x-xx)+abs(y-yy)+abs(z-zz);
} }
struct DigTarget struct DigTarget
{ {
DigTarget() : DigTarget() :
source_distance(0), source_distance(0),
grid_x(0), grid_y(0), grid_x(0), grid_y(0),
local_x(0), local_y(0), local_x(0), local_y(0),
real_x(0), real_y(0), z(0) real_x(0), real_y(0), z(0)
{ {
} }
DigTarget( DigTarget(
int realx, int realy, int _z, int realx, int realy, int _z,
int sourcex, int sourcey, int sourcez) : int sourcex, int sourcey, int sourcez) :
real_x(realx), real_y(realy), z(_z) real_x(realx), real_y(realy), z(_z)
{ {
grid_x = realx/16; grid_x = realx/16;
grid_y = realy/16; grid_y = realy/16;
local_x = realx%16; local_x = realx%16;
local_y = realy%16; local_y = realy%16;
source_distance = manhattan_distance( source_distance = manhattan_distance(
real_x, real_y, z, real_x, real_y, z,
sourcex, sourcey, sourcez); sourcex, sourcey, sourcez);
} }
DigTarget( DigTarget(
int gridx, int gridy, int _z, int gridx, int gridy, int _z,
int localx, int localy, int localx, int localy,
int sourcex, int sourcey, int sourcez) : int sourcex, int sourcey, int sourcez) :
grid_x(gridx), grid_y(gridy), grid_x(gridx), grid_y(gridy),
local_x(localx), local_y(localy), local_x(localx), local_y(localy),
z(_z) z(_z)
{ {
real_x = (grid_x*16)+local_x; real_x = (grid_x*16)+local_x;
real_y = (grid_y*16)+local_y; real_y = (grid_y*16)+local_y;
source_distance = manhattan_distance( source_distance = manhattan_distance(
real_x, real_y, z, real_x, real_y, z,
sourcex, sourcey, sourcez); sourcex, sourcey, sourcez);
} }
int source_distance; // the distance to the source coords, used for sorting int source_distance; // the distance to the source coords, used for sorting
int grid_x, grid_y; int grid_x, grid_y;
int local_x, local_y; int local_x, local_y;
int real_x, real_y; int real_x, real_y;
int z; int z;
bool operator<(const DigTarget& o) const { return source_distance < o.source_distance; } bool operator<(const DigTarget& o) const { return source_distance < o.source_distance; }
}; };
int dig(DFHack::API& DF, int dig(DFHack::API& DF,
vector<uint16_t>& targets, vector<uint16_t>& targets,
int num = -1, int num = -1,
const int x_source = 0, const int x_source = 0,
const int y_source = 0, const int y_source = 0,
const int z_source = 0) const int z_source = 0)
{ {
if (num == 0) if (num == 0)
return 0; // max limit of 0, nothing to do return 0; // max limit of 0, nothing to do
uint32_t x_max,y_max,z_max; uint32_t x_max,y_max,z_max;
DFHack::t_designation designations[16][16]; DFHack::t_designation designations[16][16];
uint16_t tiles[16][16]; uint16_t tiles[16][16];
DF.getSize(x_max,y_max,z_max); DF.getSize(x_max,y_max,z_max);
// every tile found, will later be sorted by distance to source // every tile found, will later be sorted by distance to source
vector<DigTarget> candidates; vector<DigTarget> candidates;
//cout << "============================" << endl; //cout << "============================" << endl;
//cout << "source is " << x_source << " " << y_source << " " << z_source << endl; //cout << "source is " << x_source << " " << y_source << " " << z_source << endl;
// walk the map // walk the map
for(uint32_t x = 0; x < x_max; x++) for(uint32_t x = 0; x < x_max; x++)
{ {
for(uint32_t y = 0; y < y_max; y++) for(uint32_t y = 0; y < y_max; y++)
{ {
for(uint32_t z = 0; z < z_max; z++) for(uint32_t z = 0; z < z_max; z++)
{ {
if(DF.isValidBlock(x,y,z)) if(DF.isValidBlock(x,y,z))
{ {
// read block designations and tiletype // read block designations and tiletype
DF.ReadDesignations(x,y,z, (uint32_t *) designations); DF.ReadDesignations(x,y,z, (uint32_t *) designations);
DF.ReadTileTypes(x,y,z, (uint16_t *) tiles); DF.ReadTileTypes(x,y,z, (uint16_t *) tiles);
// search all tiles for dig targets: // search all tiles for dig targets:
// visible, not yet marked for dig and matching tile type // visible, not yet marked for dig and matching tile type
for(uint32_t lx = 0; lx < 16; lx++) for(uint32_t lx = 0; lx < 16; lx++)
{ {
for(uint32_t ly = 0; ly < 16; ly++) for(uint32_t ly = 0; ly < 16; ly++)
{ {
if (designations[lx][ly].bits.hidden == 0 && if (designations[lx][ly].bits.hidden == 0 &&
designations[lx][ly].bits.dig == 0 && designations[lx][ly].bits.dig == 0 &&
vec_count(targets, DFHack::tileTypeTable[tiles[lx][ly]].c) > 0) vec_count(targets, DFHack::tileTypeTable[tiles[lx][ly]].c) > 0)
{ {
candidates.push_back(DigTarget( candidates.push_back(DigTarget(
x, y, z, x, y, z,
lx, ly, lx, ly,
x_source, y_source, z_source)); x_source, y_source, z_source));
//cout << "target found at " << world_x << " " << world_y << " " << z; //cout << "target found at " << world_x << " " << world_y << " " << z;
//cout << ", " << dt->source_distance << " tiles to source" << endl; //cout << ", " << dt->source_distance << " tiles to source" << endl;
} }
} // local y } // local y
} // local x } // local x
} }
} }
} }
} }
// if we found more tiles than was requested, sort them by distance to source, // if we found more tiles than was requested, sort them by distance to source,
// keep the front 'num' elements and drop the rest // keep the front 'num' elements and drop the rest
if (num != -1 && candidates.size() > (unsigned int)num) if (num != -1 && candidates.size() > (unsigned int)num)
{ {
sort(candidates.begin(), candidates.end()); sort(candidates.begin(), candidates.end());
candidates.resize(num); candidates.resize(num);
} }
num = candidates.size(); num = candidates.size();
//cout << "============================" << endl; //cout << "============================" << endl;
//cout << "source is " << x_source << " " << y_source << " " << z_source << endl; //cout << "source is " << x_source << " " << y_source << " " << z_source << endl;
// mark the tiles for actual digging // mark the tiles for actual digging
for (vector<DigTarget>::const_iterator i = candidates.begin(); i != candidates.end(); ++i) for (vector<DigTarget>::const_iterator i = candidates.begin(); i != candidates.end(); ++i)
{ {
//cout << "designating at " << (*i).real_x << " " << (*i).real_y << " " << (*i).z; //cout << "designating at " << (*i).real_x << " " << (*i).real_y << " " << (*i).z;
//cout << ", " << (*i).source_distance << " tiles to source" << endl; //cout << ", " << (*i).source_distance << " tiles to source" << endl;
// TODO this could probably be made much better, theres a big chance the trees are on the same grid // TODO this could probably be made much better, theres a big chance the trees are on the same grid
// TODO move into function in DigTarget // TODO move into function in DigTarget
DF.ReadDesignations((*i).grid_x, (*i).grid_y, (*i).z, (uint32_t *) designations); DF.ReadDesignations((*i).grid_x, (*i).grid_y, (*i).z, (uint32_t *) designations);
designations[(*i).local_x][(*i).local_y].bits.dig = DFHack::designation_default; designations[(*i).local_x][(*i).local_y].bits.dig = DFHack::designation_default;
DF.WriteDesignations((*i).grid_x, (*i).grid_y, (*i).z, (uint32_t *) designations); DF.WriteDesignations((*i).grid_x, (*i).grid_y, (*i).z, (uint32_t *) designations);
} }
return num; return num;
} }
void test() void test()
{ {
////////////////////////// //////////////////////////
// DigTarget // DigTarget
{ {
DigTarget dt( DigTarget dt(
20, 35, 16, 20, 35, 16,
10, 12, 14); 10, 12, 14);
assert(dt.grid_x == 1); assert(dt.grid_x == 1);
assert(dt.grid_y == 2); assert(dt.grid_y == 2);
assert(dt.local_x == 4); assert(dt.local_x == 4);
assert(dt.local_y == 3); assert(dt.local_y == 3);
assert(dt.real_x == 20); assert(dt.real_x == 20);
assert(dt.real_y == 35); assert(dt.real_y == 35);
assert(dt.z == 16); assert(dt.z == 16);
assert(dt.source_distance == 35); assert(dt.source_distance == 35);
} }
{ {
DigTarget dt( DigTarget dt(
2, 4, 16, 2, 4, 16,
5, 10, 5, 10,
10, 12, 14); 10, 12, 14);
assert(dt.grid_x == 2); assert(dt.grid_x == 2);
assert(dt.grid_y == 4); assert(dt.grid_y == 4);
assert(dt.local_x == 5); assert(dt.local_x == 5);
assert(dt.local_y == 10); assert(dt.local_y == 10);
assert(dt.real_x == 37); assert(dt.real_x == 37);
assert(dt.real_y == 74); assert(dt.real_y == 74);
assert(dt.z == 16); assert(dt.z == 16);
assert(dt.source_distance == 91); assert(dt.source_distance == 91);
} }
////////////////////////// //////////////////////////
// string splitter // string splitter
{ {
vector<string> tokens; vector<string> tokens;
string src = "10,9,11"; string src = "10,9,11";
string delim = ","; string delim = ",";
string_split(tokens, src, delim); string_split(tokens, src, delim);
assert(tokens.size() == 3); assert(tokens.size() == 3);
assert(tokens[0] == "10"); assert(tokens[0] == "10");
assert(tokens[1] == "9"); assert(tokens[1] == "9");
assert(tokens[2] == "11"); assert(tokens[2] == "11");
} }
{ {
vector<string> tokens; vector<string> tokens;
string src = "10"; string src = "10";
string delim = ","; string delim = ",";
string_split(tokens, src, delim); string_split(tokens, src, delim);
assert(tokens.size() == 1); assert(tokens.size() == 1);
assert(tokens[0] == "10"); assert(tokens[0] == "10");
} }
} }
int main (int argc, const char* argv[]) int main (int argc, const char* argv[])
{ {
test(); test();
void *options= gopt_sort( & argc, argv, gopt_start(
vector<uint16_t> targets; gopt_option( 'h', 0, gopt_shorts( 'h', '?' ), gopt_longs( "help", "HELP" )),
for (int i = 1; i < argc; ++i) gopt_option( 'z', 0, gopt_shorts( 0 ), gopt_longs( "version" )),
{ gopt_option( 'v', GOPT_REPEAT, gopt_shorts( 'v' ), gopt_longs( "verbose" )),
targets.push_back(atoi(argv[i])); gopt_option( 'o', GOPT_ARG, gopt_shorts( 'o' ), gopt_longs( "output" ))));
}
if (targets.size() == 0)
{ vector<uint16_t> targets;
cout << "Usage: Call with a list of TileClass ids separated by a space,\n"; for (int i = 1; i < argc; ++i)
cout << "every (visible) tile on the map with that id will be designated for digging.\n\n"; {
} targets.push_back(atoi(argv[i]));
else }
{ if (targets.size() == 0)
DFHack::API DF("Memory.xml"); {
if(!DF.Attach()) cout << "Usage: Call with a list of TileClass ids separated by a space,\n";
{ cout << "every (visible) tile on the map with that id will be designated for digging.\n\n";
cerr << "DF not found" << endl; }
return 1; else
} {
DF.InitMap(); DFHack::API DF("Memory.xml");
if(!DF.Attach())
// TODO hack until we have a proper cli to specify origin {
int x_source = 134, y_source = 134, z_source = 16; // my wagon starts here; cut trees close to wagon cerr << "DF not found" << endl;
//DF.InitViewAndCursor(); return 1;
//if (!DF.getViewCoords(x_source, y_source, z_source)) }
//{ DF.InitMap();
// cerr << "Enable cursor" << endl;
// return 1; // TODO hack until we have a proper cli to specify origin
//} int x_source = 134, y_source = 134, z_source = 16; // my wagon starts here; cut trees close to wagon
//DF.InitViewAndCursor();
int count = dig(DF, targets, 10, x_source, y_source, z_source); // <-- important part //if (!DF.getViewCoords(x_source, y_source, z_source))
cout << count << " targets designated" << endl; //{
// cerr << "Enable cursor" << endl;
DF.Detach(); // return 1;
} //}
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl; int count = dig(DF, targets, 10, x_source, y_source, z_source); // <-- important part
cin.ignore(); cout << count << " targets designated" << endl;
#endif
return 0; DF.Detach();
} }
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl;
cin.ignore();
#endif
return 0;
}