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

Fixed includes, unified formatting.

develop
Petr Mrázek 2010-10-25 04:39:14 +02:00
parent 36fb3a2c6a
commit 70cb93d9f4
5 changed files with 1722 additions and 1537 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

491
library/include/dfhack/DFTileTypes.h
Unescape Escape View File

@ -30,9 +30,9 @@ distribution.
namespace DFHack namespace DFHack
{ {
// tile class -- determines the general shape of the tile // tile class -- determines the general shape of the tile
// enum and lookup table for string names created using X macros // enum and lookup table for string names created using X macros
#define TILECLASS_MACRO \ #define TILECLASS_MACRO \
X(EMPTY, "") \ X(EMPTY, "") \
X(WALL, "") \ X(WALL, "") \
X(PILLAR, "") \ X(PILLAR, "") \
@ -51,32 +51,32 @@ namespace DFHack
X(SHRUB_OK, "") \ X(SHRUB_OK, "") \
X(BOULDER, "") \ X(BOULDER, "") \
X(PEBBLES, "") X(PEBBLES, "")
//end TILECLASS_MACRO //end TILECLASS_MACRO
//define tile class enum //define tile class enum
#define X(name,comment) name, #define X(name,comment) name,
enum TileClass { enum TileClass {
tileclass_invalid=-1, tileclass_invalid=-1,
TILECLASS_MACRO TILECLASS_MACRO
tileclass_count, tileclass_count,
}; };
#undef X #undef X
//Visual Studio screams if you don't do this for the const char* arrays //Visual Studio screams if you don't do this for the const char* arrays
#ifndef char_p #ifndef char_p
typedef char * char_p; typedef char * char_p;
#endif #endif
//set tile class string lookup table (e.g. for printing to user) //set tile class string lookup table (e.g. for printing to user)
#define X(name,comment) #name, #define X(name,comment) #name,
const char_p TileClassString[tileclass_count+1] = { const char_p TileClassString[tileclass_count+1] = {
TILECLASS_MACRO TILECLASS_MACRO
NULL 0
}; };
#undef X #undef X
#define TILEMATERIAL_MACRO \ #define TILEMATERIAL_MACRO \
X(AIR, "empty" ) \ X(AIR, "empty" ) \
X(SOIL, "ordinary soil. material depends on geology" ) \ X(SOIL, "ordinary soil. material depends on geology" ) \
X(STONE, "ordinary layer stone. material depends on geology" ) \ X(STONE, "ordinary layer stone. material depends on geology" ) \
@ -96,30 +96,30 @@ namespace DFHack
X(ASHES, "what remains from a FIRE" ) \ X(ASHES, "what remains from a FIRE" ) \
X(CONSTRUCTED,"tile material depends on the construction present" ) \ X(CONSTRUCTED,"tile material depends on the construction present" ) \
X(CYAN_GLOW, "the glowy stuff that disappears from the demon temple when you take the sword." ) X(CYAN_GLOW, "the glowy stuff that disappears from the demon temple when you take the sword." )
//end TILEMATERIAL_MACRO //end TILEMATERIAL_MACRO
// material enum // material enum
#define X(name,comment) name, #define X(name,comment) name,
enum TileMaterial { enum TileMaterial {
tilematerial_invalid=-1, tilematerial_invalid=-1,
TILEMATERIAL_MACRO TILEMATERIAL_MACRO
tilematerial_count, tilematerial_count,
}; };
#undef X #undef X
//string lookup table (e.g. for printing to user) //string lookup table (e.g. for printing to user)
#define X(name,comment) #name, #define X(name,comment) #name,
const char_p TileMaterialString[tilematerial_count+1] = { const char_p TileMaterialString[tilematerial_count+1] = {
TILEMATERIAL_MACRO TILEMATERIAL_MACRO
NULL 0
}; };
#undef X #undef X
// Special specials of the tile. // Special specials of the tile.
// Not the best way to do this, but compatible with existing code. // Not the best way to do this, but compatible with existing code.
// When the TileType class gets created, everything should be re-thought. // When the TileType class gets created, everything should be re-thought.
#define TILESPECIAL_MACRO \ #define TILESPECIAL_MACRO \
X(NORMAL, "Default for all type, nothing present" ) \ X(NORMAL, "Default for all type, nothing present" ) \
X(SPECIAL, "General purpose, for any unique tile which can not otherwise be differenciated" ) \ X(SPECIAL, "General purpose, for any unique tile which can not otherwise be differenciated" ) \
X(POOL, "Murky Pool, will gather water from rain" ) \ X(POOL, "Murky Pool, will gather water from rain" ) \
@ -133,129 +133,134 @@ namespace DFHack
X(DAMAGED, "Walls being dug" ) \ X(DAMAGED, "Walls being dug" ) \
X(WORN, "Walls being dug ??" ) \ X(WORN, "Walls being dug ??" ) \
X(SMOOTH, "Walls and floors." ) X(SMOOTH, "Walls and floors." )
//end TILESPECIAL_MACRO //end TILESPECIAL_MACRO
//special enum //special enum
#define X(name,comment) TILE_##name, #define X(name,comment) TILE_##name,
enum TileSpecial { enum TileSpecial {
tilespecial_invalid=-1, tilespecial_invalid=-1,
TILESPECIAL_MACRO TILESPECIAL_MACRO
tilespecial_count, tilespecial_count,
}; };
#undef X #undef X
//string lookup table (e.g. for printing to user) //string lookup table (e.g. for printing to user)
#define X(name,comment) #name, #define X(name,comment) #name,
const char_p TileSpecialString[tilespecial_count+1] = { const char_p TileSpecialString[tilespecial_count+1] = {
TILESPECIAL_MACRO TILESPECIAL_MACRO
NULL 0
}; };
#undef X #undef X
// variants are used for tiles, where there are multiple variants of the same - like grass floors // variants are used for tiles, where there are multiple variants of the same - like grass floors
enum TileVariant enum TileVariant
{ {
tilevariant_invalid=-1, tilevariant_invalid=-1,
VAR_1, //Yes, the value of VAR_1 is 0. It's legacy. Deal with it. VAR_1, //Yes, the value of VAR_1 is 0. It's legacy. Deal with it.
VAR_2, VAR_2,
VAR_3, VAR_3,
VAR_4, VAR_4,
}; };
//Mainly walls and rivers //Mainly walls and rivers
//Byte values are used because walls can have either 1 or 2 in any given direction. //Byte values are used because walls can have either 1 or 2 in any given direction.
const int TileDirectionCount = 4; const int TileDirectionCount = 4;
union TileDirection union TileDirection
{ {
uint32_t whole; uint32_t whole;
unsigned char b[TileDirectionCount]; unsigned char b[TileDirectionCount];
struct { struct
//Maybe should add 'up' and 'down' for Z-levels? {
unsigned char north,south,west,east; //Maybe should add 'up' and 'down' for Z-levels?
}; unsigned char north,south,west,east;
};
inline TileDirection()
{ inline TileDirection()
whole = 0; {
} whole = 0;
TileDirection( uint32_t whole_bits) }
{ TileDirection( uint32_t whole_bits)
whole = whole_bits; {
} whole = whole_bits;
TileDirection( unsigned char North, unsigned char South, unsigned char West, unsigned char East ) }
{ TileDirection( unsigned char North, unsigned char South, unsigned char West, unsigned char East )
north=North; south=South; east=East; west=West; {
} north=North; south=South; east=East; west=West;
TileDirection( const char *dir ) }
{ TileDirection( const char *dir )
//This one just made for fun. {
//Supports N S E W //This one just made for fun.
const char *p = dir; //Supports N S E W
unsigned char *l=NULL; const char *p = dir;
north=south=east=west=0; unsigned char *l=0;
if(!dir) return; north=south=east=west=0;
if(!dir) return;
for( ;*p;++p){
switch(*p){ for( ;*p;++p)
case 'N': //North / Up {
case 'n': switch(*p)
++north; l=&north; break; {
case 'S': //South / Down case 'N': //North / Up
case 's': case 'n':
++south; l=&south; break; ++north; l=&north; break;
case 'E': //East / Right case 'S': //South / Down
case 'e': case 's':
++east; l=&east; break; ++south; l=&south; break;
case 'W': //West / Left case 'E': //East / Right
case 'w': case 'e':
++west; l=&west; break; ++east; l=&east; break;
case '-': case 'W': //West / Left
case ' ': case 'w':
//Explicitly ensure dash and space are ignored. ++west; l=&west; break;
//Other characters/symbols may be assigned in the future. case '-':
break; case ' ':
default: //Explicitly ensure dash and space are ignored.
if( l && '0' <= *p && '9' >= *p ) //Other characters/symbols may be assigned in the future.
*l += *p - '0'; break;
break; default:
} if( l && '0' <= *p && '9' >= *p )
} *l += *p - '0';
} break;
}
//may be useful for some situations }
inline uint32_t sum() const { }
return 0L + north + south + east + west;
} //may be useful for some situations
inline uint32_t sum() const
//Gives a string that represents the direction. {
//This is a static string, overwritten with every call! return 0L + north + south + east + west;
//Support values > 2 even though they should never happen. }
//Copy string if it will be used.
inline char * getStr() const { //Gives a string that represents the direction.
static char str[16]; //This is a static string, overwritten with every call!
//type punning trick //Support values > 2 even though they should never happen.
*( (uint64_t *)str ) = *( (uint64_t *)"--------" ); //Copy string if it will be used.
str[8]=0; inline char * getStr() const
#define DIRECTION(x,i,c) \ {
if(x){ \ static char str[16];
str[i]=c; \ //type punning trick
if(1==x) ; \ *( (uint64_t *)str ) = *( (uint64_t *)"--------" );
else if(2==x) str[i+1]=c; \ str[8]=0;
else str[i+1]='0'+x; \ #define DIRECTION(x,i,c) \
} if(x){ \
str[i]=c; \
DIRECTION(north,0,'N') if(1==x) ; \
DIRECTION(south,2,'S') else if(2==x) str[i+1]=c; \
DIRECTION(west,4,'W') else str[i+1]='0'+x; \
DIRECTION(east,6,'E') }
#undef DIRECTION
return str; DIRECTION(north,0,'N')
} DIRECTION(south,2,'S')
DIRECTION(west,4,'W')
DIRECTION(east,6,'E')
}; #undef DIRECTION
return str;
}
};
struct TileRow struct TileRow
{ {
@ -263,11 +268,11 @@ namespace DFHack
TileClass c; TileClass c;
TileMaterial m; TileMaterial m;
TileVariant v; TileVariant v;
TileSpecial s; TileSpecial s;
TileDirection d; TileDirection d;
}; };
#define TILE_TYPE_ARRAY_LENGTH 520 #define TILE_TYPE_ARRAY_LENGTH 520
const TileRow tileTypeTable[TILE_TYPE_ARRAY_LENGTH] = const TileRow tileTypeTable[TILE_TYPE_ARRAY_LENGTH] =
{ {
@ -890,7 +895,7 @@ namespace DFHack
// 510 // 510
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "N-----E-" }, {"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "N-----E-" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "N---W---" }, {"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "N---W---" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "--S-W---" }, {"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "--S-W---" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "N-S-----" }, {"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "N-S-----" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "----W-E-" }, {"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "----W-E-" },
{"constructed stair up/down",STAIR_UPDOWN,CONSTRUCTED, VAR_1}, {"constructed stair up/down",STAIR_UPDOWN,CONSTRUCTED, VAR_1},
@ -936,91 +941,89 @@ namespace DFHack
return tileTypeTable[in].c; return tileTypeTable[in].c;
} }
//zilpin: for convenience, when you'll be using the tile information a lot. //zilpin: for convenience, when you'll be using the tile information a lot.
inline const inline const
TileRow * getTileTypeP(int in) TileRow * getTileTypeP(int in)
{ {
if( in<0 || in>=TILE_TYPE_ARRAY_LENGTH ) return NULL; if( in<0 || in>=TILE_TYPE_ARRAY_LENGTH ) return 0;
return ( const TileRow * ) &tileTypeTable[in]; return ( const TileRow * ) &tileTypeTable[in];
} }
//zilpin: Find the first tile entry which matches the given search criteria. //zilpin: Find the first tile entry which matches the given search criteria.
//All parameters are optional. //All parameters are optional.
//To omit, use the 'invalid' enum for that type (e.g. tileclass_invalid, tilematerial_invalid, etc) //To omit, use the 'invalid' enum for that type (e.g. tileclass_invalid, tilematerial_invalid, etc)
//For tile directions, pass NULL to omit. //For tile directions, pass NULL to omit.
//Returns matching index in tileTypeTable, or -1 if none found. //Returns matching index in tileTypeTable, or -1 if none found.
inline inline
int32_t findTileType( const TileClass tclass, const TileMaterial tmat, const TileVariant tvar, const TileSpecial tspecial, const TileDirection tdir ) int32_t findTileType( const TileClass tclass, const TileMaterial tmat, const TileVariant tvar, const TileSpecial tspecial, const TileDirection tdir )
{ {
int32_t tt; int32_t tt;
for(tt=0;tt<TILE_TYPE_ARRAY_LENGTH; ++tt){ for(tt=0;tt<TILE_TYPE_ARRAY_LENGTH; ++tt){
if( tclass>-1 ) if( tclass != tileTypeTable[tt].c ) continue; if( tclass>-1 ) if( tclass != tileTypeTable[tt].c ) continue;
if( tmat>-1 ) if( tmat != tileTypeTable[tt].m ) continue; if( tmat>-1 ) if( tmat != tileTypeTable[tt].m ) continue;
if( tvar>-1 ) if( tvar != tileTypeTable[tt].v ) continue; if( tvar>-1 ) if( tvar != tileTypeTable[tt].v ) continue;
if( tspecial>-1 ) if( tspecial != tileTypeTable[tt].s ) continue; if( tspecial>-1 ) if( tspecial != tileTypeTable[tt].s ) continue;
if( tdir.whole ) if( tdir.whole != tileTypeTable[tt].d.whole ) continue; if( tdir.whole ) if( tdir.whole != tileTypeTable[tt].d.whole ) continue;
//Match! //Match!
return tt; return tt;
} }
return -1; return -1;
} }
//Convenience version of the above, to pass strings as the direction //Convenience version of the above, to pass strings as the direction
inline inline
int32_t findTileType( const TileClass tclass, const TileMaterial tmat, const TileVariant tvar, const TileSpecial tspecial, const char *tdirStr ) int32_t findTileType( const TileClass tclass, const TileMaterial tmat, const TileVariant tvar, const TileSpecial tspecial, const char *tdirStr )
{ {
if(tdirStr){ if(tdirStr){
TileDirection tdir(tdirStr); TileDirection tdir(tdirStr);
return findTileType(tclass,tmat,tvar,tspecial, tdir ); return findTileType(tclass,tmat,tvar,tspecial, tdir );
}else{ }else{
return findTileType(tclass,tmat,tvar,tspecial, NULL ); return findTileType(tclass,tmat,tvar,tspecial, 0 );
} }
} }
//zilpin: Find a tile type similar to the one given, but with a different class.
//Useful for tile-editing operations.
//If no match found, returns the sourceType
//Definitely needs improvement for wall directions, etc.
inline
int32_t findSimilarTileType( const int32_t sourceTileType, const TileClass tclass ){
int32_t tt, maybe=0, match=0;
int value=0, matchv=0;
const TileRow *source = &tileTypeTable[sourceTileType];
const char * sourcename = source->name;
const uint32_t sourcenameint = *((const uint32_t *)sourcename);
#ifdef assert
assert( sourceTileType >=0 && sourceTileType < TILE_TYPE_ARRAY_LENGTH );
#endif
for(tt=0;tt<TILE_TYPE_ARRAY_LENGTH; ++tt){
if( tclass == tileTypeTable[tt].c ){
//shortcut null entries
if(!tileTypeTable[tt].name) continue;
//Special flag match is absolutely mandatory!
if( source->s != tileTypeTable[tt].s ) continue;
maybe=tt; value=0;
//Material is high-value match
if( tileTypeTable[tt].m == source->m ) value|=8;
//Direction is medium value match
if( tileTypeTable[tt].d.whole == source->d.whole ) value|=4;
//Variant is low-value match
if( tileTypeTable[tt].v == source->v ) value|=1;
//Check value against last match
if( value>matchv ){
match=tt;
matchv=value;
}
}
}
if( match ) return match;
return sourceTileType;
}
//zilpin: Find a tile type similar to the one given, but with a different class.
//Useful for tile-editing operations.
//If no match found, returns the sourceType
//Definitely needs improvement for wall directions, etc.
inline
int32_t findSimilarTileType( const int32_t sourceTileType, const TileClass tclass ){
int32_t tt, maybe=0, match=0;
int value=0, matchv=0;
const TileRow *source = &tileTypeTable[sourceTileType];
const char * sourcename = source->name;
const uint32_t sourcenameint = *((const uint32_t *)sourcename);
#ifdef assert
assert( sourceTileType >=0 && sourceTileType < TILE_TYPE_ARRAY_LENGTH );
#endif
for(tt=0;tt<TILE_TYPE_ARRAY_LENGTH; ++tt){
if( tclass == tileTypeTable[tt].c ){
//shortcut null entries
if(!tileTypeTable[tt].name) continue;
//Special flag match is absolutely mandatory!
if( source->s != tileTypeTable[tt].s ) continue;
maybe=tt; value=0;
//Material is high-value match
if( tileTypeTable[tt].m == source->m ) value|=8;
//Direction is medium value match
if( tileTypeTable[tt].d.whole == source->d.whole ) value|=4;
//Variant is low-value match
if( tileTypeTable[tt].v == source->v ) value|=1;
//Check value against last match
if( value>matchv ){
match=tt;
matchv=value;
}
}
}
if( match ) return match;
return sourceTileType;
}
} }

