From 822265443c756675311a576b9981e4be433f7cf7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Petr=20Mr=C3=A1zek?= Date: Thu, 25 Mar 2010 21:37:09 +0100 Subject: [PATCH] Make the API a bit saner about the used data types and structures --- examples/veinlook.cpp | 8 +-- library/CMakeLists.txt | 29 ++++---- library/DFHackAPI.cpp | 18 ++--- library/DFHackAPI.h | 152 ++++++++++++++++++++++++++--------------- library/DFTypes.h | 21 ++++-- tools/cleanmap.cpp | 10 +-- tools/digger.cpp | 12 ++-- tools/prospector.cpp | 12 ++-- tools/reveal.cpp | 10 +-- 9 files changed, 163 insertions(+), 109 deletions(-) diff --git a/examples/veinlook.cpp b/examples/veinlook.cpp index a23f30e60..e01558087 100644 --- a/examples/veinlook.cpp +++ b/examples/veinlook.cpp @@ -459,10 +459,10 @@ main(int argc, char *argv[]) TileMaterial tm = tileTypeTable[Block->tiletypes[x][y]].m; if( tc == WALL && tm == VEIN || tc == TREE_OK || tc == TREE_DEAD) { - Block->designaton[x][y].bits.dig = designation_default; + Block->designation[x][y].bits.dig = designation_default; } } - DF.WriteDesignations(cursorX+i,cursorY+j,cursorZ, (uint32_t *) Block->designaton); + DF.WriteDesignations(cursorX+i,cursorY+j,cursorZ, &(Block->designation)); } // do a dump of the block data if(dump) @@ -489,7 +489,7 @@ main(int argc, char *argv[]) { int color = COLOR_BLACK; color = pickColor(Block->tiletypes[x][y]); - if(!Block->designaton[x][y].bits.hidden) + if(!Block->designation[x][y].bits.hidden) /*{ puttile(x+(i+1)*16,y+(j+1)*16,Block->tiletypes[x][y], color); } @@ -546,7 +546,7 @@ main(int argc, char *argv[]) { if(tileTypeTable[blocks[1][1].tiletypes[k][j]].m != VEIN) continue; - if(blocks[1][1].designaton[k][j].bits.hidden) + if(blocks[1][1].designation[k][j].bits.hidden) continue; // and the bit array with a one-bit mask, check if the bit is set bool set = !!(((1 << k) & veinVector[realvein].assignment[j]) >> k); diff --git a/library/CMakeLists.txt b/library/CMakeLists.txt index 321ef5b3b..00db92923 100644 --- a/library/CMakeLists.txt +++ b/library/CMakeLists.txt @@ -107,18 +107,17 @@ IF(UNIX) ENDIF(UNIX) # SWIG stuff -FIND_PACKAGE(SWIG) - -IF(SWIG_FOUND) - INCLUDE(${SWIG_USE_FILE}) - FIND_PACKAGE(PythonLibs) - IF(PYTHONLIBS_FOUND) - INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_PATH}) - SET(CMAKE_SWIG_FLAGS "-c++") - SET_SOURCE_FILES_PROPERTIES(pydfhack.i PROPERTIES CPLUSPLUS ON) -# SET(CMAKE_DFHACK_SWIG_OUTDIR ${dfhack_SOURCE_DIR}/output CACHE PATH "Directory where Java wrapped libraries will be saved.") - # SET_SOURCE_FILES_PROPERTIES(pydfhack.i PROPERTIES SWIG_FLAGS "-includeall") - SWIG_ADD_MODULE(pydfhack python pydfhack.i) - SWIG_LINK_LIBRARIES(pydfhack ${PYTHON_LIBRARIES} dfhack) - ENDIF(PYTHONLIBS_FOUND) -ENDIF(SWIG_FOUND) \ No newline at end of file +#FIND_PACKAGE(SWIG) + +#IF(SWIG_FOUND) + #INCLUDE(${SWIG_USE_FILE}) + #FIND_PACKAGE(PythonLibs) + #IF(PYTHONLIBS_FOUND) + #INCLUDE_DIRECTORIES(${PYTHON_INCLUDE_PATH}) + #SET(CMAKE_SWIG_FLAGS "-c++") + #SET_SOURCE_FILES_PROPERTIES(pydfhack.i PROPERTIES CPLUSPLUS ON) + #SET_SOURCE_FILES_PROPERTIES(pydfhack.i PROPERTIES SWIG_FLAGS "-includeall") + #SWIG_ADD_MODULE(pydfhack python pydfhack.i) + #SWIG_LINK_LIBRARIES(pydfhack ${PYTHON_LIBRARIES} dfhack) + #ENDIF(PYTHONLIBS_FOUND) +#ENDIF(SWIG_FOUND) \ No newline at end of file diff --git a/library/DFHackAPI.cpp b/library/DFHackAPI.cpp index e663b741e..fe03ff978 100644 --- a/library/DFHackAPI.cpp +++ b/library/DFHackAPI.cpp @@ -348,7 +348,7 @@ bool API::ReadBlock40d(uint32_t x, uint32_t y, uint32_t z, mapblock40d * buffer) { g_pProcess->read (addr + d->tile_type_offset, sizeof (buffer->tiletypes), (uint8_t *) buffer->tiletypes); g_pProcess->read (addr + d->occupancy_offset, sizeof (buffer->occupancy), (uint8_t *) buffer->occupancy); - g_pProcess->read (addr + d->designation_offset, sizeof (buffer->designaton), (uint8_t *) buffer->designaton); + g_pProcess->read (addr + d->designation_offset, sizeof (buffer->designation), (uint8_t *) buffer->designation); g_pProcess->read (addr + d->biome_stuffs, sizeof (buffer->biome_indices), (uint8_t *) buffer->biome_indices); buffer->origin = addr; uint32_t addr_of_struct = g_pProcess->readDWord(addr); @@ -361,7 +361,7 @@ bool API::ReadBlock40d(uint32_t x, uint32_t y, uint32_t z, mapblock40d * buffer) // 256 * sizeof(uint16_t) -bool API::ReadTileTypes (uint32_t x, uint32_t y, uint32_t z, uint16_t *buffer) +bool API::ReadTileTypes (uint32_t x, uint32_t y, uint32_t z, tiletypes40d *buffer) { uint32_t addr = d->block[x*d->y_block_count*d->z_block_count + y*d->z_block_count + z]; if (addr) @@ -401,7 +401,7 @@ bool API::WriteDirtyBit(uint32_t x, uint32_t y, uint32_t z, bool dirtybit) // 256 * sizeof(uint32_t) -bool API::ReadDesignations (uint32_t x, uint32_t y, uint32_t z, uint32_t *buffer) +bool API::ReadDesignations (uint32_t x, uint32_t y, uint32_t z, designations40d *buffer) { uint32_t addr = d->block[x*d->y_block_count*d->z_block_count + y*d->z_block_count + z]; if (addr) @@ -414,7 +414,7 @@ bool API::ReadDesignations (uint32_t x, uint32_t y, uint32_t z, uint32_t *buffer // 256 * sizeof(uint32_t) -bool API::ReadOccupancy (uint32_t x, uint32_t y, uint32_t z, uint32_t *buffer) +bool API::ReadOccupancy (uint32_t x, uint32_t y, uint32_t z, occupancies40d *buffer) { uint32_t addr = d->block[x*d->y_block_count*d->z_block_count + y*d->z_block_count + z]; if (addr) @@ -427,7 +427,7 @@ bool API::ReadOccupancy (uint32_t x, uint32_t y, uint32_t z, uint32_t *buffer) // 256 * sizeof(uint16_t) -bool API::WriteTileTypes (uint32_t x, uint32_t y, uint32_t z, uint16_t *buffer) +bool API::WriteTileTypes (uint32_t x, uint32_t y, uint32_t z, tiletypes40d *buffer) { uint32_t addr = d->block[x*d->y_block_count*d->z_block_count + y*d->z_block_count + z]; if (addr) @@ -445,7 +445,7 @@ bool API::getCurrentCursorCreature(uint32_t & creature_index) return true; } // 256 * sizeof(uint32_t) -bool API::WriteDesignations (uint32_t x, uint32_t y, uint32_t z, uint32_t *buffer) +bool API::WriteDesignations (uint32_t x, uint32_t y, uint32_t z, designations40d *buffer) { uint32_t addr = d->block[x*d->y_block_count*d->z_block_count + y*d->z_block_count + z]; if (addr) @@ -457,7 +457,7 @@ bool API::WriteDesignations (uint32_t x, uint32_t y, uint32_t z, uint32_t *buffe } // 256 * sizeof(uint32_t) -bool API::WriteOccupancy (uint32_t x, uint32_t y, uint32_t z, uint32_t *buffer) +bool API::WriteOccupancy (uint32_t x, uint32_t y, uint32_t z, occupancies40d *buffer) { uint32_t addr = d->block[x*d->y_block_count*d->z_block_count + y*d->z_block_count + z]; if (addr) @@ -471,12 +471,12 @@ bool API::WriteOccupancy (uint32_t x, uint32_t y, uint32_t z, uint32_t *buffer) // FIXME: this is bad. determine the real size! //16 of them? IDK... there's probably just 7. Reading more doesn't cause errors as it's an array nested inside a block // 16 * sizeof(uint8_t) -bool API::ReadRegionOffsets (uint32_t x, uint32_t y, uint32_t z, uint8_t *buffer) +bool API::ReadRegionOffsets (uint32_t x, uint32_t y, uint32_t z, biome_indices40d *buffer) { uint32_t addr = d->block[x*d->y_block_count*d->z_block_count + y*d->z_block_count + z]; if (addr) { - g_pProcess->read (addr + d->biome_stuffs, 16 * sizeof (uint8_t), buffer); + g_pProcess->read (addr + d->biome_stuffs, 16 * sizeof (uint8_t), (uint8_t *) buffer); return true; } return false; diff --git a/library/DFHackAPI.h b/library/DFHackAPI.h index 842977107..b828e1695 100644 --- a/library/DFHackAPI.h +++ b/library/DFHackAPI.h @@ -46,32 +46,39 @@ namespace DFHack public: API(const std::string path_to_xml); ~API(); + /* + * Basic control over DF's process state + */ + bool Attach(); bool Detach(); bool isAttached(); - //true if paused, false if not - bool ReadPauseState(); - - // read the DF menu view state (stock screen, unit screen, other screens - bool ReadViewScreen(t_viewscreen &); - - // read the DF menu state (designation menu ect) - uint32_t ReadMenuState(); - - // stop DF from executing + /// stop DF from executing bool Suspend(); - // stop DF from executing, asynchronous, use with polling + bool isSuspended(); + + /// stop DF from executing, asynchronous, use with polling bool AsyncSuspend(); - // resume DF + + /// resume DF bool Resume(); - /** - * Force resume - * be careful with this one - */ + + /// forces resume on Windows. This can be a bad thing with multiple DF tools running! bool ForceResume(); - bool isSuspended(); - /** + + /* + * Query the DF's GUI state + */ + ///true if paused, false if not + bool ReadPauseState(); + /// read the DF menu view state (stock screen, unit screen, other screens + bool ReadViewScreen(t_viewscreen &); + /// read the DF menu state (designation menu ect) + uint32_t ReadMenuState(); + + + /* * Matgloss. next four methods look very similar. I could use two and move the processing one level up... * I'll keep it like this, even with the code duplication as it will hopefully get more features and separate data types later. * Yay for nebulous plans for a rock survey tool that tracks how much of which metal could be smelted from available resorces @@ -135,111 +142,148 @@ namespace DFHack */ uint32_t getBlockPtr (uint32_t blockx, uint32_t blocky, uint32_t blockz); + /// read the whole map block at block coords (see DFTypes.h for the block structure) bool ReadBlock40d(uint32_t blockx, uint32_t blocky, uint32_t blockz, mapblock40d * buffer); - bool ReadTileTypes(uint32_t blockx, uint32_t blocky, uint32_t blockz, uint16_t *buffer); // 256 * sizeof(uint16_t) - bool WriteTileTypes(uint32_t blockx, uint32_t blocky, uint32_t blockz, uint16_t *buffer); // 256 * sizeof(uint16_t) + /// read/write block tile types + bool ReadTileTypes(uint32_t blockx, uint32_t blocky, uint32_t blockz, tiletypes40d *buffer); + bool WriteTileTypes(uint32_t blockx, uint32_t blocky, uint32_t blockz, tiletypes40d *buffer); - bool ReadDesignations(uint32_t blockx, uint32_t blocky, uint32_t blockz, uint32_t *buffer); // 256 * sizeof(uint32_t) - bool WriteDesignations (uint32_t blockx, uint32_t blocky, uint32_t blockz, uint32_t *buffer); + /// read/write block designations + bool ReadDesignations(uint32_t blockx, uint32_t blocky, uint32_t blockz, designations40d *buffer); + bool WriteDesignations (uint32_t blockx, uint32_t blocky, uint32_t blockz, designations40d *buffer); - bool ReadOccupancy(uint32_t blockx, uint32_t blocky, uint32_t blockz, uint32_t *buffer); // 256 * sizeof(uint32_t) - bool WriteOccupancy(uint32_t blockx, uint32_t blocky, uint32_t blockz, uint32_t *buffer); // 256 * sizeof(uint32_t) - + /// read/write block occupancies + bool ReadOccupancy(uint32_t blockx, uint32_t blocky, uint32_t blockz, occupancies40d *buffer); + bool WriteOccupancy(uint32_t blockx, uint32_t blocky, uint32_t blockz, occupancies40d *buffer); + + /// read/write the block dirty bit - this is used to mark a map block so that DF scans it for designated jobs like digging bool ReadDirtyBit(uint32_t blockx, uint32_t blocky, uint32_t blockz, bool &dirtybit); bool WriteDirtyBit(uint32_t blockx, uint32_t blocky, uint32_t blockz, bool dirtybit); - /// read region offsets of a block - bool ReadRegionOffsets(uint32_t blockx, uint32_t blocky, uint32_t blockz, uint8_t *buffer); // 16 * sizeof(uint8_t) + /// read region offsets of a block - used for determining layer stone matgloss + bool ReadRegionOffsets(uint32_t blockx, uint32_t blocky, uint32_t blockz, biome_indices40d *buffer); /// read aggregated veins of a block bool ReadVeins(uint32_t blockx, uint32_t blocky, uint32_t blockz, std::vector & veins, std::vector & ices); - /** - * Buildings, constructions, plants, all pretty straighforward. InitReadBuildings returns all the building types as a mapping between a numeric values and strings + /* + * Constructions (costructed walls, floors, ramps, etc...) */ + /// start reading constructions. numconstructions is an output - total constructions present bool InitReadConstructions( uint32_t & numconstructions ); + /// read a construiction at index bool ReadConstruction(const int32_t index, t_construction & construction); + /// cleanup after reading constructions void FinishReadConstructions(); + /* + * Buildings - also includes zones and stockpiles + */ bool InitReadBuildings ( uint32_t & numbuildings ); bool ReadBuilding(const int32_t index, t_building & building); void FinishReadBuildings(); + /* + * Effects like mist, dragonfire or dust + */ bool InitReadEffects ( uint32_t & numeffects ); bool ReadEffect(const int32_t index, t_effect_df40d & effect); bool WriteEffect(const int32_t index, const t_effect_df40d & effect); void FinishReadEffects(); - + + /* + * Trees and shrubs + */ bool InitReadVegetation( uint32_t & numplants ); bool ReadVegetation(const int32_t index, t_tree_desc & shrubbery); void FinishReadVegetation(); + /* + * Creatures + */ bool InitReadCreatures( uint32_t & numcreatures ); - /// returns index of creature actually read or -1 if no creature can be found + /** + * Read creatures in a box, starting with index. Returns -1 if no more creatures + * found. Call repeatedly do get all creatures in a specified box (uses tile coords) + */ int32_t ReadCreatureInBox(const int32_t index, t_creature & furball, const uint16_t x1, const uint16_t y1,const uint16_t z1, const uint16_t x2, const uint16_t y2,const uint16_t z2); bool ReadCreature(const int32_t index, t_creature & furball); void FinishReadCreatures(); + /// read/write size bytes of raw data at offset. DANGEROUS, CAN SEGFAULT DF! void ReadRaw (const uint32_t offset, const uint32_t size, uint8_t *target); void WriteRaw (const uint32_t offset, const uint32_t size, uint8_t *source); + /// write labors of a creature (for Dwarf Therapist) + void WriteLabors(const uint32_t index, uint8_t labors[NUM_CREATURE_LABORS]); - bool InitViewAndCursor(); - + /* + * Notes placed by the player + */ + + /// start reading notes. numnotes is an output - total notes present bool InitReadNotes( uint32_t & numnotes ); + /// read note from the note vector at index bool ReadNote(const int32_t index, t_note & note); + /// free the note vector void FinishReadNotes(); - + + /* + * Settlements + */ bool InitReadSettlements( uint32_t & numsettlements ); bool ReadSettlement(const int32_t index, t_settlement & settlement); bool ReadCurrentSettlement(t_settlement & settlement); void FinishReadSettlements(); + /* + * Hotkeys (DF's zoom locations) + */ bool InitReadHotkeys( ); bool ReadHotkeys(t_hotkey hotkeys[]); + /* + * Cursor, and view coords + */ + bool InitViewAndCursor(); bool getViewCoords (int32_t &x, int32_t &y, int32_t &z); bool setViewCoords (const int32_t x, const int32_t y, const int32_t z); bool getCursorCoords (int32_t &x, int32_t &y, int32_t &z); bool setCursorCoords (const int32_t x, const int32_t y, const int32_t z); - /// This returns false if there is nothing under the cursor, it puts the addresses in a vector if there is + /// get the creature vector index of the creature currently under DF' cursor bool getCurrentCursorCreature (uint32_t & creature_index); - + /* + * Window size in tiles + */ bool InitViewSize(); bool getWindowSize(int32_t & width, int32_t & height); - /* unimplemented - bool setWindowSize(const int32_t & width, const int32_t & height); - */ - bool getItemIndexesInBox(std::vector &indexes, - const uint16_t x1, const uint16_t y1, const uint16_t z1, - const uint16_t x2, const uint16_t y2, const uint16_t z2); /* - // FIXME: add a real creature class, move these - string getLastName(const uint32_t &index, bool); - string getSquadName(const uint32_t &index, bool); - string getProfession(const uint32_t &index); - string getCurrentJob(const uint32_t &index); - vector getSkills(const uint32_t &index); - vector getTraits(const uint32_t &index); - vector getLabors(const uint32_t &index); - */ + * DF translation tables and name translation + */ bool InitReadNameTables (std::vector< std::vector > & translations , std::vector< std::vector > & foreign_languages); void FinishReadNameTables(); - std::string TranslateName(const t_name & name,const std::vector< std::vector > & translations ,const std::vector< std::vector > & foreign_languages, bool inEnglish=true); - void WriteLabors(const uint32_t index, uint8_t labors[NUM_CREATURE_LABORS]); + /* + * Item reading + */ bool InitReadItems(uint32_t & numitems); + bool getItemIndexesInBox(std::vector &indexes, + const uint16_t x1, const uint16_t y1, const uint16_t z1, + const uint16_t x2, const uint16_t y2, const uint16_t z2); bool ReadItem(const uint32_t index, t_item & item); void FinishReadItems(); - + + /* + * Get the other API parts for raw access + */ memory_info *getMemoryInfo(); Process * getProcess(); DFWindow * getWindow(); diff --git a/library/DFTypes.h b/library/DFTypes.h index 6c6f3871e..3f38d6e29 100644 --- a/library/DFTypes.h +++ b/library/DFTypes.h @@ -724,6 +724,12 @@ enum e_designation designation_7 // whatever }; +enum e_liquidtype +{ + liquid_water, + liquid_magma +}; + struct naked_designation { unsigned int flow_size : 3; // how much liquid is here? @@ -753,7 +759,7 @@ struct naked_designation * 0 = water * 1 = magma */ - unsigned int liquid_type : 1; + e_liquidtype liquid_type : 1; unsigned int water_table : 1; // srsly. wtf? unsigned int rained : 1; // does this mean actual rain (as in the blue blocks) or a wet tile? e_traffic traffic : 2; // needs enum @@ -822,13 +828,18 @@ union t_occupancy naked_occupancy_grouped unibits; }; +typedef int16_t tiletypes40d [16][16]; +typedef DFHack::t_designation designations40d [16][16]; +typedef DFHack::t_occupancy occupancies40d [16][16]; +typedef uint8_t biome_indices40d [8]; + typedef struct { - int16_t tiletypes [16][16]; - DFHack::t_designation designaton [16][16]; - DFHack::t_occupancy occupancy [16][16]; + tiletypes40d tiletypes; + designations40d designation; + occupancies40d occupancy; // really a '7', but I use 8 to make it neater :) - uint8_t biome_indices [8]; + biome_indices40d biome_indices; uint32_t origin; // the address where it came from uint32_t dirty_dword; // bit 1 set means that the block is to be included in job checks } mapblock40d; diff --git a/tools/cleanmap.cpp b/tools/cleanmap.cpp index 3b0f6108a..5b057ce9a 100644 --- a/tools/cleanmap.cpp +++ b/tools/cleanmap.cpp @@ -13,7 +13,7 @@ int main (void) uint32_t x_max,y_max,z_max; uint32_t num_blocks = 0; uint32_t bytes_read = 0; - DFHack::t_occupancy occupancies[256]; + DFHack::occupancies40d occupancies; DFHack::API DF ("Memory.xml"); if(!DF.Attach()) @@ -34,14 +34,14 @@ int main (void) if(DF.isValidBlock(x,y,z)) { // read block designations - DF.ReadOccupancy(x,y,z, (uint32_t *) occupancies); + DF.ReadOccupancy(x,y,z, &occupancies); // change the hidden flag to 0 - for (uint32_t i = 0; i < 256;i++) + for (uint32_t i = 0; i < 16;i++) for (uint32_t j = 0; j < 16;j++) { - occupancies[i].unibits.splatter = 0; + occupancies[i][j].unibits.splatter = 0; } // write the designations back - DF.WriteOccupancy(x,y,z, (uint32_t *) occupancies); + DF.WriteOccupancy(x,y,z, &occupancies); } } } diff --git a/tools/digger.cpp b/tools/digger.cpp index 4020f0e00..c347e38dd 100644 --- a/tools/digger.cpp +++ b/tools/digger.cpp @@ -136,8 +136,8 @@ int dig(DFHack::API& DF, return 0; // max limit of 0, nothing to do uint32_t x_max,y_max,z_max; - DFHack::t_designation designations[16][16]; - uint16_t tiles[16][16]; + DFHack::designations40d designations; + DFHack::tiletypes40d tiles; DF.getSize(x_max,y_max,z_max); // every tile found, will later be sorted by distance to source @@ -156,8 +156,8 @@ int dig(DFHack::API& DF, if(DF.isValidBlock(x,y,z)) { // read block designations and tiletype - DF.ReadDesignations(x,y,z, (uint32_t *) designations); - DF.ReadTileTypes(x,y,z, (uint16_t *) tiles); + DF.ReadDesignations(x,y,z, &designations); + DF.ReadTileTypes(x,y,z, &tiles); // search all tiles for dig targets: // visible, not yet marked for dig and matching tile type @@ -210,9 +210,9 @@ int dig(DFHack::API& DF, } // TODO this could probably be made much better, theres a big chance the trees are on the same grid - DF.ReadDesignations((*i).grid_x, (*i).grid_y, (*i).z, (uint32_t *) designations); + DF.ReadDesignations((*i).grid_x, (*i).grid_y, (*i).z, &designations); 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, &designations); // Mark as dirty so the jobs are properly picked up by the dwarves DF.WriteDirtyBit((*i).grid_x, (*i).grid_y, (*i).z, true); diff --git a/tools/prospector.cpp b/tools/prospector.cpp index 2427979c7..ec037db4e 100644 --- a/tools/prospector.cpp +++ b/tools/prospector.cpp @@ -46,9 +46,9 @@ int main (int argc, const char* argv[]) showhidden = true; #endif uint32_t x_max,y_max,z_max; - uint16_t tiletypes[16][16]; - DFHack::t_designation designations[16][16]; - uint8_t regionoffsets[16]; + DFHack::tiletypes40d tiletypes; + DFHack::designations40d designations; + DFHack::biome_indices40d regionoffsets; map materials; materials.clear(); vector stonetypes; @@ -97,8 +97,8 @@ int main (int argc, const char* argv[]) continue; // read data - DF.ReadTileTypes(x,y,z, (uint16_t *) tiletypes); - DF.ReadDesignations(x,y,z, (uint32_t *) designations); + DF.ReadTileTypes(x,y,z, &tiletypes); + DF.ReadDesignations(x,y,z, &designations); memset(tempvein, -1, sizeof(tempvein)); veins.clear(); @@ -106,7 +106,7 @@ int main (int argc, const char* argv[]) if(showbaselayers) { - DF.ReadRegionOffsets(x,y,z, regionoffsets); + DF.ReadRegionOffsets(x,y,z, ®ionoffsets); // get the layer materials for(uint32_t xx = 0;xx<16;xx++) { diff --git a/tools/reveal.cpp b/tools/reveal.cpp index a469adbe2..48f3302a3 100644 --- a/tools/reveal.cpp +++ b/tools/reveal.cpp @@ -11,7 +11,7 @@ using namespace std; int main (void) { uint32_t x_max,y_max,z_max; - DFHack::t_designation designations[256]; + DFHack::designations40d designations; DFHack::API DF("Memory.xml"); if(!DF.Attach()) @@ -32,14 +32,14 @@ int main (void) if(DF.isValidBlock(x,y,z)) { // read block designations - DF.ReadDesignations(x,y,z, (uint32_t *) designations); + DF.ReadDesignations(x,y,z, &designations); // change the hidden flag to 0 - for (uint32_t i = 0; i < 256;i++) + for (uint32_t i = 0; i < 16;i++) for (uint32_t j = 0; j < 16;j++) { - designations[i].bits.hidden = 0; + designations[i][j].bits.hidden = 0; } // write the designations back - DF.WriteDesignations(x,y,z, (uint32_t *) designations); + DF.WriteDesignations(x,y,z, &designations); } } }