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

Merge remote branch 'upstream/master'

develop
reverb 2010-10-25 16:12:27 -05:00
parent ba88c86670 70cb93d9f4
commit 48dd2fc424
7 changed files with 2745 additions and 903 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
Unescape Escape View File

@ -29,3 +29,5 @@ dfhack/python/pydfhack/_pydfhack.so
dfhack/python/PyDFHack.egg-info
dfhack/python/build
dfhack/python/dist
/cmakeall.bat

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

@ -29,63 +29,237 @@ distribution.
namespace DFHack
{
// tile class -- determines the general shape of the tile
enum TileClass
{
EMPTY,// empty
WALL,
PILLAR,
FORTIFICATION,
STAIR_UP,
STAIR_DOWN,
STAIR_UPDOWN,
RAMP,// ramps have no direction
RAMP_TOP,// the top of a ramp. I assume it's used for path finding.
FLOOR,// generic floor
TREE_DEAD,
TREE_OK,
SAPLING_DEAD,
SAPLING_OK,
SHRUB_DEAD,
SHRUB_OK,
BOULDER,
PEBBLES
// enum and lookup table for string names created using X macros
#define TILECLASS_MACRO \
X(EMPTY, "") \
X(WALL, "") \
X(PILLAR, "") \
X(FORTIFICATION, "") \
X(STAIR_UP, "") \
X(STAIR_DOWN, "") \
X(STAIR_UPDOWN, "") \
X(RAMP, "ramps have no direction" ) \
X(RAMP_TOP, "used for pathing?" ) \
X(FLOOR, "") \
X(TREE_DEAD, "") \
X(TREE_OK, "") \
X(SAPLING_DEAD, "") \
X(SAPLING_OK, "") \
X(SHRUB_DEAD, "") \
X(SHRUB_OK, "") \
X(BOULDER, "") \
X(PEBBLES, "")
//end TILECLASS_MACRO
//define tile class enum
#define X(name,comment) name,
enum TileClass {
tileclass_invalid=-1,
TILECLASS_MACRO
tileclass_count,
};
// material -- what material the tile is made of
enum TileMaterial
{
AIR,// empty
SOIL,// ordinary soil. material depends on geology
STONE,// ordinary layer stone. material depends on geology
FEATSTONE,// map feature stone. used for things like hell, the hell temple or adamantine tubes. material depends on local/global feature
OBSIDIAN,// cast obsidian
VEIN,// vein stone. material depends on mineral veins present
ICE,// frozen water... not much to say. you can determine what was on the tile before it froze by looking into the 'ice vein' objects
GRASS,// grass (has 4 variants)
GRASS2,// grass (has 4 variants)
GRASS_DEAD,// dead grass (has 4 variants)
GRASS_DRY,// dry grass (has 4 variants)
DRIFTWOOD,// non-specified wood - normally on top of the local layer stone/soil.
HFS,// the stuff demon pits are made of - this makes them different from ordinary pits.
MAGMA,// material for semi-molten rock and 'magma flow' tiles
CAMPFIRE,// human armies make them when they siege. The original tile may be lost?
FIRE,// burning grass
ASHES,// what remains from a FIRE
CONSTRUCTED,// tile material depends on the construction present
CYAN_GLOW// the glowy stuff that disappears from the demon temple when you take the sword.
#undef X
//Visual Studio screams if you don't do this for the const char* arrays
#ifndef char_p
typedef char * char_p;
#endif
//set tile class string lookup table (e.g. for printing to user)
#define X(name,comment) #name,
const char_p TileClassString[tileclass_count+1] = {
TILECLASS_MACRO
0
};
#undef X
#define TILEMATERIAL_MACRO \
X(AIR, "empty" ) \
X(SOIL, "ordinary soil. material depends on geology" ) \
X(STONE, "ordinary layer stone. material depends on geology" ) \
X(FEATSTONE, "map special stone. used for things like hell, the hell temple or adamantine tubes. material depends on local/global special" ) \
X(OBSIDIAN, "cast obsidian" ) \
X(VEIN, "vein stone. material depends on mineral veins present" ) \
X(ICE, "frozen water... not much to say. you can determine what was on the tile before it froze by looking into the 'ice vein' objects" ) \
X(GRASS, "grass (has 4 variants)" ) \
X(GRASS2, "grass (has 4 variants)" ) \
X(GRASS_DEAD, "dead grass (has 4 variants)" ) \
X(GRASS_DRY, "dry grass (has 4 variants)" ) \
X(DRIFTWOOD, "non-specified wood - normally on top of the local layer stone/soil." ) \
X(HFS, "the stuff demon pits are made of - this makes them different from ordinary pits." ) \
X(MAGMA, "material for semi-molten rock and 'magma flow' tiles" ) \
X(CAMPFIRE, "human armies make them when they siege. The original tile may be lost?" ) \
X(FIRE, "burning grass" ) \
X(ASHES, "what remains from a FIRE" ) \
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." )
//end TILEMATERIAL_MACRO
// material enum
#define X(name,comment) name,
enum TileMaterial {
tilematerial_invalid=-1,
TILEMATERIAL_MACRO
tilematerial_count,
};
#undef X
//string lookup table (e.g. for printing to user)
#define X(name,comment) #name,
const char_p TileMaterialString[tilematerial_count+1] = {
TILEMATERIAL_MACRO
0
};
#undef X
// Special specials of the tile.
// Not the best way to do this, but compatible with existing code.
// When the TileType class gets created, everything should be re-thought.
#define TILESPECIAL_MACRO \
X(NORMAL, "Default for all type, nothing present" ) \
X(SPECIAL, "General purpose, for any unique tile which can not otherwise be differenciated" ) \
X(POOL, "Murky Pool, will gather water from rain" ) \
X(STREAM, "Streams (and brooks too? maybe?)" ) \
X(STREAM_TOP, "The walkable surface of a stream/brook" ) \
X(RIVER_SOURCE, "Rivers Source, when it exists on a map" ) \
X(RIVER, "Rivers, and their entering and exiting tiles" ) \
X(WATERFALL, "Special case for Waterfall Landing. How's this used?" ) \
X(ENDLESS, "Eerie Pit and Old Chasm/Endless Pit" ) \
X(CRACKED, "Walls being dug" ) \
X(DAMAGED, "Walls being dug" ) \
X(WORN, "Walls being dug ??" ) \
X(SMOOTH, "Walls and floors." )
//end TILESPECIAL_MACRO
//special enum
#define X(name,comment) TILE_##name,
enum TileSpecial {
tilespecial_invalid=-1,
TILESPECIAL_MACRO
tilespecial_count,
};
#undef X
//string lookup table (e.g. for printing to user)
#define X(name,comment) #name,
const char_p TileSpecialString[tilespecial_count+1] = {
TILESPECIAL_MACRO
0
};
#undef X
// variants are used for tiles, where there are multiple variants of the same - like grass floors
enum TileVariant
{
VAR_1,
tilevariant_invalid=-1,
VAR_1, //Yes, the value of VAR_1 is 0. It's legacy. Deal with it.
VAR_2,
VAR_3,
VAR_4
VAR_4,
};
//Mainly walls and rivers
//Byte values are used because walls can have either 1 or 2 in any given direction.
const int TileDirectionCount = 4;
union TileDirection
{
uint32_t whole;
unsigned char b[TileDirectionCount];
struct
{
//Maybe should add 'up' and 'down' for Z-levels?
unsigned char north,south,west,east;
};
inline TileDirection()
{
whole = 0;
}
TileDirection( uint32_t whole_bits)
{
whole = whole_bits;
}
TileDirection( unsigned char North, unsigned char South, unsigned char West, unsigned char East )
{
north=North; south=South; east=East; west=West;
}
TileDirection( const char *dir )
{
//This one just made for fun.
//Supports N S E W
const char *p = dir;
unsigned char *l=0;
north=south=east=west=0;
if(!dir) return;
for( ;*p;++p)
{
switch(*p)
{
case 'N': //North / Up
case 'n':
++north; l=&north; break;
case 'S': //South / Down
case 's':
++south; l=&south; break;
case 'E': //East / Right
case 'e':
++east; l=&east; break;
case 'W': //West / Left
case 'w':
++west; l=&west; break;
case '-':
case ' ':
//Explicitly ensure dash and space are ignored.
//Other characters/symbols may be assigned in the future.
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;
}
//Gives a string that represents the direction.
//This is a static string, overwritten with every call!
//Support values > 2 even though they should never happen.
//Copy string if it will be used.
inline char * getStr() const
{
static char str[16];
//type punning trick
*( (uint64_t *)str ) = *( (uint64_t *)"--------" );
str[8]=0;
#define DIRECTION(x,i,c) \
if(x){ \
str[i]=c; \
if(1==x) ; \
else if(2==x) str[i+1]=c; \
else str[i+1]='0'+x; \
}
DIRECTION(north,0,'N')
DIRECTION(south,2,'S')
DIRECTION(west,4,'W')
DIRECTION(east,6,'E')
#undef DIRECTION
return str;
}
};
struct TileRow
@ -94,6 +268,8 @@ namespace DFHack
TileClass c;
TileMaterial m;
TileVariant v;
TileSpecial s;
TileDirection d;
};
#define TILE_TYPE_ARRAY_LENGTH 520
@ -103,7 +279,7 @@ namespace DFHack
// 0
{"void",EMPTY, AIR, VAR_1},
{"ramp top",RAMP_TOP, AIR, VAR_1},
{"pool",FLOOR, SOIL, VAR_1},
{"pool",FLOOR, SOIL, VAR_1, TILE_POOL},
{0, EMPTY, AIR, VAR_1},
{0, EMPTY, AIR, VAR_1},
{0, EMPTY, AIR, VAR_1},
@ -142,7 +318,7 @@ namespace DFHack
{"empty space",EMPTY, AIR, VAR_1},
{0 ,EMPTY, AIR, VAR_1},
{"shrub",SHRUB_OK, SOIL, VAR_1},
{"chasm",FLOOR, AIR, VAR_1},
{"chasm",FLOOR, AIR, VAR_1, TILE_ENDLESS },
{"obsidian stair up/down",STAIR_UPDOWN, OBSIDIAN, VAR_1},
{"obsidian stair down",STAIR_DOWN, OBSIDIAN, VAR_1},
{"obsidian stair up",STAIR_UP, OBSIDIAN, VAR_1},
@ -151,12 +327,12 @@ namespace DFHack
// 40
{"soil stair down",STAIR_DOWN, SOIL, VAR_1},
{"soil stair up",STAIR_UP, SOIL, VAR_1},
{"eerie pit",FLOOR, HFS, VAR_1},
{"smooth stone floor",FLOOR, STONE, VAR_1},
{"smooth obsidian floor",FLOOR, OBSIDIAN, VAR_1},
{"smooth featstone? floor",FLOOR, FEATSTONE, VAR_1},
{"smooth vein floor",FLOOR, VEIN, VAR_1},
{"smooth ice floor",FLOOR, ICE, VAR_1},
{"eerie pit",FLOOR, HFS, VAR_1, TILE_ENDLESS},
{"smooth stone floor",FLOOR, STONE, VAR_1 , TILE_SMOOTH },
{"smooth obsidian floor",FLOOR, OBSIDIAN, VAR_1 , TILE_SMOOTH },
{"smooth featstone? floor",FLOOR, FEATSTONE, VAR_1 , TILE_SMOOTH },
{"smooth vein floor",FLOOR, VEIN, VAR_1 , TILE_SMOOTH },
{"smooth ice floor",FLOOR, ICE, VAR_1 , TILE_SMOOTH },
{0 ,EMPTY, AIR, VAR_1},
{"grass stair up/down",STAIR_UPDOWN, GRASS, VAR_1},
@ -206,10 +382,10 @@ namespace DFHack
{0 ,EMPTY, AIR, VAR_1},
{0 ,EMPTY, AIR, VAR_1},
{0 ,EMPTY, AIR, VAR_1},
{"waterfall landing",FLOOR, SOIL, VAR_1}, // verify material
{"waterfall landing",FLOOR, SOIL, VAR_1, TILE_WATERFALL }, // verify material
// 90
{"river source",FLOOR, SOIL, VAR_1}, // verify material
{"river source",FLOOR, SOIL, VAR_1, TILE_RIVER_SOURCE }, // verify material
{0 ,EMPTY, AIR, VAR_1},
{0 ,EMPTY, AIR, VAR_1},
{0 ,EMPTY, AIR, VAR_1},
@ -311,9 +487,9 @@ namespace DFHack
{0 ,EMPTY, AIR, VAR_1},
{0 ,EMPTY, AIR, VAR_1},
{0 ,EMPTY, AIR, VAR_1},
{"cracked stone wall" ,WALL, STONE, VAR_1},
{"damaged stone wall" ,WALL, STONE, VAR_1},
{"worn stone wall" ,WALL, STONE, VAR_1},
{"cracked stone wall" ,WALL, STONE, VAR_1, TILE_CRACKED },
{"damaged stone wall" ,WALL, STONE, VAR_1, TILE_DAMAGED },
{"worn stone wall" ,WALL, STONE, VAR_1, TILE_WORN },
{0 ,EMPTY, AIR, VAR_1},
// 180
@ -422,79 +598,79 @@ namespace DFHack
{0 ,EMPTY, AIR, VAR_1},
{"glowing floor" ,FLOOR, CYAN_GLOW, VAR_1},
{0 ,EMPTY, AIR, VAR_1},
{"smooth obsidian wall RD2",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall RD2",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "--SS--E-" },
// 270
{"smooth obsidian wall R2D",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall R2U",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall RU2",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall L2U",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall LU2",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall L2D",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall LD2",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall LRUD",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall RUD",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall LRD",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall R2D",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "--S---EE" },
{"smooth obsidian wall R2U",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "N-----EE" },
{"smooth obsidian wall RU2",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "NN----E-" },
{"smooth obsidian wall L2U",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "N---WW--" },
{"smooth obsidian wall LU2",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "NN--W---" },
{"smooth obsidian wall L2D",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "--S-WW--" },
{"smooth obsidian wall LD2",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "--SSW---" },
{"smooth obsidian wall LRUD",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH ,"N-S-W-E-" },
{"smooth obsidian wall RUD",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "N-S---E-" },
{"smooth obsidian wall LRD",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "--S-W-E-" },
// 280
{"smooth obsidian wall LRU",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall LUD",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall RD",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall RU",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall LU",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall LD",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall UD",WALL,OBSIDIAN,VAR_1},
{"smooth obsidian wall LR",WALL,OBSIDIAN,VAR_1},
{"smooth featstone wall RD2",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall R2D",WALL,FEATSTONE,VAR_1},
{"smooth obsidian wall LRU",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "N---W-E-" },
{"smooth obsidian wall LUD",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "N-S-W---" },
{"smooth obsidian wall RD",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "--S---E-" },
{"smooth obsidian wall RU",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "N-----E-" },
{"smooth obsidian wall LU",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "N---W---" },
{"smooth obsidian wall LD",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "--S-W---" },
{"smooth obsidian wall UD",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "N-S-----" },
{"smooth obsidian wall LR",WALL,OBSIDIAN,VAR_1 , TILE_SMOOTH , "----W-E-" },
{"smooth featstone wall RD2",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "--SS--E-" },
{"smooth featstone wall R2D",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "--S---EE" },
// 290
{"smooth featstone wall R2U",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall RU2",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall L2U",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall LU2",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall L2D",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall LD2",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall LRUD",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall RUD",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall LRD",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall LRU",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall R2U",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "N-----EE" },
{"smooth featstone wall RU2",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "NN----E-" },
{"smooth featstone wall L2U",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "N---WW--" },
{"smooth featstone wall LU2",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "NN--W---" },
{"smooth featstone wall L2D",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "--S-WW--" },
{"smooth featstone wall LD2",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "--SSW---" },
{"smooth featstone wall LRUD",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH ,"N-S-W-E-" },
{"smooth featstone wall RUD",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "N-S---E-" },
{"smooth featstone wall LRD",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "--S-W-E-" },
{"smooth featstone wall LRU",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "N---W-E-" },
//300
{"smooth featstone wall LUD",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall RD",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall RU",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall LU",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall LD",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall UD",WALL,FEATSTONE,VAR_1},
{"smooth featstone wall LR",WALL,FEATSTONE,VAR_1},
{"smooth stone wall RD2",WALL,STONE,VAR_1},
{"smooth stone wall R2D",WALL,STONE,VAR_1},
{"smooth stone wall R2U",WALL,STONE,VAR_1},
{"smooth featstone wall LUD",WALL,FEATSTONE,VAR_1, TILE_SMOOTH , "N-S-W---" },
{"smooth featstone wall RD",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "--S---E-" },
{"smooth featstone wall RU",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "N-----E-" },
{"smooth featstone wall LU",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "N---W---" },
{"smooth featstone wall LD",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "--S-W---" },
{"smooth featstone wall UD",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "N-S-----" },
{"smooth featstone wall LR",WALL,FEATSTONE,VAR_1 , TILE_SMOOTH , "----W-E-" },
{"smooth stone wall RD2",WALL,STONE,VAR_1 , TILE_SMOOTH , "--SS--E-" },
{"smooth stone wall R2D",WALL,STONE,VAR_1 , TILE_SMOOTH , "--S---EE" },
{"smooth stone wall R2U",WALL,STONE,VAR_1 , TILE_SMOOTH , "N-----EE" },
//310
{"smooth stone wall RU2",WALL,STONE,VAR_1},
{"smooth stone wall L2U",WALL,STONE,VAR_1},
{"smooth stone wall LU2",WALL,STONE,VAR_1},
{"smooth stone wall L2D",WALL,STONE,VAR_1},
{"smooth stone wall LD2",WALL,STONE,VAR_1},
{"smooth stone wall LRUD",WALL,STONE,VAR_1},
{"smooth stone wall RUD",WALL,STONE,VAR_1},
{"smooth stone wall LRD",WALL,STONE,VAR_1},
{"smooth stone wall LRU",WALL,STONE,VAR_1},
{"smooth stone wall LUD",WALL,STONE,VAR_1},
{"smooth stone wall RU2",WALL,STONE,VAR_1 , TILE_SMOOTH , "NN----E-" },
{"smooth stone wall L2U",WALL,STONE,VAR_1 , TILE_SMOOTH , "N---WW--" },
{"smooth stone wall LU2",WALL,STONE,VAR_1 , TILE_SMOOTH , "NN--W---" },
{"smooth stone wall L2D",WALL,STONE,VAR_1 , TILE_SMOOTH , "--S-WW--" },
{"smooth stone wall LD2",WALL,STONE,VAR_1 , TILE_SMOOTH , "--SSW---" },
{"smooth stone wall LRUD",WALL,STONE,VAR_1 , TILE_SMOOTH , "N-S-W-E-" },
{"smooth stone wall RUD",WALL,STONE,VAR_1 , TILE_SMOOTH , "N-S---E-" },
{"smooth stone wall LRD",WALL,STONE,VAR_1 , TILE_SMOOTH , "--S-W-E-" },
{"smooth stone wall LRU",WALL,STONE,VAR_1 , TILE_SMOOTH , "N---W-E-" },
{"smooth stone wall LUD",WALL,STONE,VAR_1 , TILE_SMOOTH , "N-S-W---" },
//320
{"smooth stone wall RD",WALL,STONE,VAR_1},
{"smooth stone wall RU",WALL,STONE,VAR_1},
{"smooth stone wall LU",WALL,STONE,VAR_1},
{"smooth stone wall LD",WALL,STONE,VAR_1},
{"smooth stone wall UD",WALL,STONE,VAR_1},
{"smooth stone wall LR",WALL,STONE,VAR_1},
{"smooth stone wall RD",WALL,STONE,VAR_1 , TILE_SMOOTH , "--S---E-" },
{"smooth stone wall RU",WALL,STONE,VAR_1 , TILE_SMOOTH , "N-----E-" },
{"smooth stone wall LU",WALL,STONE,VAR_1 , TILE_SMOOTH , "N---W---" },
{"smooth stone wall LD",WALL,STONE,VAR_1 , TILE_SMOOTH , "--S-W---" },
{"smooth stone wall UD",WALL,STONE,VAR_1 , TILE_SMOOTH , "N-S-----" },
{"smooth stone wall LR",WALL,STONE,VAR_1 , TILE_SMOOTH , "----W-E-" },
{"obsidian fortification",FORTIFICATION,OBSIDIAN,VAR_1},
{"featstone? fortification",FORTIFICATION,FEATSTONE,VAR_1},
{"cracked obsidian wall",WALL,OBSIDIAN,VAR_1},
{"damaged obsidian wall",WALL,OBSIDIAN,VAR_1},
{"cracked obsidian wall",WALL,OBSIDIAN,VAR_1, TILE_CRACKED },
{"damaged obsidian wall",WALL,OBSIDIAN,VAR_1, TILE_DAMAGED },
// 330
{"worn obsidian wall",WALL,OBSIDIAN,VAR_1},
@ -503,9 +679,9 @@ namespace DFHack
MAPTILE_FEATSTONE_WALL_WORN2,
MAPTILE_FEATSTONE_WALL_WORN3,
MAPTILE_FEATSTONE_WALL,*/
{"cracked featstone wall",WALL,STONE,VAR_1},
{"damaged featstone wall",WALL,STONE,VAR_1},
{"worn featstone wall",WALL,STONE,VAR_1},
{"cracked featstone wall",WALL,STONE,VAR_1, TILE_CRACKED },
{"damaged featstone wall",WALL,STONE,VAR_1, TILE_DAMAGED },
{"worn featstone wall",WALL,STONE,VAR_1, TILE_WORN },
{"featstone wall",WALL,STONE,VAR_1},
{"stone floor",FLOOR,STONE,VAR_1},
{"stone floor",FLOOR,STONE,VAR_2},
@ -538,31 +714,31 @@ namespace DFHack
// 360
{"ice fortification",FORTIFICATION,ICE,VAR_1},
{"cracked ice wall",WALL,ICE,VAR_1},
{"damaged ice wall",WALL,ICE,VAR_1},
{"worn ice wall",WALL,ICE,VAR_1},
{"cracked ice wall",WALL,ICE,VAR_1, TILE_CRACKED},
{"damaged ice wall",WALL,ICE,VAR_1, TILE_DAMAGED},
{"worn ice wall",WALL,ICE,VAR_1, TILE_WORN },
{"ice wall",WALL,ICE,VAR_1},
{"river N",FLOOR,SOIL,VAR_1},
{"river S",FLOOR,SOIL,VAR_1},
{"river E",FLOOR,SOIL,VAR_1},
{"river W",FLOOR,SOIL,VAR_1},
{"river NW",FLOOR,SOIL,VAR_1},
{"river N",FLOOR,SOIL,VAR_1, TILE_RIVER , "N" },
{"river S",FLOOR,SOIL,VAR_1, TILE_RIVER , "S" },
{"river E",FLOOR,SOIL,VAR_1, TILE_RIVER , "E" },
{"river W",FLOOR,SOIL,VAR_1, TILE_RIVER , "W" },
{"river NW",FLOOR,SOIL,VAR_1, TILE_RIVER, "NW"},
//370
{"river NE",FLOOR,SOIL,VAR_1},
{"river SW",FLOOR,SOIL,VAR_1},
{"river SE",FLOOR,SOIL,VAR_1},
{"stream bed N",FLOOR,SOIL,VAR_1},
{"stream bed S",FLOOR,SOIL,VAR_1},
{"stream bed E",FLOOR,SOIL,VAR_1},
{"stream bed W",FLOOR,SOIL,VAR_1},
{"stream bed NW",FLOOR,SOIL,VAR_1},
{"stream bed NE",FLOOR,SOIL,VAR_1},
{"stream bed SW",FLOOR,SOIL,VAR_1},
{"river NE",FLOOR,SOIL,VAR_1, TILE_RIVER , "NE" },
{"river SW",FLOOR,SOIL,VAR_1, TILE_RIVER , "SW" },
{"river SE",FLOOR,SOIL,VAR_1, TILE_RIVER , "SE" },
{"stream bed N",FLOOR,SOIL,VAR_1, TILE_STREAM , "N" },
{"stream bed S",FLOOR,SOIL,VAR_1, TILE_STREAM , "S" },
{"stream bed E",FLOOR,SOIL,VAR_1, TILE_STREAM , "E" },
{"stream bed W",FLOOR,SOIL,VAR_1, TILE_STREAM , "W" },
{"stream bed NW",FLOOR,SOIL,VAR_1, TILE_STREAM, "NW" },
{"stream bed NE",FLOOR,SOIL,VAR_1, TILE_STREAM, "NE" },
{"stream bed SW",FLOOR,SOIL,VAR_1, TILE_STREAM, "SW" },
// 380
{"stream bed SE",FLOOR,SOIL,VAR_1},
{"stream top",FLOOR,SOIL,VAR_1},
{"stream bed SE",FLOOR,SOIL,VAR_1, TILE_STREAM, "SE" },
{"stream top",FLOOR,SOIL,VAR_1, TILE_STREAM_TOP },
{0 ,EMPTY, AIR, VAR_1},
{0 ,EMPTY, AIR, VAR_1},
{0 ,EMPTY, AIR, VAR_1},
@ -604,33 +780,33 @@ namespace DFHack
{"featstone? pebbles",PEBBLES,FEATSTONE,VAR_2},
{"featstone? pebbles",PEBBLES,FEATSTONE,VAR_3},
{"featstone? pebbles",PEBBLES,FEATSTONE,VAR_4},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "--SS--E-"},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "--S---EE"},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "N-----EE" },
// 420
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "NN----E-"},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "N---WW--"},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "NN--W---"},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "--S-WW--" },
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "--SSW---"},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "N-S-W-E-"},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "N-S---E-"},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "--S-W-E-"},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "N---W-E-"},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "N-S-W---"},
// 430
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "--S---E-"},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "N-----E-"},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "N---W---"},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "--S-W---"},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "N-S-----"},
{"smooth vein wall",WALL,VEIN,VAR_1 , TILE_SMOOTH , "----W-E-"},
{"vein fortification",FORTIFICATION,VEIN,VAR_1},
{"cracked vein wall",WALL,VEIN,VAR_1},
{"damaged vein wall",WALL,VEIN,VAR_1},
{"worn vein wall",WALL,VEIN,VAR_1},
{"cracked vein wall",WALL,VEIN,VAR_1, TILE_CRACKED },
{"damaged vein wall",WALL,VEIN,VAR_1, TILE_DAMAGED },
{"worn vein wall",WALL,VEIN,VAR_1 , TILE_WORN },
// 440
{"vein wall",WALL,VEIN,VAR_1},
@ -645,27 +821,27 @@ namespace DFHack
{"vein pebbles",PEBBLES,VEIN,VAR_4},
// 450
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "--SS--E-"},
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "--S---EE" },
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "N-----EE" },
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "NN----E-"},
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "N---WW--" },
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "NN--W---" },
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "--S-WW--" },
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "--SSW---" },
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "N-S-W-E-"},
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "N-S---E-" },
// 460
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1},
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "--S-W-E-" },
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "N---W-E-" },
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "N-S-W---"},
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "--S---E-"},
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "N-----E-" },
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "N---W---" },
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "--S-W---" },
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "N-S-----" },
{"smooth ice wall",WALL,ICE,VAR_1 , TILE_SMOOTH , "----W-E-"},
{0 ,EMPTY, AIR, VAR_1},
// 470
@ -699,29 +875,29 @@ namespace DFHack
{"constructed floor",FLOOR,CONSTRUCTED, VAR_1},
{"constructed fortification",FORTIFICATION,CONSTRUCTED, VAR_1},
{"constructed pillar",PILLAR,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "--SS--E-" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "--S---EE" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "N-----EE" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "NN----E-" },
// 500
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "N---WW--" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "NN--W---" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "--S-WW--" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "--SSW---" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "N-S-W-E-" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "N-S---E-" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "--S-W-E-" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "N---W-E-" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "N-S-W---" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "--S---E-" },
// 510
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"constructed wall",WALL,CONSTRUCTED, VAR_1},
{"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, "--S-W---" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "N-S-----" },
{"constructed wall",WALL,CONSTRUCTED, VAR_1 ,TILE_NORMAL, "----W-E-" },
{"constructed stair up/down",STAIR_UPDOWN,CONSTRUCTED, VAR_1},
{"constructed stair down",STAIR_DOWN,CONSTRUCTED, VAR_1},
{"constructed stair up",STAIR_UP,CONSTRUCTED, VAR_1},
@ -764,6 +940,90 @@ namespace DFHack
{
return tileTypeTable[in].c;
}
//zilpin: for convenience, when you'll be using the tile information a lot.
inline const
TileRow * getTileTypeP(int in)
{
if( in<0 || in>=TILE_TYPE_ARRAY_LENGTH ) return 0;
return ( const TileRow * ) &tileTypeTable[in];
}
//zilpin: Find the first tile entry which matches the given search criteria.
//All parameters are optional.
//To omit, use the 'invalid' enum for that type (e.g. tileclass_invalid, tilematerial_invalid, etc)
//For tile directions, pass NULL to omit.
//Returns matching index in tileTypeTable, or -1 if none found.
inline
int32_t findTileType( const TileClass tclass, const TileMaterial tmat, const TileVariant tvar, const TileSpecial tspecial, const TileDirection tdir )
{
int32_t tt;
for(tt=0;tt<TILE_TYPE_ARRAY_LENGTH; ++tt){
if( tclass>-1 ) if( tclass != tileTypeTable[tt].c ) continue;
if( tmat>-1 ) if( tmat != tileTypeTable[tt].m ) continue;
if( tvar>-1 ) if( tvar != tileTypeTable[tt].v ) continue;
if( tspecial>-1 ) if( tspecial != tileTypeTable[tt].s ) continue;
if( tdir.whole ) if( tdir.whole != tileTypeTable[tt].d.whole ) continue;
//Match!
return tt;
}
return -1;
}
//Convenience version of the above, to pass strings as the direction
inline
int32_t findTileType( const TileClass tclass, const TileMaterial tmat, const TileVariant tvar, const TileSpecial tspecial, const char *tdirStr )
{
if(tdirStr){
TileDirection tdir(tdirStr);
return findTileType(tclass,tmat,tvar,tspecial, tdir );
}else{
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;
}
}

28
tools/playground/CMakeLists.txt
Unescape Escape View File

@ -67,6 +67,31 @@ TARGET_LINK_LIBRARIES(dfcopypaste dfhack)
ADD_EXECUTABLE(dfpaths paths.cpp)
TARGET_LINK_LIBRARIES(dfpaths dfhack)
# deramp
# Author: zilpin
# seeks entire map for 'remove ramp' designation, makes a floor, removes designation.
# intended use is to simulate old 'channel' functionality.
ADD_EXECUTABLE(dfderamp deramp.cpp)
TARGET_LINK_LIBRARIES(dfderamp dfhack)
# printtiletypes
# Author: zilpin
# Prints CSV dump of all tile type information.
# No DF process needed. Intended only for debugging and information purposes.
ADD_EXECUTABLE(dfprinttiletypes printtiletypes.cpp)
TARGET_LINK_LIBRARIES(dfprinttiletypes dfhack)
# hellhole
# Author: zilpin
# Creates a bottomless hole to hell.
# Experimental version hard-codes values.
# Will have many options in the future.
ADD_EXECUTABLE(dfhellhole hellhole.cpp)
TARGET_LINK_LIBRARIES(dfhellhole dfhack)
# this needs the C bindings
IF(BUILD_DFHACK_C_BINDINGS)
# for trying out some 'stuff'
@ -83,6 +108,9 @@ dfmoodump
dfdigger
dfdigger2
dfcatsplosion
dfderamp
dfprinttiletypes
dfhellhole
RUNTIME DESTINATION bin
)
IF(UNIX)

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