127
tools/playground/deramp.cpp
Unescape Escape View File

@ -5,6 +5,7 @@
#include <map> #include <map>
#include <stddef.h> #include <stddef.h>
#include <assert.h> #include <assert.h>
#include <string.h>
using namespace std; using namespace std;
#include <DFHack.h> #include <DFHack.h>
@ -20,20 +21,20 @@ int main (void)
DFHack::tiletypes40d tiles; DFHack::tiletypes40d tiles;
DFHack::tiletypes40d tilesAbove; DFHack::tiletypes40d tilesAbove;
//DFHack::TileRow *ptile; //DFHack::TileRow *ptile;
int32_t oldT, newT; int32_t oldT, newT;
int16_t t; int16_t t;
int dirty=0, count=0; int dirty=0, count=0;
DFHack::ContextManager DFMgr("Memory.xml"); DFHack::ContextManager DFMgr("Memory.xml");
DFHack::Context *DF = DFMgr.getSingleContext(); DFHack::Context *DF = DFMgr.getSingleContext();
//sanity check //sanity check
assert( sizeof(designations) == (16*16*sizeof(DFHack::t_designation)) ); assert( sizeof(designations) == (16*16*sizeof(DFHack::t_designation)) );
//Init //Init
try try
{ {
DF->Attach(); DF->Attach();
} }
@ -48,7 +49,7 @@ int main (void)
DFHack::Maps *Mapz = DF->getMaps(); DFHack::Maps *Mapz = DF->getMaps();
// init the map // init the map
if(!Mapz->Start()) if (!Mapz->Start())
{ {
cerr << "Can't init map." << endl; cerr << "Can't init map." << endl;
#ifndef LINUX_BUILD #ifndef LINUX_BUILD
@ -62,67 +63,75 @@ int main (void)
uint8_t zeroes [16][16] = {0}; uint8_t zeroes [16][16] = {0};
// 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(Mapz->isValidBlock(x,y,z)) if (Mapz->isValidBlock(x,y,z))
{ {
dirty=0; dirty=0;
Mapz->ReadDesignations(x,y,z, &designations); Mapz->ReadDesignations(x,y,z, &designations);
Mapz->ReadTileTypes(x,y,z, &tiles); Mapz->ReadTileTypes(x,y,z, &tiles);
if(Mapz->isValidBlock(x,y,z+1)){ if (Mapz->isValidBlock(x,y,z+1))
Mapz->ReadTileTypes(x,y,z+1, &tilesAbove); {
}else{ Mapz->ReadTileTypes(x,y,z+1, &tilesAbove);
memset(&tilesAbove,0,sizeof(tilesAbove)); }
} else
{
for(uint32_t ty=0;ty<16;++ty){ memset(&tilesAbove,0,sizeof(tilesAbove));
for(uint32_t tx=0;tx<16;++tx){ }
//Only the remove ramp designation (ignore channel designation, etc)
oldT = tiles[tx][ty]; for (uint32_t ty=0;ty<16;++ty)
if( DFHack::designation_default == designations[tx][ty].bits.dig {
&& DFHack::RAMP==DFHack::tileTypeTable[oldT].c for (uint32_t tx=0;tx<16;++tx)
){ {
//Current tile is a ramp. //Only the remove ramp designation (ignore channel designation, etc)
//Set current tile, as accurately as can be expected oldT = tiles[tx][ty];
newT = DFHack::findSimilarTileType(oldT,DFHack::FLOOR); if ( DFHack::designation_default == designations[tx][ty].bits.dig
&& DFHack::RAMP==DFHack::tileTypeTable[oldT].c)
//If no change, skip it (couldn't find a good tile type) {
if( oldT == newT) continue; //Current tile is a ramp.
//Set new tile type, clear designation //Set current tile, as accurately as can be expected
tiles[tx][ty] = newT; newT = DFHack::findSimilarTileType(oldT,DFHack::FLOOR);
designations[tx][ty].bits.dig = DFHack::designation_no;
//If no change, skip it (couldn't find a good tile type)
//Check the tile above this one, in case a downward slope needs to be removed. if ( oldT == newT) continue;
if( DFHack::RAMP_TOP == DFHack::tileTypeTable[tilesAbove[tx][ty]].c ){ //Set new tile type, clear designation
tilesAbove[tx][ty] = 32; tiles[tx][ty] = newT;
} designations[tx][ty].bits.dig = DFHack::designation_no;
dirty=-1; //Check the tile above this one, in case a downward slope needs to be removed.
++count; if ( DFHack::RAMP_TOP == DFHack::tileTypeTable[tilesAbove[tx][ty]].c )
} {
} tilesAbove[tx][ty] = 32;
} }
//If anything was changed, write it all.
if(dirty){ dirty=-1;
Mapz->WriteDesignations(x,y,z, &designations); ++count;
Mapz->WriteTileTypes(x,y,z, &tiles); }
if(Mapz->isValidBlock(x,y,z+1)){ }
Mapz->WriteTileTypes(x,y,z+1, &tilesAbove); }
} //If anything was changed, write it all.
} if (dirty)
{
Mapz->WriteDesignations(x,y,z, &designations);
Mapz->WriteTileTypes(x,y,z, &tiles);
if (Mapz->isValidBlock(x,y,z+1))
{
Mapz->WriteTileTypes(x,y,z+1, &tilesAbove);
}
}
} }
} }
} }
} }
DF->Detach(); DF->Detach();
cout << "Found and changed " << count << " tiles." << endl; cout << "Found and changed " << count << " tiles." << endl;
#ifndef LINUX_BUILD #ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl; cout << "Done. Press any key to continue" << endl;
cin.ignore(); cin.ignore();
#endif #endif
return 0; return 0;
} }

2052
tools/playground/hellhole.cpp
View File

File diff suppressed because it is too large Load Diff

125
tools/playground/printtiletypes.cpp
Unescape Escape View File

@ -17,77 +17,84 @@ using namespace DFHack;
int main (int argc, char **argv) int main (int argc, char **argv)
{ {
FILE *f=stdout; FILE *f=stdout;
const int Columns = 7; const int Columns = 7;
const char * Headings[Columns] = {"TileTypeID","Class","Material","V","Special","Direction","Description"}; const char * Headings[Columns] = {"TileTypeID","Class","Material","V","Special","Direction","Description"};
size_t Size[ Columns ] = {}; size_t Size[ Columns ] = {};
int i; int i;
//First, figure out column widths. //First, figure out column widths.
for(i=0;i<Columns;++i){ for(i=0;i<Columns;++i)
Size[i]=strlen(Headings[i])+1; {
} Size[i]=strlen(Headings[i])+1;
}
//Classes //Classes
fprintf(f,"\nTile Type Classes:\n"); fprintf(f,"\nTile Type Classes:\n");
for(i=0;i<tileclass_count;++i){ for(i=0;i<tileclass_count;++i)
Size[1]=max<size_t>(Size[1],strlen(TileClassString[i])); {
fprintf(f,"%4i ; %s\n", i, TileClassString[i] ,0 ); Size[1]=max<size_t>(Size[1],strlen(TileClassString[i]));
} fprintf(f,"%4i ; %s\n", i, TileClassString[i] ,0 );
}
//Materials //Materials
fprintf(f,"\nTile Type Materials:\n"); fprintf(f,"\nTile Type Materials:\n");
for(i=0;i<tilematerial_count;++i){ for(i=0;i<tilematerial_count;++i)
Size[2]=max<size_t>(Size[2],strlen(TileMaterialString[i])); {
fprintf(f,"%4i ; %s\n", i, TileMaterialString[i] ,0 ); Size[2]=max<size_t>(Size[2],strlen(TileMaterialString[i]));
} fprintf(f,"%4i ; %s\n", i, TileMaterialString[i] ,0 );
}
//Specials //Specials
fprintf(f,"\nTile Type Specials:\n"); fprintf(f,"\nTile Type Specials:\n");
for(i=0;i<tilespecial_count;++i){ for(i=0;i<tilespecial_count;++i)
Size[4]=max<size_t>(Size[4],strlen(TileSpecialString[i])); {
fprintf(f,"%4i ; %s\n", i, TileSpecialString[i] ,0 ); Size[4]=max<size_t>(Size[4],strlen(TileSpecialString[i]));
} fprintf(f,"%4i ; %s\n", i, TileSpecialString[i] ,0 );
}
/* - Not needed for now - /* - Not needed for now -
//Direction is tricky //Direction is tricky
for(i=0;i<TILE_TYPE_ARRAY_LENGTH;++i) for(i=0;i<TILE_TYPE_ARRAY_LENGTH;++i)
Size[5]=max(Size[5], tileTypeTable[i].d.sum()+1 ); Size[5]=max(Size[5], tileTypeTable[i].d.sum()+1 );
*/ */
//Print the headings first. //Print the headings first.
fprintf(f,"\nTile Types:\n"); fprintf(f,"\nTile Types:\n");
for(i=0;i<Columns;++i){ for(i=0;i<Columns;++i)
if(i) putc(';',f); {
fprintf(f," %-*s ",Size[i],Headings[i],0); if(i) putc(';',f);
} fprintf(f," %-*s ",Size[i],Headings[i],0);
fprintf(f,"\n"); }
fprintf(f,"\n");
//Process the whole array. //Process the whole array.
//A macro should be used for making the strings safe, but they are left in naked ? blocks //A macro should be used for making the strings safe, but they are left in naked ? blocks
//to illustrate the array references more clearly. //to illustrate the array references more clearly.
for(i=0;i<TILE_TYPE_ARRAY_LENGTH;++i){ for(i=0;i<TILE_TYPE_ARRAY_LENGTH;++i)
fprintf(f," %*i ; %-*s ; %-*s ; %*c ; %-*s ; %-*s ; %s\n", {
Size[0], i, fprintf(f," %*i ; %-*s ; %-*s ; %*c ; %-*s ; %-*s ; %s\n",
Size[1], ( tileTypeTable[i].name ? TileClassString[ tileTypeTable[i].c ] : "" ), Size[0], i,
Size[2], ( tileTypeTable[i].name ? TileMaterialString[ tileTypeTable[i].m ] : "" ), Size[1], ( tileTypeTable[i].name ? TileClassString[ tileTypeTable[i].c ] : "" ),
Size[3], ( tileTypeTable[i].v ? '0'+tileTypeTable[i].v : ' ' ), Size[2], ( tileTypeTable[i].name ? TileMaterialString[ tileTypeTable[i].m ] : "" ),
Size[4], ( tileTypeTable[i].s ? TileSpecialString[ tileTypeTable[i].s ] : "" ), Size[3], ( tileTypeTable[i].v ? '0'+tileTypeTable[i].v : ' ' ),
Size[5], ( tileTypeTable[i].d.whole ? tileTypeTable[i].d.getStr() : "" ), Size[4], ( tileTypeTable[i].s ? TileSpecialString[ tileTypeTable[i].s ] : "" ),
( tileTypeTable[i].name ? tileTypeTable[i].name : "" ), Size[5], ( tileTypeTable[i].d.whole ? tileTypeTable[i].d.getStr() : "" ),
0 ( tileTypeTable[i].name ? tileTypeTable[i].name : "" ),
); 0
} );
fprintf(f,"\n"); }
fprintf(f,"\n");
#ifndef LINUX_BUILD #ifndef LINUX_BUILD
if( 1== argc){ if( 1== argc)
cout << "Done. Press any key to continue" << endl; {
cin.ignore(); cout << "Done. Press any key to continue" << endl;
} cin.ignore();
}
#endif #endif
return 0; return 0;
} }