@ -0,0 +1,137 @@
// De-ramp. All ramps marked for removal are replaced with given tile (presently, normal floor).
#include <iostream>
#include <vector>
#include <map>
#include <stddef.h>
#include <assert.h>
#include <string.h>
using namespace std;
#include <DFHack.h>
#include <dfhack/DFTileTypes.h>
int main (void)
{
uint32_t x_max,y_max,z_max;
uint32_t num_blocks = 0;
uint32_t bytes_read = 0;
DFHack::designations40d designations;
DFHack::tiletypes40d tiles;
DFHack::tiletypes40d tilesAbove;
//DFHack::TileRow *ptile;
int32_t oldT, newT;
int16_t t;
int dirty=0, count=0;
DFHack::ContextManager DFMgr("Memory.xml");
DFHack::Context *DF = DFMgr.getSingleContext();
//sanity check
assert( sizeof(designations) == (16*16*sizeof(DFHack::t_designation)) );
//Init
try
{
DF->Attach();
}
catch (exception& e)
{
cerr << e.what() << endl;
#ifndef LINUX_BUILD
cin.ignore();
#endif
return 1;
}
DFHack::Maps *Mapz = DF->getMaps();
// init the map
if (!Mapz->Start())
{
cerr << "Can't init map." << endl;
#ifndef LINUX_BUILD
cin.ignore();
#endif
return 1;
}
Mapz->getSize(x_max,y_max,z_max);
uint8_t zeroes [16][16] = {0};
// walk the map
for (uint32_t x = 0; x< x_max;x++)
{
for (uint32_t y = 0; y< y_max;y++)
{
for (uint32_t z = 0; z< z_max;z++)
{
if (Mapz->isValidBlock(x,y,z))
{
dirty=0;
Mapz->ReadDesignations(x,y,z, &designations);
Mapz->ReadTileTypes(x,y,z, &tiles);
if (Mapz->isValidBlock(x,y,z+1))
{
Mapz->ReadTileTypes(x,y,z+1, &tilesAbove);
}
else
{
memset(&tilesAbove,0,sizeof(tilesAbove));
}
for (uint32_t ty=0;ty<16;++ty)
{
for (uint32_t tx=0;tx<16;++tx)
{
//Only the remove ramp designation (ignore channel designation, etc)
oldT = tiles[tx][ty];
if ( DFHack::designation_default == designations[tx][ty].bits.dig
&& DFHack::RAMP==DFHack::tileTypeTable[oldT].c)
{
//Current tile is a ramp.
//Set current tile, as accurately as can be expected
newT = DFHack::findSimilarTileType(oldT,DFHack::FLOOR);
//If no change, skip it (couldn't find a good tile type)
if ( oldT == newT) continue;
//Set new tile type, clear designation
tiles[tx][ty] = newT;
designations[tx][ty].bits.dig = DFHack::designation_no;
//Check the tile above this one, in case a downward slope needs to be removed.
if ( DFHack::RAMP_TOP == DFHack::tileTypeTable[tilesAbove[tx][ty]].c )
{
tilesAbove[tx][ty] = 32;
}
dirty=-1;
++count;
}
}
}
//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();
cout << "Found and changed " << count << " tiles." << endl;
#ifndef LINUX_BUILD
cout << "Done. Press any key to continue" << endl;
cin.ignore();
#endif
return 0;
}

1279
tools/playground/hellhole.cpp
View File

File diff suppressed because it is too large Load Diff

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

@ -0,0 +1,100 @@
// Prints all the Tile Types known by DFHack.
// File is both fixed-field and CSV parsable.
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <vector>
#include <map>
#include <stddef.h>
#include <assert.h>
using namespace std;
#include <DFHack.h>
#include <dfhack/DFTileTypes.h>
using namespace DFHack;
int main (int argc, char **argv)
{
FILE *f=stdout;
const int Columns = 7;
const char * Headings[Columns] = {"TileTypeID","Class","Material","V","Special","Direction","Description"};
size_t Size[ Columns ] = {};
int i;
//First, figure out column widths.
for(i=0;i<Columns;++i)
{
Size[i]=strlen(Headings[i])+1;
}
//Classes
fprintf(f,"\nTile Type Classes:\n");
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 );
}
//Materials
fprintf(f,"\nTile Type Materials:\n");
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 );
}
//Specials
fprintf(f,"\nTile Type Specials:\n");
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 );
}
/* - Not needed for now -
//Direction is tricky
for(i=0;i<TILE_TYPE_ARRAY_LENGTH;++i)
Size[5]=max(Size[5], tileTypeTable[i].d.sum()+1 );
*/
//Print the headings first.
fprintf(f,"\nTile Types:\n");
for(i=0;i<Columns;++i)
{
if(i) putc(';',f);
fprintf(f," %-*s ",Size[i],Headings[i],0);
}
fprintf(f,"\n");
//Process the whole array.
//A macro should be used for making the strings safe, but they are left in naked ? blocks
//to illustrate the array references more clearly.
for(i=0;i<TILE_TYPE_ARRAY_LENGTH;++i)
{
fprintf(f," %*i ; %-*s ; %-*s ; %*c ; %-*s ; %-*s ; %s\n",
Size[0], i,
Size[1], ( tileTypeTable[i].name ? TileClassString[ tileTypeTable[i].c ] : "" ),
Size[2], ( tileTypeTable[i].name ? TileMaterialString[ tileTypeTable[i].m ] : "" ),
Size[3], ( tileTypeTable[i].v ? '0'+tileTypeTable[i].v : ' ' ),
Size[4], ( tileTypeTable[i].s ? TileSpecialString[ tileTypeTable[i].s ] : "" ),
Size[5], ( tileTypeTable[i].d.whole ? tileTypeTable[i].d.getStr() : "" ),
( tileTypeTable[i].name ? tileTypeTable[i].name : "" ),
0
);
}
fprintf(f,"\n");
#ifndef LINUX_BUILD
if( 1== argc)
{
cout << "Done. Press any key to continue" << endl;
cin.ignore();
}
#endif
return 0;
}

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

@ -8,8 +8,8 @@
#include <ctime>
#include <cstdio>
#define DFHACK_WANT_MISCUTILS
#define DFHACK_WANT_TILETYPES
#define DFHACK_WANT_MISCUTILS 1
#define DFHACK_WANT_TILETYPES 1
#include <DFHack.h>
using namespace DFHack;
@ -18,6 +18,7 @@ int main (int numargs, const char ** args)
DFHack::ContextManager DFMgr("Memory.xml");
DFHack::Context *DF = DFMgr.getSingleContext();
BEGIN_PROBE:
try
{
DF->Attach();
@ -31,6 +32,7 @@ int main (int numargs, const char ** args)
return 1;
}
DFHack::Position *Pos = DF->getPosition();
DFHack::VersionInfo* mem = DF->getMemoryInfo();
DFHack::Maps *Maps = DF->getMaps();
@ -57,6 +59,11 @@ int main (int numargs, const char ** args)
Maps->Start();
vector<DFHack::t_feature> global_features;
std::map <DFHack::planecoord, std::vector<DFHack::t_feature *> > local_features;
Maps->ReadLocalFeatures(local_features);
Maps->ReadGlobalFeatures(global_features);
int32_t cursorX, cursorY, cursorZ;
Pos->getCursorCoords(cursorX,cursorY,cursorZ);
if(cursorX != -30000)
@ -82,7 +89,15 @@ int main (int numargs, const char ** args)
// tiletype
std::cout <<"tiletype: " << tiletype;
if(tileTypeTable[tiletype].name)
std::cout << " = " << tileTypeTable[tiletype].name;
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","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\n","Variant",tileTypeTable[tiletype].v , 0);
printf("%-10s: %s\n","Direction",tileTypeTable[tiletype].d.getStr() , 0);
std::cout << std::endl;
std::cout <<"temperature1: " << tmpb1[tileX][tileY] << " U" << std::endl;
std::cout <<"temperature2: " << tmpb2[tileX][tileY] << " U" << std::endl;
@ -109,24 +124,45 @@ int main (int numargs, const char ** args)
std::cout << "smooth?" << std::endl;
uint32_t designato = block.origin + designatus + (tileX * 16 + tileY) * sizeof(t_designation);
printf("designation offset: 0x%x\n", designato);
if(des.light)
std::cout << "Light ";
else
std::cout << " ";
if(des.skyview)
std::cout << "SkyView ";
else
std::cout << " ";
if(des.subterranean)
std::cout << "Underground ";
else
std::cout << " ";
#define PRINT_FLAG( X ) printf("%-16s= %c\n", #X , ( des.X ? 'Y' : ' ' ) )
PRINT_FLAG( hidden );
PRINT_FLAG( light );
PRINT_FLAG( skyview );
PRINT_FLAG( subterranean );
PRINT_FLAG( water_table );
//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
std::cout << std::endl;
}
}
DF->Detach();
#ifndef LINUX_BUILD
std::cout << "Done. Press any key to continue" << std::endl;
std::cout << "Press any key to refresh..." << std::endl;
cin.ignore();
goto BEGIN_PROBE;
#endif
return 0;
}