80
tools/supported/probe.cpp
Unescape Escape View File

@ -18,7 +18,7 @@ int main (int numargs, const char ** args)
DFHack::ContextManager DFMgr("Memory.xml"); DFHack::ContextManager DFMgr("Memory.xml");
DFHack::Context *DF = DFMgr.getSingleContext(); DFHack::Context *DF = DFMgr.getSingleContext();
BEGIN_PROBE: BEGIN_PROBE:
try try
{ {
DF->Attach(); DF->Attach();
@ -91,11 +91,11 @@ BEGIN_PROBE:
if(tileTypeTable[tiletype].name) if(tileTypeTable[tiletype].name)
std::cout << " = " << tileTypeTable[tiletype].name << std::endl; std::cout << " = " << tileTypeTable[tiletype].name << std::endl;
printf("%-10s: %4d %s\n","Class",tileTypeTable[tiletype].c,TileClassString[ tileTypeTable[tiletype].c ] , 0); printf("%-10s: %4d %s\n","Class",tileTypeTable[tiletype].c,TileClassString[ tileTypeTable[tiletype].c ] , 0);
printf("%-10s: %4d %s\n","Material",tileTypeTable[tiletype].c,TileMaterialString[ tileTypeTable[tiletype].m ] , 0); printf("%-10s: %4d %s\n","Material",tileTypeTable[tiletype].c,TileMaterialString[ tileTypeTable[tiletype].m ] , 0);
printf("%-10s: %4d %s\n","Special",tileTypeTable[tiletype].c,TileSpecialString[ tileTypeTable[tiletype].s ] , 0); printf("%-10s: %4d %s\n","Special",tileTypeTable[tiletype].c,TileSpecialString[ tileTypeTable[tiletype].s ] , 0);
printf("%-10s: %4d\n","Variant",tileTypeTable[tiletype].v , 0); printf("%-10s: %4d\n","Variant",tileTypeTable[tiletype].v , 0);
printf("%-10s: %s\n","Direction",tileTypeTable[tiletype].d.getStr() , 0); printf("%-10s: %s\n","Direction",tileTypeTable[tiletype].d.getStr() , 0);
std::cout << std::endl; std::cout << std::endl;
@ -125,46 +125,44 @@ BEGIN_PROBE:
uint32_t designato = block.origin + designatus + (tileX * 16 + tileY) * sizeof(t_designation); uint32_t designato = block.origin + designatus + (tileX * 16 + tileY) * sizeof(t_designation);
printf("designation offset: 0x%x\n", designato); printf("designation offset: 0x%x\n", designato);
#define PRINT_FLAG( X ) printf("%-16s= %c\n", #X , ( des.X ? 'Y' : ' ' ) ) #define PRINT_FLAG( X ) printf("%-16s= %c\n", #X , ( des.X ? 'Y' : ' ' ) )
PRINT_FLAG( hidden ); PRINT_FLAG( hidden );
PRINT_FLAG( light ); PRINT_FLAG( light );
PRINT_FLAG( skyview ); PRINT_FLAG( skyview );
PRINT_FLAG( subterranean ); PRINT_FLAG( subterranean );
PRINT_FLAG( water_table ); PRINT_FLAG( water_table );
//PRINT_FLAG( rained ); //PRINT_FLAG( rained );
planecoord pc;
pc.dim.x=blockX; pc.dim.y=blockY;
PRINT_FLAG( feature_local );
if( des.feature_local ){
printf("%-16s %4d (%2d) %s\n", "",
block.local_feature,
local_features[pc][block.local_feature]->type,
sa_feature[local_features[pc][block.local_feature]->type]
);
}
PRINT_FLAG( feature_global );
if( des.feature_global ){
printf("%-16s %4d (%2d) %s\n", "",
block.global_feature,
global_features[block.global_feature].type,
sa_feature[global_features[block.global_feature].type]
);
}
#undef PRINT_FLAG
planecoord pc;
pc.dim.x=blockX; pc.dim.y=blockY;
PRINT_FLAG( feature_local );
if( des.feature_local )
{
printf("%-16s %4d (%2d) %s\n", "",
block.local_feature,
local_features[pc][block.local_feature]->type,
sa_feature[local_features[pc][block.local_feature]->type]
);
}
PRINT_FLAG( feature_global );
if( des.feature_global ){
printf("%-16s %4d (%2d) %s\n", "",
block.global_feature,
global_features[block.global_feature].type,
sa_feature[global_features[block.global_feature].type]
);
}
#undef PRINT_FLAG
std::cout << std::endl; std::cout << std::endl;
} }
} }
DF->Detach(); DF->Detach();
#ifndef LINUX_BUILD #ifndef LINUX_BUILD
//std::cout << "Done. Press any key to continue" << std::endl; std::cout << "Press any key to refresh..." << std::endl;
std::cout << "Press any key to refresh..." << std::endl; cin.ignore();
cin.ignore(); goto BEGIN_PROBE;
goto BEGIN_PROBE;
#endif #endif
return 0; return 0;
} }