From 4bb724cd6c16fc8c06069183883d8af70e19a0ef Mon Sep 17 00:00:00 2001 From: Quietust Date: Thu, 19 Jan 2012 14:11:52 -0600 Subject: [PATCH] Significant cleanup of Maps module - next step will be to kill it properly --- .../block_square_event_mineralst.methods.inc | 19 + library/include/modules/MapCache.h | 28 +- library/include/modules/Maps.h | 428 ++------------- library/modules/Maps.cpp | 491 +++++------------- plugins/autodump.cpp | 8 +- plugins/filltraffic.cpp | 34 +- plugins/liquids.cpp | 25 +- plugins/probe.cpp | 44 +- plugins/prospector.cpp | 12 +- plugins/reveal.cpp | 12 +- plugins/tiletypes.cpp | 7 +- plugins/tubefill.cpp | 2 +- plugins/vdig.cpp | 92 ++-- 13 files changed, 319 insertions(+), 883 deletions(-) create mode 100644 library/include/df/custom/block_square_event_mineralst.methods.inc diff --git a/library/include/df/custom/block_square_event_mineralst.methods.inc b/library/include/df/custom/block_square_event_mineralst.methods.inc new file mode 100644 index 000000000..732eeaa1d --- /dev/null +++ b/library/include/df/custom/block_square_event_mineralst.methods.inc @@ -0,0 +1,19 @@ +inline bool getassignment( DFCoord & xy ) +{ + return getassignment(xy.x,xy.y); +} +inline bool getassignment( int x, int y ) +{ + return (tile_bitmask[y] & (1 << x)); +} +inline void setassignment( DFCoord & xy, bool bit ) +{ + return setassignment(xy.x,xy.y, bit); +} +inline void setassignment( int x, int y, bool bit ) +{ + if(bit) + tile_bitmask[y] |= (1 << x); + else + tile_bitmask[y] &= 0xFFFF ^ (1 << x); +} \ No newline at end of file diff --git a/library/include/modules/MapCache.h b/library/include/modules/MapCache.h index ad6b91e96..1426b5c04 100644 --- a/library/include/modules/MapCache.h +++ b/library/include/modules/MapCache.h @@ -30,12 +30,14 @@ distribution. #include "TileTypes.h" #include #include +#include "df/map_block.h" +#include "df/block_square_event_mineralst.h" namespace MapExtras { void SquashVeins (DFHack::Maps *m, DFHack::DFCoord bcoord, DFHack::mapblock40d & mb, DFHack::t_blockmaterials & materials) { memset(materials,-1,sizeof(materials)); - std::vector veins; + std::vector veins; m->SortBlockEvents(bcoord.x,bcoord.y,bcoord.z,&veins); //iterate through block rows for(uint32_t j = 0;j<16;j++) @@ -48,9 +50,9 @@ void SquashVeins (DFHack::Maps *m, DFHack::DFCoord bcoord, DFHack::mapblock40d & { for(int i = (int) veins.size() - 1; i >= 0;i--) { - if(!!(((1 << k) & veins[i]->assignment[j]) >> k)) + if(!!(((1 << k) & veins[i]->tile_bitmask[j]) >> k)) { - materials[k][j] = veins[i]->type; + materials[k][j] = veins[i]->inorganic_mat; i = -1; } } @@ -152,11 +154,11 @@ class Block return true; } - DFHack::t_designation DesignationAt(DFHack::DFCoord p) + df::tile_designation DesignationAt(DFHack::DFCoord p) { return raw.designation[p.x][p.y]; } - bool setDesignationAt(DFHack::DFCoord p, DFHack::t_designation des) + bool setDesignationAt(DFHack::DFCoord p, df::tile_designation des) { if(!valid) return false; dirty_designations = true; @@ -170,11 +172,11 @@ class Block return true; } - DFHack::t_occupancy OccupancyAt(DFHack::DFCoord p) + df::tile_occupancy OccupancyAt(DFHack::DFCoord p) { return raw.occupancy[p.x][p.y]; } - bool setOccupancyAt(DFHack::DFCoord p, DFHack::t_occupancy des) + bool setOccupancyAt(DFHack::DFCoord p, df::tile_occupancy des) { if(!valid) return false; dirty_occupancies = true; @@ -373,18 +375,18 @@ class MapCache return 0; } - DFHack::t_designation designationAt (DFHack::DFCoord tilecoord) + df::tile_designation designationAt (DFHack::DFCoord tilecoord) { Block * b= BlockAt(tilecoord / 16); if(b && b->valid) { return b->DesignationAt(tilecoord % 16); } - DFHack:: t_designation temp; + df::tile_designation temp; temp.whole = 0; return temp; } - bool setDesignationAt (DFHack::DFCoord tilecoord, DFHack::t_designation des) + bool setDesignationAt (DFHack::DFCoord tilecoord, df::tile_designation des) { Block * b= BlockAt(tilecoord / 16); if(b && b->valid) @@ -395,18 +397,18 @@ class MapCache return false; } - DFHack::t_occupancy occupancyAt (DFHack::DFCoord tilecoord) + df::tile_occupancy occupancyAt (DFHack::DFCoord tilecoord) { Block * b= BlockAt(tilecoord / 16); if(b && b->valid) { return b->OccupancyAt(tilecoord % 16); } - DFHack:: t_occupancy temp; + df::tile_occupancy temp; temp.whole = 0; return temp; } - bool setOccupancyAt (DFHack::DFCoord tilecoord, DFHack::t_occupancy occ) + bool setOccupancyAt (DFHack::DFCoord tilecoord, df::tile_occupancy occ) { Block * b= BlockAt(tilecoord / 16); if(b && b->valid) diff --git a/library/include/modules/Maps.h b/library/include/modules/Maps.h index 9d60f33e5..032e8aa93 100644 --- a/library/include/modules/Maps.h +++ b/library/include/modules/Maps.h @@ -36,7 +36,20 @@ distribution. #include #include "Virtual.h" #include "BitArray.h" -#include "Materials.h" +#include "modules/Materials.h" + +#include "df/world.h" +#include "df/feature_type.h" +#include "df/map_block.h" +#include "df/block_square_event.h" +#include "df/block_square_event_mineralst.h" +#include "df/block_square_event_frozen_liquidst.h" +#include "df/block_square_event_world_constructionst.h" +#include "df/block_square_event_material_spatterst.h" +#include "df/block_square_event_grassst.h" +#include "df/tile_liquid.h" +#include "df/tile_dig_designation.h" +#include "df/tile_traffic.h" /** * \defgroup grp_maps Maps module and its types @@ -48,21 +61,11 @@ namespace DFHack /*************************************************************************** T Y P E S ***************************************************************************/ - /** - * \ingroup grp_maps - */ - enum e_feature - { - feature_Other, - feature_Adamantine_Tube, - feature_Underworld, - feature_Hell_Temple - }; /** * Function for translating feature index to its name * \ingroup grp_maps */ - extern DFHACK_EXPORT const char * sa_feature(e_feature index); + extern DFHACK_EXPORT const char * sa_feature(df::feature_type index); /** * Class for holding a world coordinate. Can do math with coordinates and can be used as an index for std::map @@ -141,7 +144,7 @@ namespace DFHack */ struct t_feature { - e_feature type; + df::feature_type type; /// main material type - decides between stuff like bodily fluids, inorganics, vomit, amber, etc. int16_t main_material; /// generally some index to a vector of material types. @@ -152,97 +155,6 @@ namespace DFHack void * origin; }; - - /** - * mineral vein object - bitmap with a material type - * \ingroup grp_maps - */ - struct t_vein : public t_virtual - { - /// index into the inorganic material vector - int32_t type; - /// bit mask describing how the vein maps to the map block - /// assignment[y] & (1 << x) describes the tile (x, y) of the block - int16_t assignment[16]; - uint32_t flags; // FIXME: figure those out - - //zilpin: Functions to more conveniently check the assignment flags of the vein. - //Coordinates are given in tile within the block. - //Important to make these inline. - inline bool getassignment( DFCoord & xy ) - { - return getassignment(xy.x,xy.y); - } - inline bool getassignment( int x, int y ) - { - return (assignment[y] & (1 << x)); - } - inline void setassignment( DFCoord & xy, bool bit ) - { - return setassignment(xy.x,xy.y, bit); - } - inline void setassignment( int x, int y, bool bit ) - { - if(bit) - assignment[y] |= (1 << x); - else - assignment[y] &= 0xFFFF ^ (1 << x); - } - }; - - /** - * stores what tiles should appear when the ice melts - bitmap of material types - * \ingroup grp_maps - */ - struct t_frozenliquidvein : public t_virtual - { - /// a 16x16 array of the original tile types - int16_t tiles[16][16]; - }; - /** - * a 'spattervein' defines what coverings the individual map tiles have (snow, blood, etc) - * bitmap of intensity with matrial type - * \ingroup grp_maps - * @see PrintSplatterType - */ - struct t_spattervein : public t_virtual - { - /// generic material. - t_materialType mat1; - /// material vector index - t_materialIndex mat2; - /** - * matter state - liquid/solid/etc. - * @ref e_matter_state - */ - uint16_t matter_state; - /// 16x16 array of covering 'intensity' - uint8_t intensity[16][16]; - }; - /** - * a 'grass vein' defines the grass coverage of a map block - * bitmap of density (max = 100) with plant material type - * \ingroup grp_maps - */ - struct t_grassvein : public t_virtual - { - /// material vector index - t_materialIndex material; - /// 16x16 array of covering 'intensity' - uint8_t intensity[16][16]; - }; - /** - * defines the world constructions present. The material member is a mystery. - * \ingroup grp_maps - */ - struct t_worldconstruction : public t_virtual - { - /// material vector index - uint32_t material; - /// 16x16 array of bits - uint16_t assignment[16]; - }; - /** * \ingroup grp_maps */ @@ -260,184 +172,6 @@ namespace DFHack eBiomeCount }; - /** - * \ingroup grp_maps - */ - enum e_traffic - { - traffic_normal, - traffic_low, - traffic_high, - traffic_restricted - }; - - /** - * type of a designation for a tile - * \ingroup grp_maps - */ - enum e_designation - { - /// no designation - designation_no, - /// dig walls, remove stairs and ramps, gather plants, fell trees. depends on tile type - designation_default, - /// dig up/down stairs - designation_ud_stair, - /// dig a channel - designation_channel, - /// dig ramp out of a wall - designation_ramp, - /// dig a stair down - designation_d_stair, - /// dig a stair up - designation_u_stair, - /// whatever. for completenes I guess - designation_7 - }; - - /** - * type of liquid in a tile - * \ingroup grp_maps - */ - enum e_liquidtype - { - liquid_water, - liquid_magma - }; - - /** - * designation bit field - * \ingroup grp_maps - */ - struct naked_designation - { - unsigned int flow_size : 3; // how much liquid is here? - unsigned int pile : 1; // stockpile? - /// All the different dig designations - e_designation dig : 3; - unsigned int smooth : 2; - unsigned int hidden : 1; - - /** - * This one is rather involved, but necessary to retrieve the base layer matgloss index - * @see http://www.bay12games.com/forum/index.php?topic=608.msg253284#msg253284 - */ - unsigned int geolayer_index :4; - unsigned int light : 1; - unsigned int subterranean : 1; // never seen the light of day? - unsigned int skyview : 1; // sky is visible now, it rains in here when it rains - - /** - * Probably similar to the geolayer_index. Only with a different set of offsets and different data. - * we don't use this yet - */ - unsigned int biome : 4; - /** - * 0 = water - * 1 = magma - */ - 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; - /// the tile is not evaluated when calculating flows? - unsigned int flow_forbid : 1; - /// no liquid spreading - unsigned int liquid_static : 1; - /// this tile is a part of a local feature. can be combined with 'featstone' tiles - unsigned int feature_local : 1; - /// this tile is a part of a global feature. can be combined with 'featstone' tiles - unsigned int feature_global : 1; - unsigned int water_stagnant : 1; - unsigned int water_salt : 1; - }; - /** - * designation bit field wrapper - * \ingroup grp_maps - */ - union t_designation - { - uint32_t whole; - naked_designation bits; - }; - - /** - * occupancy flags (rat,dwarf,horse,built wall,not build wall,etc) - * \ingroup grp_maps - */ - struct naked_occupancy - { - /// 0-2: building type... should be an enum. - unsigned int building : 3;// 0-2 - /// 3: the tile contains a standing creature - unsigned int unit : 1; // 3 - /// 4: the tile contains a prone creature - unsigned int unit_grounded : 1; - /// 5: the tile contains an item - unsigned int item : 1; - /// 6: set on magma sea tiles, cavern lake tiles, rivers. not set on pools. probably something like 'inhibit growth'? - unsigned int unk6 : 1; - /// 7: mossy! - unsigned int moss : 1; - /// 8-11: arrow color. 0 = no arrow - unsigned int arrow_color : 4; - /// 12: arrow orientaton - unsigned int broken_arrows_variant : 1; - /// 13 - unsigned int unk13 : 1; - /// 14: A monster lair. Items placed won't be moved. - unsigned int monster_lair : 1; - /** - * 15: seems to be set on terrain tiles where grass growth is impossible - * pebbles, boulders, rock floors in the middle of grass. also shrubs. but not trees - */ - unsigned int no_grow : 1; - /// 16 - unsigned int unk16 : 1; - /// 17 - unsigned int unk17 : 1; - /// 18 - unsigned int unk18 : 1; - /// 19 - unsigned int unk19 : 1; - - /// 20 - unsigned int unk20 : 1; - /// 21 - unsigned int unk21 : 1; - /// 22 - unsigned int unk22 : 1; - /// 23 - unsigned int unk23 : 1; - - /// 24 - unsigned int unk24 : 1; - /// 25 - unsigned int unk25 : 1; - /// 26 - unsigned int unk26 : 1; - /// 27 - unsigned int unk27 : 1; - - /// 28 - unsigned int unk28 : 1; - /// 29 - unsigned int unk29 : 1; - /// 30 - unsigned int unk30 : 1; - /// 31 - unsigned int unk31 : 1; - }; - /** - * occupancy flags (rat,dwarf,horse,built wall,not build wall,etc) wrapper - * \ingroup grp_maps - */ - union t_occupancy - { - uint32_t whole; - naked_occupancy bits; - }; - /** * map block flags * \ingroup grp_maps @@ -454,16 +188,6 @@ namespace DFHack /// rest of the flags is completely unknown unsigned int unk_2: 4; }; - enum e_block_flags - { - /// designated for jobs (digging and stuff like that) - BLOCK_DESIGNATED, - /// possibly related to the designated flag - BLOCK_UNKN1, - /// two flags required for liquid flow. - BLOCK_LIQUIDFLOW_1, - BLOCK_LIQUIDFLOW_2, - }; /** * map block flags wrapper * \ingroup grp_maps @@ -488,12 +212,12 @@ namespace DFHack * 16x16 array of designation flags * \ingroup grp_maps */ - typedef DFHack::t_designation designations40d [16][16]; + typedef df::tile_designation designations40d [16][16]; /** * 16x16 array of occupancy flags * \ingroup grp_maps */ - typedef DFHack::t_occupancy occupancies40d [16][16]; + typedef df::tile_occupancy occupancies40d [16][16]; /** * array of 16 biome indexes valid for the block * \ingroup grp_maps @@ -520,107 +244,15 @@ namespace DFHack /// values used for geology/biome assignment biome_indices40d biome_indices; /// the address where the block came from - uint32_t origin; + void * origin; t_blockflags blockflags; /// index into the global feature vector - int16_t global_feature; + int32_t global_feature; /// index into the local feature vector... complicated - int16_t local_feature; + int32_t local_feature; int32_t mystery; } mapblock40d; - // A raw DF block. - // one of the vector is the 'effects' vector. another should be item id/index vector - struct df_block - { - BitArray flags; - // how to handle this virtual mess? - std::vector block_events; - // no idea what these are - long unk1; - long unk2; - long unk3; - // feature indexes - signed long local_feature; // local feature index, -1 = no local feature - signed long global_feature; // global feature index, -1 = no global feature - signed long mystery; // no idea. couldn't manage to catch its use in debugger. - // more mysterious numbers - long unk4; - long unk5; - long unk6; - std::vector items; // item related - probly item IDs - std::vector effects; - signed long unk7; // -1 most of the time, another index? - unsigned long unk8; // again, index? - std::vector plants; - unsigned short map_x; - unsigned short map_y; - unsigned short map_z; - unsigned short region_x; - unsigned short region_y; - unsigned short tiletype[16][16]; // weird 2-byte alignment here - t_designation designation[16][16]; - t_occupancy occupancy[16][16]; - // following is uncertain, but total length should be fixed. - unsigned char unk9[16][16]; - unsigned long pathfinding[16][16]; - unsigned short unk10[16][16]; - unsigned short unk11[16][16]; - unsigned short unk12[16][16]; - // end uncertain section - unsigned short temperature_1[16][16]; - unsigned short temperature_2[16][16]; - // no idea again. needs research... - unsigned short unk13[16][16]; - unsigned short unk14[16][16]; - unsigned char region_offset[9]; - }; - template - struct df_array - { - inline T& operator[] (uint32_t index) - { - return array[index]; - }; - T * array; - }; - template - struct df_2darray - { - inline df_array& operator[] (uint32_t index) - { - return array[index]; - }; - df_array * array; - }; - template - struct df_3darray - { - inline df_2darray& operator[] (uint32_t index) - { - return array[index]; - }; - inline bool operator! () - { - return !array; - } - df_2darray * array; - }; - struct map_data - { - df_3darray map; - std::vector unk1; - void * unk2; - uint32_t x_size_blocks; - uint32_t y_size_blocks; - uint32_t z_size_blocks; - uint32_t x_size; - uint32_t y_size; - uint32_t z_size; - int32_t x_area_offset; - int32_t y_area_offset; - int32_t z_area_offset; - }; /** * The Maps module * \ingroup grp_modules @@ -629,9 +261,6 @@ namespace DFHack class DFHACK_EXPORT Maps : public Module { public: - // the map data of DF, as we know it. - map_data * mdata; - Maps(); ~Maps(); bool Start(); @@ -730,7 +359,8 @@ namespace DFHack /** * Get the map block or NULL if block is not valid */ - df_block * getBlock (uint32_t blockx, uint32_t blocky, uint32_t blockz); + df::map_block * getBlock (int32_t blockx, int32_t blocky, int32_t blockz); + df::map_block * getBlockAbs (int32_t x, int32_t y, int32_t z); /// copy 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); @@ -770,15 +400,15 @@ namespace DFHack /// sorts the block event vector into multiple vectors by type /// mineral veins, what's under ice, blood smears and mud bool SortBlockEvents(uint32_t x, uint32_t y, uint32_t z, - std::vector* veins, - std::vector* ices = 0, - std::vector* splatter = 0, - std::vector* grass = 0, - std::vector* constructions = 0 + std::vector* veins, + std::vector* ices = 0, + std::vector* splatter = 0, + std::vector* grass = 0, + std::vector* constructions = 0 ); /// remove a block event from the block by address - bool RemoveBlockEvent(uint32_t x, uint32_t y, uint32_t z, t_virtual * which ); + bool RemoveBlockEvent(uint32_t x, uint32_t y, uint32_t z, df::block_square_event * which ); /// read all plants in this block bool ReadVegetation(uint32_t x, uint32_t y, uint32_t z, std::vector*& plants); diff --git a/library/modules/Maps.cpp b/library/modules/Maps.cpp index 4d3dc1506..25eb10b15 100644 --- a/library/modules/Maps.cpp +++ b/library/modules/Maps.cpp @@ -40,6 +40,13 @@ using namespace std; #include "ModuleFactory.h" #include "Core.h" +#include "DataDefs.h" +#include "df/world_data.h" +#include "df/world_underground_region.h" +#include "df/feature_init.h" + +using df::global::world; + #define MAPS_GUARD if(!d->Started) throw DFHack::Error::ModuleNotInitialized(); using namespace DFHack; @@ -49,20 +56,32 @@ Module* DFHack::createMaps() return new Maps(); } -const char * DFHack::sa_feature(e_feature index) +const char * DFHack::sa_feature(df::feature_type index) { switch(index) { - case feature_Other: - return "Other"; - case feature_Adamantine_Tube: - return "Adamantine Tube"; - case feature_Underworld: - return "Underworld"; - case feature_Hell_Temple: - return "Hell Temple"; - default: - return "Unknown/Error"; + case df::feature_type::outdoor_river: + return "River"; + case df::feature_type::cave: + return "Cave"; + case df::feature_type::pit: + return "Pit"; + case df::feature_type::magma_pool: + return "Magma pool"; + case df::feature_type::volcano: + return "Volcano"; + case df::feature_type::deep_special_tube: + return "Adamantine deposit"; + case df::feature_type::deep_surface_portal: + return "Underworld portal"; + case df::feature_type::subterranean_from_layer: + return "Cavern"; + case df::feature_type::magma_core_from_layer: + return "Magma sea"; + case df::feature_type::feature_underworld_from_layer: + return "Underworld"; + default: + return "Unknown/Error"; } }; @@ -71,46 +90,8 @@ struct Maps::Private uint32_t worldSizeX, worldSizeY; uint32_t maps_module; - struct t_offsets - { - // FIXME: those need a rework really. Why did Toady use virtual inheritance for such vastly different types anyway? - void * vein_mineral_vptr; - void * vein_ice_vptr; - void * vein_spatter_vptr; - void * vein_grass_vptr; - void * vein_worldconstruction_vptr; - /* - GEOLOGY - */ - uint32_t world_regions;// mem->getAddress ("ptr2_region_array"); - uint32_t region_size;// = minfo->getHexValue ("region_size"); - uint32_t region_geo_index_offset;// = minfo->getOffset ("region_geo_index_off"); - uint32_t world_geoblocks_vector;// = minfo->getOffset ("geoblock_vector"); - uint32_t world_size_x;// = minfo->getOffset ("world_size_x"); - uint32_t world_size_y;// = minfo->getOffset ("world_size_y"); - uint32_t geolayer_geoblock_offset;// = minfo->getOffset ("geolayer_geoblock_offset"); - uint32_t type_inside_geolayer;// = mem->getOffset ("type_inside_geolayer"); - - /* - FEATURES - */ - // FIXME: replace with a struct pointer, eventually. needs to be mapped out first - char * world_data; - uint32_t local_f_start; // offset from world_data - // FIXME: replace by virtual function call - uint32_t local_material; - // FIXME: replace by virtual function call - uint32_t local_submaterial; - uint32_t global_vector; // offset from world_data - uint32_t global_funcptr; - // FIXME: replace by virtual function call - uint32_t global_material; - // FIXME: replace by virtual function call - uint32_t global_submaterial; - } offsets; Process * owner; - OffsetGroup *OG_vector; bool Inited; bool FeaturesStarted; bool Started; @@ -118,8 +99,6 @@ struct Maps::Private bool hasFeatures; bool hasVeggies; - set unknown_veins; - // map between feature address and the read object map local_feature_store; map > m_local_feature; @@ -136,62 +115,8 @@ Maps::Maps() d->Inited = d->FeaturesStarted = d->Started = false; DFHack::VersionInfo * mem = c.vinfo; - Private::t_offsets &off = d->offsets; d->hasFeatures = d->hasGeology = d->hasVeggies = true; - // get the offsets once here - OffsetGroup *OG_Maps = mem->getGroup("Maps"); - off.world_data = OG_Maps->getAddress("world_data"); - { - mdata = (map_data *) OG_Maps->getAddress ("map_data"); - off.world_size_x = OG_Maps->getOffset ("world_size_x_from_wdata"); - off.world_size_y = OG_Maps->getOffset ("world_size_y_from_wdata"); - try - { - OffsetGroup *OG_Geology = OG_Maps->getGroup("geology"); - off.world_regions = OG_Geology->getOffset ("ptr2_region_array_from_wdata"); - off.world_geoblocks_vector = OG_Geology->getOffset ("geoblock_vector_from_wdata"); - off.region_size = OG_Geology->getHexValue ("region_size"); - off.region_geo_index_offset = OG_Geology->getOffset ("region_geo_index_off"); - off.geolayer_geoblock_offset = OG_Geology->getOffset ("geolayer_geoblock_offset"); - off.type_inside_geolayer = OG_Geology->getOffset ("type_inside_geolayer"); - } - catch(Error::AllMemdef &) - { - d->hasGeology = false; - } - OffsetGroup *OG_global_features = OG_Maps->getGroup("features")->getGroup("global"); - OffsetGroup *OG_local_features = OG_Maps->getGroup("features")->getGroup("local"); - try - { - off.local_f_start = OG_local_features->getOffset("start_ptr_from_wdata"); - off.global_vector = OG_global_features->getOffset("vector_from_wdata"); - off.local_material = OG_local_features->getOffset("material"); - off.local_submaterial = OG_local_features->getOffset("submaterial"); - - off.global_funcptr = OG_global_features->getOffset("funcptr"); - off.global_material = OG_global_features->getOffset("material"); - off.global_submaterial = OG_global_features->getOffset("submaterial"); - } - catch(Error::AllMemdef &) - { - d->hasFeatures = false; - } - } - d->OG_vector = mem->getGroup("vector"); - - // these can (will) fail and will be found when looking at the actual veins later - // basically a cache - off.vein_ice_vptr = 0; - mem->resolveClassnameToVPtr("block_square_event_frozen_liquid", off.vein_ice_vptr); - off.vein_mineral_vptr = 0; - mem->resolveClassnameToVPtr("block_square_event_mineral",off.vein_mineral_vptr); - off.vein_spatter_vptr = 0; - mem->resolveClassnameToVPtr("block_square_event_material_spatterst",off.vein_spatter_vptr); - off.vein_grass_vptr = 0; - mem->resolveClassnameToVPtr("block_square_event_grassst",off.vein_grass_vptr); - off.vein_worldconstruction_vptr = 0; - mem->resolveClassnameToVPtr("block_square_event_world_constructionst",off.vein_worldconstruction_vptr); d->Inited = true; } @@ -215,19 +140,11 @@ bool Maps::Start() Finish(); Process *p = d->owner; - Private::t_offsets &off = d->offsets; - - // is there a map? - //uint32_t x_array_loc = p->readDWord (off.map_offset); - if (!mdata->map) - { - return false; - } // get the size - uint32_t & mx = mdata->x_size_blocks; - uint32_t & my = mdata->y_size_blocks; - uint32_t & mz = mdata->z_size_blocks; + int32_t & mx = world->map.x_count_block; + int32_t & my = world->map.y_count_block; + int32_t & mz = world->map.z_count_block; // test for wrong map dimensions if (mx == 0 || mx > 48 || my == 0 || my > 48 || mz == 0) @@ -245,18 +162,18 @@ bool Maps::Start() void Maps::getSize (uint32_t& x, uint32_t& y, uint32_t& z) { MAPS_GUARD - x = mdata->x_size_blocks; - y = mdata->y_size_blocks; - z = mdata->z_size_blocks; + x = world->map.x_count_block; + y = world->map.y_count_block; + z = world->map.z_count_block; } // getter for map position void Maps::getPosition (int32_t& x, int32_t& y, int32_t& z) { MAPS_GUARD - x = mdata->x_area_offset; - y = mdata->y_area_offset; - z = mdata->z_area_offset; + x = world->map.region_x; + y = world->map.region_y; + z = world->map.region_z; } bool Maps::Finish() @@ -268,19 +185,29 @@ bool Maps::Finish() * Block reading */ -df_block* Maps::getBlock (uint32_t x, uint32_t y, uint32_t z) +df::map_block* Maps::getBlock (int32_t blockx, int32_t blocky, int32_t blockz) { - MAPS_GUARD - if(x >= mdata->x_size_blocks || y >= mdata->y_size_blocks || z >= mdata->z_size_blocks) - return 0; - return mdata->map[x][y][z]; + if ((blockx < 0) || (blocky < 0) || (blockz < 0)) + return NULL; + if ((blockx >= world->map.x_count_block) || (blocky << 4 >= world->map.y_count_block) || (blockz >= world->map.z_count_block)) + return NULL; + return world->map.block_index[blockx][blocky][blockz]; +} + +df::map_block *Maps::getBlockAbs (int32_t x, int32_t y, int32_t z) +{ + if ((x < 0) || (y < 0) || (z < 0)) + return NULL; + if ((x >= world->map.x_count) || (y >= world->map.y_count) || (z >= world->map.z_count)) + return NULL; + return world->map.block_index[x >> 4][y >> 4][z]; } bool Maps::ReadBlock40d(uint32_t x, uint32_t y, uint32_t z, mapblock40d * buffer) { MAPS_GUARD Process *p = d->owner; - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { buffer->position = DFCoord(x,y,z); @@ -290,9 +217,9 @@ bool Maps::ReadBlock40d(uint32_t x, uint32_t y, uint32_t z, mapblock40d * buffer memcpy(buffer->biome_indices,block->region_offset, sizeof(block->region_offset)); buffer->global_feature = block->global_feature; buffer->local_feature = block->local_feature; - buffer->mystery = block->mystery; + buffer->mystery = block->unk2; // FIXME: not 64-bit safe - buffer->origin = (uint32_t) █ + buffer->origin = █ //uint32_t addr_of_struct = p->readDWord(addr); // FIXME: maybe truncates buffer->blockflags.whole = block->flags; @@ -308,7 +235,7 @@ bool Maps::ReadBlock40d(uint32_t x, uint32_t y, uint32_t z, mapblock40d * buffer bool Maps::ReadTileTypes (uint32_t x, uint32_t y, uint32_t z, tiletypes40d *buffer) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { memcpy(buffer, block->tiletype, sizeof(tiletypes40d)); @@ -320,7 +247,7 @@ bool Maps::ReadTileTypes (uint32_t x, uint32_t y, uint32_t z, tiletypes40d *buff bool Maps::WriteTileTypes (uint32_t x, uint32_t y, uint32_t z, tiletypes40d *buffer) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { memcpy(block->tiletype, buffer, sizeof(tiletypes40d)); @@ -335,10 +262,10 @@ bool Maps::WriteTileTypes (uint32_t x, uint32_t y, uint32_t z, tiletypes40d *buf bool Maps::ReadDirtyBit(uint32_t x, uint32_t y, uint32_t z, bool &dirtybit) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { - dirtybit = block->flags.is_set(BLOCK_DESIGNATED); + dirtybit = block->flags.is_set(df::block_flags::Designated); return true; } return false; @@ -347,10 +274,10 @@ bool Maps::ReadDirtyBit(uint32_t x, uint32_t y, uint32_t z, bool &dirtybit) bool Maps::WriteDirtyBit(uint32_t x, uint32_t y, uint32_t z, bool dirtybit) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { - block->flags.set(BLOCK_DESIGNATED,dirtybit); + block->flags.set(df::block_flags::Designated, dirtybit); return true; } return false; @@ -363,7 +290,7 @@ bool Maps::WriteDirtyBit(uint32_t x, uint32_t y, uint32_t z, bool dirtybit) bool Maps::ReadBlockFlags(uint32_t x, uint32_t y, uint32_t z, t_blockflags &blockflags) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { blockflags.whole = block->flags; @@ -375,7 +302,7 @@ bool Maps::ReadBlockFlags(uint32_t x, uint32_t y, uint32_t z, t_blockflags &bloc bool Maps::WriteBlockFlags(uint32_t x, uint32_t y, uint32_t z, t_blockflags blockflags) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { return (block->flags = blockflags.whole); @@ -389,7 +316,7 @@ bool Maps::WriteBlockFlags(uint32_t x, uint32_t y, uint32_t z, t_blockflags bloc bool Maps::ReadDesignations (uint32_t x, uint32_t y, uint32_t z, designations40d *buffer) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { memcpy(buffer, block->designation, sizeof(designations40d)); @@ -401,7 +328,7 @@ bool Maps::ReadDesignations (uint32_t x, uint32_t y, uint32_t z, designations40d bool Maps::WriteDesignations (uint32_t x, uint32_t y, uint32_t z, designations40d *buffer) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { memcpy(block->designation, buffer, sizeof(designations40d)); @@ -416,7 +343,7 @@ bool Maps::WriteDesignations (uint32_t x, uint32_t y, uint32_t z, designations40 bool Maps::ReadOccupancy (uint32_t x, uint32_t y, uint32_t z, occupancies40d *buffer) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { memcpy(buffer, block->occupancy, sizeof(occupancies40d)); @@ -428,7 +355,7 @@ bool Maps::ReadOccupancy (uint32_t x, uint32_t y, uint32_t z, occupancies40d *bu bool Maps::WriteOccupancy (uint32_t x, uint32_t y, uint32_t z, occupancies40d *buffer) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { memcpy(block->occupancy, buffer, sizeof(occupancies40d)); @@ -443,7 +370,7 @@ bool Maps::WriteOccupancy (uint32_t x, uint32_t y, uint32_t z, occupancies40d *b bool Maps::ReadTemperatures(uint32_t x, uint32_t y, uint32_t z, t_temperatures *temp1, t_temperatures *temp2) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { if(temp1) @@ -457,7 +384,7 @@ bool Maps::ReadTemperatures(uint32_t x, uint32_t y, uint32_t z, t_temperatures * bool Maps::WriteTemperatures (uint32_t x, uint32_t y, uint32_t z, t_temperatures *temp1, t_temperatures *temp2) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { if(temp1) @@ -475,7 +402,7 @@ bool Maps::WriteTemperatures (uint32_t x, uint32_t y, uint32_t z, t_temperatures bool Maps::ReadRegionOffsets (uint32_t x, uint32_t y, uint32_t z, biome_indices40d *buffer) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { memcpy(buffer, block->region_offset,sizeof(biome_indices40d)); @@ -501,45 +428,22 @@ bool Maps::StartFeatures() MAPS_GUARD if(d->FeaturesStarted) return true; if(!d->hasFeatures) return false; - // can't be used without a map! - if(!mdata->map) - return false; - - Process * p = d->owner; - Private::t_offsets &off = d->offsets; - char * base = 0; - char * global_feature_vector = 0; - - char * world = p->readPtr( (void *) off.world_data); - if(!world) return false; - base = p->readPtr(world + off.local_f_start); - global_feature_vector = p->readPtr(off.world_data) + off.global_vector; - - // deref pointer to the humongo-structure - if(!base) - return false; // regionX and regionY are in embark squares! // we convert to full region tiles // this also works in adventure mode // region X coord - whole regions - const uint32_t sizeof_vec = d->OG_vector->getHexValue("sizeof"); - const uint32_t sizeof_elem = 16; - const uint32_t offset_elem = 4; - const uint32_t loc_main_mat_offset = off.local_material; - const uint32_t loc_sub_mat_offset = off.local_submaterial; - const uint32_t sizeof_16vec = 16* sizeof_vec; - for(uint32_t blockX = 0; blockX < mdata->x_size_blocks; blockX ++) - for(uint32_t blockY = 0; blockY < mdata->y_size_blocks; blockY ++) + for(uint32_t blockX = 0; blockX < world->map.x_count_block; blockX ++) + for(uint32_t blockY = 0; blockY < world->map.y_count_block; blockY ++) { // regionX and regionY are in embark squares! // we convert to full region tiles // this also works in adventure mode // region X coord - whole regions - uint32_t region_x = ( (blockX / 3) + mdata->x_area_offset ) / 16; + uint32_t region_x = ( (blockX / 3) + world->map.region_x ) / 16; // region Y coord - whole regions - uint32_t region_y = ( (blockY / 3) + mdata->y_area_offset ) / 16; + uint32_t region_y = ( (blockY / 3) + world->map.region_y ) / 16; uint32_t bigregion_x = region_x / 16; uint32_t bigregion_y = region_y / 16; uint32_t sub_x = region_x % 16; @@ -548,19 +452,16 @@ bool Maps::StartFeatures() // base = pointer to local feature structure (inside world data struct) // bigregion is 16x16 regions. for each bigregion in X dimension: - char * mega_column = p->readPtr(base + bigregion_x * 4); - // 16B structs, second DWORD of the struct is a pointer - char * loc_f_array16x16 = p->readPtr(mega_column + offset_elem + (sizeof_elem * bigregion_y)); - if(loc_f_array16x16) + if(world->world_data->unk_204[bigregion_x][bigregion_y].features) { - vector * p_features = (vector *) (loc_f_array16x16 + sizeof_16vec * sub_x + sizeof_vec * sub_y); - uint32_t size = p_features->size(); + vector *features = &world->world_data->unk_204[bigregion_x][bigregion_y].features->feature_init[sub_x][sub_y]; + uint32_t size = features->size(); DFCoord pc(blockX,blockY); std::vector tempvec; for(uint32_t i = 0; i < size; i++) { - char * cur_ptr = p_features->at(i); + df::feature_init * cur_ptr = features->at(i); map ::iterator it; it = d->local_feature_store.find(cur_ptr); @@ -573,30 +474,11 @@ bool Maps::StartFeatures() // no? else { - //FIXME: replace with accessors - // create, add to store t_feature tftemp; - tftemp.discovered = false; //= p->readDWord(cur_ptr + 4); - tftemp.origin = (t_feature *) cur_ptr; - string name = p->readClassName((void *)p->readDWord( cur_ptr )); - if(name == "feature_init_deep_special_tubest") - { - tftemp.main_material = p->readWord( cur_ptr + loc_main_mat_offset ); - tftemp.sub_material = p->readDWord( cur_ptr + loc_sub_mat_offset ); - tftemp.type = feature_Adamantine_Tube; - } - else if(name == "feature_init_deep_surface_portalst") - { - tftemp.main_material = p->readWord( cur_ptr + loc_main_mat_offset ); - tftemp.sub_material = p->readDWord( cur_ptr + loc_sub_mat_offset ); - tftemp.type = feature_Hell_Temple; - } - else - { - tftemp.main_material = -1; - tftemp.sub_material = -1; - tftemp.type = feature_Other; - } + tftemp.discovered = false; + tftemp.origin = cur_ptr; + tftemp.type = cur_ptr->getType(); + cur_ptr->getMaterial(&tftemp.main_material, &tftemp.sub_material); d->local_feature_store[cur_ptr] = tftemp; // push pointer tempvec.push_back(&(d->local_feature_store[cur_ptr])); @@ -605,35 +487,19 @@ bool Maps::StartFeatures() d->m_local_feature[pc] = tempvec; } } - // deref pointer to the humongo-structure - const uint32_t global_feature_funcptr = off.global_funcptr; - const uint32_t glob_main_mat_offset = off.global_material; - const uint32_t glob_sub_mat_offset = off.global_submaterial; - vector * p_features = (vector *) global_feature_vector; + + // enumerate global features + uint32_t size = world->world_data->underground_regions.size(); d->v_global_feature.clear(); - uint32_t size = p_features->size(); d->v_global_feature.reserve(size); - for(uint32_t i = 0; i < size; i++) + for (uint32_t i = 0; i < size; i++) { t_feature temp; - char * feat_ptr = p->readPtr(p_features->at(i) + global_feature_funcptr ); + df::feature_init * feat_ptr = world->world_data->underground_regions[i]->feature_init; temp.origin = feat_ptr; temp.discovered = false; - - // FIXME: use the memory_info cache mechanisms - string name = p->readClassName((void *)p->readDWord( feat_ptr)); - if(name == "feature_init_underworld_from_layerst") - { - temp.main_material = p->readWord( feat_ptr + glob_main_mat_offset ); - temp.sub_material = p->readDWord( feat_ptr + glob_sub_mat_offset ); - temp.type = feature_Underworld; - } - else - { - temp.main_material = -1; - temp.sub_material = -1; - temp.type = feature_Other; - } + temp.type = feat_ptr->getType(); + feat_ptr->getMaterial(&temp.main_material, &temp.sub_material); d->v_global_feature.push_back(temp); } d->FeaturesStarted = true; @@ -663,7 +529,7 @@ std::vector * Maps::GetLocalFeatures(DFCoord coord) bool Maps::ReadFeatures(uint32_t x, uint32_t y, uint32_t z, int16_t & local, int16_t & global) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { local = block->local_feature; @@ -676,7 +542,7 @@ bool Maps::ReadFeatures(uint32_t x, uint32_t y, uint32_t z, int16_t & local, int bool Maps::WriteFeatures(uint32_t x, uint32_t y, uint32_t z, const int16_t & local, const int16_t & global) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { block->local_feature = local; @@ -737,7 +603,7 @@ bool Maps::ReadFeatures(mapblock40d * block, t_feature ** local, t_feature ** gl bool Maps::SetBlockLocalFeature(uint32_t x, uint32_t y, uint32_t z, int16_t local) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { block->local_feature = local; @@ -749,7 +615,7 @@ bool Maps::SetBlockLocalFeature(uint32_t x, uint32_t y, uint32_t z, int16_t loca bool Maps::SetBlockGlobalFeature(uint32_t x, uint32_t y, uint32_t z, int16_t global) { MAPS_GUARD - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if (block) { block->global_feature = global; @@ -761,112 +627,63 @@ bool Maps::SetBlockGlobalFeature(uint32_t x, uint32_t y, uint32_t z, int16_t glo /* * Block events */ -bool Maps::SortBlockEvents(uint32_t x, uint32_t y, uint32_t z, vector * veins, vector * ices, vector *splatter, vector *grass, vector *constructions) +bool Maps::SortBlockEvents(uint32_t x, uint32_t y, uint32_t z, + vector * veins, + vector * ices, + vector *splatter, + vector *grass, + vector *constructions) { MAPS_GUARD Process* p = d->owner; - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if(veins) veins->clear(); if(ices) ices->clear(); if(splatter) splatter->clear(); if(grass) grass->clear(); if(constructions) constructions->clear(); - Private::t_offsets &off = d->offsets; if (!block) return false; uint32_t size = block->block_events.size(); // read all veins for (uint32_t i = 0; i < size;i++) { - retry: - // read the vein pointer from the vector - t_virtual * temp = block->block_events[i]; - void * type = temp->vptr; - if(type == (void *) off.vein_mineral_vptr) - { - if(!veins) continue; - // store it in the vector - veins->push_back ((t_vein *) temp); - } - else if(type == (void *) off.vein_ice_vptr) - { - if(!ices) continue; - ices->push_back ((t_frozenliquidvein *) temp); - } - else if(type == (void *) off.vein_spatter_vptr) - { - if(!splatter) continue; - splatter->push_back ( (t_spattervein *)temp); - } - else if(type == (void *) off.vein_grass_vptr) + df::block_square_event *evt = block->block_events[i]; + switch (evt->getType()) { - if(!grass) continue; - grass->push_back ((t_grassvein *) temp); - } - else if(type == (void *) off.vein_worldconstruction_vptr) - { - if(!constructions) continue; - constructions->push_back ((t_worldconstruction *) temp); - } - // previously unseen type of vein - else - { - string cname = p->readClassName(type); - //string cname = typeid(*(blockevent *)temp).name(); - //Core::getInstance().con.printerr("%s\n",cname.c_str()); - if(!off.vein_ice_vptr && cname == "block_square_event_frozen_liquidst") - { - off.vein_ice_vptr = type; - //Core::getInstance().con.printerr("%s %x\n",cname.c_str(), type); - goto retry; - } - else if(!off.vein_mineral_vptr &&cname == "block_square_event_mineralst") - { - off.vein_mineral_vptr = type; - //Core::getInstance().con.printerr("%s %x\n",cname.c_str(), type); - goto retry; - } - else if(!off.vein_spatter_vptr && cname == "block_square_event_material_spatterst") - { - off.vein_spatter_vptr = type; - //Core::getInstance().con.printerr("%s %x\n",cname.c_str(), type); - goto retry; - } - else if(!off.vein_grass_vptr && cname=="block_square_event_grassst") - { - off.vein_grass_vptr = type; - //Core::getInstance().con.printerr("%s %x\n",cname.c_str(), type); - goto retry; - } - else if(!off.vein_worldconstruction_vptr && cname=="block_square_event_world_constructionst") - { - off.vein_worldconstruction_vptr = type; - //Core::getInstance().con.printerr("%s %x\n",cname.c_str(), type); - goto retry; - } -#ifdef DEBUG - else // this is something we've never seen before - { - if(!d->unknown_veins.count(type)) - { - cerr << "unknown vein " << cname << hex << " 0x" << temp << " block: 0x" << addr << dec << endl; - d->unknown_veins.insert(type); - } - } -#endif + case df::block_square_event_type::mineral: + if (veins) + veins->push_back((df::block_square_event_mineralst *)evt); + break; + case df::block_square_event_type::frozen_liquid: + if (ices) + ices->push_back((df::block_square_event_frozen_liquidst *)evt); + break; + case df::block_square_event_type::material_spatter: + if (splatter) + splatter->push_back((df::block_square_event_material_spatterst *)evt); + break; + case df::block_square_event_type::grass: + if (grass) + grass->push_back((df::block_square_event_grassst *)evt); + break; + case df::block_square_event_type::world_construction: + if (constructions) + constructions->push_back((df::block_square_event_world_constructionst *)evt); + break; } } return true; } -bool Maps::RemoveBlockEvent(uint32_t x, uint32_t y, uint32_t z, t_virtual * which) +bool Maps::RemoveBlockEvent(uint32_t x, uint32_t y, uint32_t z, df::block_square_event * which) { MAPS_GUARD Process* p = d->owner; - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if(block) { for(int i = 0; i < block->block_events.size();i++) @@ -889,21 +706,6 @@ bool Maps::ReadGeology (vector < vector >& assign) { MAPS_GUARD if(!d->hasGeology) return false; - Process *p = d->owner; - // get needed addresses and offsets. Now this is what I call crazy. - uint16_t worldSizeX, worldSizeY; - char *regions; - char *geoblocks_vector_addr; - Private::t_offsets &off = d->offsets; - // get world size - char * world = p->readPtr(off.world_data); - p->readWord (world + off.world_size_x, worldSizeX); - p->readWord (world + off.world_size_y, worldSizeY); - regions = p->readPtr ( world + off.world_regions); // ptr2_region_array - geoblocks_vector_addr = world + off.world_geoblocks_vector; - - // read the geoblock vector - vector & geoblocks = *(vector *)(geoblocks_vector_addr); // iterate over 8 surrounding regions + local region for (int i = eNorthWest; i < eBiomeCount; i++) @@ -912,43 +714,26 @@ bool Maps::ReadGeology (vector < vector >& assign) // regionX is in embark squares // regionX/16 is in 16x16 embark square regions // i provides -1 .. +1 offset from the current region - int bioRX = mdata->x_area_offset / 16 + ((i % 3) - 1); + int bioRX = world->map.region_x / 16 + ((i % 3) - 1); if (bioRX < 0) bioRX = 0; - if (bioRX >= worldSizeX) bioRX = worldSizeX - 1; - int bioRY = mdata->y_area_offset / 16 + ((i / 3) - 1); + if (bioRX >= world->world_data->world_width) bioRX = world->world_data->world_width - 1; + int bioRY = world->map.region_y / 16 + ((i / 3) - 1); if (bioRY < 0) bioRY = 0; - if (bioRY >= worldSizeY) bioRY = worldSizeY - 1; - - /// regions are a 2d array. consists of pointers to arrays of regions - /// regions are of region_size size - // get pointer to column of regions - char * geoX; - p->readPtr (regions + bioRX*4, geoX); + if (bioRY >= world->world_data->world_height) bioRY = world->world_data->world_height - 1; // get index into geoblock vector - uint16_t geoindex; - p->readWord (geoX + bioRY*off.region_size + off.region_geo_index_offset, geoindex); - - /// geology blocks are assigned to regions from a vector - // get the geoblock from the geoblock vector using the geoindex - // read the matgloss pointer from the vector into temp - char * geoblock_off = geoblocks[geoindex]; + uint16_t geoindex = world->world_data->unk_1c0[bioRX][bioRY].geo_index; /// geology blocks have a vector of layer descriptors // get the vector with pointer to layers - vector & geolayers = *(vector *)(geoblock_off + off.geolayer_geoblock_offset); - // make sure we don't load crap - assert (geolayers.size() > 0 && geolayers.size() <= 16); + vector *geolayers = &world->world_data->unk_190[geoindex]->unk_4; /// layer descriptor has a field that determines the type of stone/soil - d->v_geology[i].reserve (geolayers.size()); + d->v_geology[i].reserve (geolayers->size()); // finally, read the layer matgloss - for (uint32_t j = 0;j < geolayers.size();j++) + for (uint32_t j = 0;j < geolayers->size();j++) { - // read pointer to a layer - char * geol_offset = geolayers[j]; - // read word at pointer + 2, store in our geology vectors - d->v_geology[i].push_back (p->readWord (geol_offset + off.type_inside_geolayer)); + d->v_geology[i].push_back (geolayers->at(j)->unk_4); } } assign.clear(); @@ -988,10 +773,10 @@ bool Maps::ReadVegetation(uint32_t x, uint32_t y, uint32_t z, std::vectorhasVeggies || !d->Started) return false; - df_block * block = getBlock(x,y,z); + df::map_block * block = getBlock(x,y,z); if(!block) return false; - Private::t_offsets &off = d->offsets; - plants = &block->plants; + + plants = (vector *)&block->plants; return true; } diff --git a/plugins/autodump.cpp b/plugins/autodump.cpp index a7cebf7bb..e7775d36c 100644 --- a/plugins/autodump.cpp +++ b/plugins/autodump.cpp @@ -185,8 +185,8 @@ static command_result autodump_main(Core * c, vector & parameters) { // yes... cerr << "Moving from block to block!" << endl; - df_block * bl_src = Maps->getBlock(itm->pos.x /16, itm->pos.y/16, itm->pos.z); - df_block * bl_tgt = Maps->getBlock(cx /16, cy/16, cz); + df::map_block * bl_src = Maps->getBlock(itm->pos.x /16, itm->pos.y/16, itm->pos.z); + df::map_block * bl_tgt = Maps->getBlock(cx /16, cy/16, cz); if(bl_src) { std::remove(bl_src->items.begin(), bl_src->items.end(),itm->id); @@ -234,7 +234,7 @@ static command_result autodump_main(Core * c, vector & parameters) { if(it->second == 0) { - t_occupancy occ = MC.occupancyAt(it->first); + df::tile_occupancy occ = MC.occupancyAt(it->first); occ.bits.item = false; MC.setOccupancyAt(it->first, occ); } @@ -247,7 +247,7 @@ static command_result autodump_main(Core * c, vector & parameters) Block * b = MC.BlockAt(pos_cursor / 16); if(b) { - t_occupancy occ = MC.occupancyAt(pos_cursor); + df::tile_occupancy occ = MC.occupancyAt(pos_cursor); occ.bits.item = 1; MC.setOccupancyAt(pos_cursor,occ); } diff --git a/plugins/filltraffic.cpp b/plugins/filltraffic.cpp index b011bce2c..815f47613 100644 --- a/plugins/filltraffic.cpp +++ b/plugins/filltraffic.cpp @@ -57,8 +57,8 @@ DFhackCExport command_result filltraffic(DFHack::Core * c, std::vectordesignationAt(xy); + df::tile_designation des = MCache->designationAt(xy); int16_t tt = MCache->tiletypeAt(xy); - DFHack::t_occupancy oc; + df::tile_occupancy oc; if (checkbuilding) oc = MCache->occupancyAt(xy); - source = des.bits.traffic; + source = (df::tile_traffic)des.bits.traffic; if(source == target) { c->con.printerr("This tile is already set to the target traffic type.\n"); @@ -356,25 +356,25 @@ DFhackCExport command_result setAllMatching(DFHack::Core * c, checkTile checkPro //Unconditionally set map to target traffic type void allHigh(DFHack::DFCoord coord, MapExtras::MapCache * map) { - DFHack::t_designation des = map->designationAt(coord); - des.bits.traffic = traffic_high; + df::tile_designation des = map->designationAt(coord); + des.bits.traffic = df::tile_traffic::High; map->setDesignationAt(coord, des); } void allNormal(DFHack::DFCoord coord, MapExtras::MapCache * map) { - DFHack::t_designation des = map->designationAt(coord); - des.bits.traffic = traffic_normal; + df::tile_designation des = map->designationAt(coord); + des.bits.traffic = df::tile_traffic::Normal; map->setDesignationAt(coord, des); } void allLow(DFHack::DFCoord coord, MapExtras::MapCache * map) { - DFHack::t_designation des = map->designationAt(coord); - des.bits.traffic = traffic_low; + df::tile_designation des = map->designationAt(coord); + des.bits.traffic = df::tile_traffic::Low; map->setDesignationAt(coord, des); } void allRestricted(DFHack::DFCoord coord, MapExtras::MapCache * map) { - DFHack::t_designation des = map->designationAt(coord); - des.bits.traffic = traffic_restricted; + df::tile_designation des = map->designationAt(coord); + des.bits.traffic = df::tile_traffic::Restricted; map->setDesignationAt(coord, des); } diff --git a/plugins/liquids.cpp b/plugins/liquids.cpp index 4b6af8735..0b7904dbf 100644 --- a/plugins/liquids.cpp +++ b/plugins/liquids.cpp @@ -389,7 +389,7 @@ DFhackCExport command_result df_liquids (Core * c, vector & parameters) mcache.setTiletypeAt(*iter, 331); mcache.setTemp1At(*iter,10015); mcache.setTemp2At(*iter,10015); - DFHack::t_designation des = mcache.designationAt(*iter); + df::tile_designation des = mcache.designationAt(*iter); des.bits.flow_size = 0; mcache.setDesignationAt(*iter, des); iter ++; @@ -411,8 +411,8 @@ DFhackCExport command_result df_liquids (Core * c, vector & parameters) { mcache.setTiletypeAt(*iter, 90); - DFHack::t_designation a = mcache.designationAt(*iter); - a.bits.liquid_type = DFHack::liquid_water; + df::tile_designation a = mcache.designationAt(*iter); + a.bits.liquid_type = df::tile_liquid::Water; a.bits.liquid_static = false; a.bits.flow_size = 7; mcache.setTemp1At(*iter,10015); @@ -434,7 +434,7 @@ DFhackCExport command_result df_liquids (Core * c, vector & parameters) while (iter != all_tiles.end()) { DFHack::DFCoord current = *iter; - DFHack::t_designation des = mcache.designationAt(current); + df::tile_designation des = mcache.designationAt(current); des.bits.water_salt = false; des.bits.water_stagnant = false; mcache.setDesignationAt(current,des); @@ -455,9 +455,8 @@ DFhackCExport command_result df_liquids (Core * c, vector & parameters) iter ++; continue; } - DFHack::t_designation des = mcache.designationAt(current); + df::tile_designation des = mcache.designationAt(current); uint16_t tt = mcache.tiletypeAt(current); - DFHack::naked_designation & flow = des.bits; // don't put liquids into places where they don't belong... if(!DFHack::FlowPassable(tt)) { @@ -468,27 +467,27 @@ DFhackCExport command_result df_liquids (Core * c, vector & parameters) { if(setmode == "s.") { - flow.flow_size = amount; + des.bits.flow_size = amount; } else if(setmode == "s+") { - if(flow.flow_size < amount) - flow.flow_size = amount; + if(des.bits.flow_size < amount) + des.bits.flow_size = amount; } else if(setmode == "s-") { - if (flow.flow_size > amount) - flow.flow_size = amount; + if (des.bits.flow_size > amount) + des.bits.flow_size = amount; } if(amount != 0 && mode == "magma") { - flow.liquid_type = DFHack::liquid_magma; + des.bits.liquid_type = df::tile_liquid::Magma; mcache.setTemp1At(current,12000); mcache.setTemp2At(current,12000); } else if(amount != 0 && mode == "water") { - flow.liquid_type = DFHack::liquid_water; + des.bits.liquid_type = df::tile_liquid::Water; mcache.setTemp1At(current,10015); mcache.setTemp2At(current,10015); } diff --git a/plugins/probe.cpp b/plugins/probe.cpp index a56757dc4..b2b4e57d1 100644 --- a/plugins/probe.cpp +++ b/plugins/probe.cpp @@ -145,7 +145,7 @@ DFhackCExport command_result df_probe (Core * c, vector & parameters) } */ int16_t tiletype = mc.tiletypeAt(cursor); - naked_designation &des = block.designation[tileX][tileY].bits; + df::tile_designation &des = block.designation[tileX][tileY]; /* if(showDesig) { @@ -189,8 +189,8 @@ DFhackCExport command_result df_probe (Core * c, vector & parameters) con.print("temperature2: %d U\n",mc.temperature2At(cursor)); // biome, geolayer - con << "biome: " << des.biome << std::endl; - con << "geolayer: " << des.geolayer_index + con << "biome: " << des.bits.biome << std::endl; + con << "geolayer: " << des.bits.geolayer_index << std::endl; int16_t base_rock = mc.baseMaterialAt(cursor); if(base_rock != -1) @@ -217,33 +217,33 @@ DFhackCExport command_result df_probe (Core * c, vector & parameters) con << endl; } // liquids - if(des.flow_size) + if(des.bits.flow_size) { - if(des.liquid_type == DFHack::liquid_magma) + if(des.bits.liquid_type == df::tile_liquid::Magma) con <<"magma: "; else con <<"water: "; - con << des.flow_size << std::endl; + con << des.bits.flow_size << std::endl; } - if(des.flow_forbid) + if(des.bits.flow_forbid) con << "flow forbid" << std::endl; - if(des.pile) + if(des.bits.pile) con << "stockpile?" << std::endl; - if(des.rained) + if(des.bits.rained) con << "rained?" << std::endl; - if(des.smooth) + if(des.bits.smooth) con << "smooth?" << std::endl; - if(des.water_salt) + if(des.bits.water_salt) con << "salty" << endl; - if(des.water_stagnant) + if(des.bits.water_stagnant) con << "stagnant" << endl; #define PRINT_FLAG( X ) con.print("%-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 ); + PRINT_FLAG( bits.hidden ); + PRINT_FLAG( bits.light ); + PRINT_FLAG( bits.outside ); + PRINT_FLAG( bits.subterranean ); + PRINT_FLAG( bits.water_table ); + PRINT_FLAG( bits.rained ); DFCoord pc(blockX, blockY); @@ -252,7 +252,7 @@ DFhackCExport command_result df_probe (Core * c, vector & parameters) t_feature * local = 0; t_feature * global = 0; Maps->ReadFeatures(&(b->raw),&local,&global); - PRINT_FLAG( feature_local ); + PRINT_FLAG( bits.feature_local ); if(local) { con.print("%-16s", ""); @@ -261,7 +261,7 @@ DFhackCExport command_result df_probe (Core * c, vector & parameters) con.print(" addr 0x%X ", local->origin); con.print(" %s\n", sa_feature(local->type)); } - PRINT_FLAG( feature_global ); + PRINT_FLAG( bits.feature_global ); if(global) { con.print("%-16s", ""); @@ -272,8 +272,8 @@ DFhackCExport command_result df_probe (Core * c, vector & parameters) } else { - PRINT_FLAG( feature_local ); - PRINT_FLAG( feature_global ); + PRINT_FLAG( bits.feature_local ); + PRINT_FLAG( bits.feature_global ); } #undef PRINT_FLAG con << "local feature idx: " << block.local_feature diff --git a/plugins/prospector.cpp b/plugins/prospector.cpp index 8f76465ea..9246c0d89 100644 --- a/plugins/prospector.cpp +++ b/plugins/prospector.cpp @@ -321,8 +321,8 @@ DFhackCExport command_result prospector (DFHack::Core * c, vector & par for(uint32_t x = 0; x < 16; x++) { DFHack::DFCoord coord(x, y); - DFHack::t_designation des = b->DesignationAt(coord); - DFHack::t_occupancy occ = b->OccupancyAt(coord); + df::tile_designation des = b->DesignationAt(coord); + df::tile_occupancy occ = b->OccupancyAt(coord); // Skip hidden tiles if (!showHidden && des.bits.hidden) @@ -346,7 +346,7 @@ DFhackCExport command_result prospector (DFHack::Core * c, vector & par // Check for liquid if (des.bits.flow_size) { - if (des.bits.liquid_type == liquid_magma) + if (des.bits.liquid_type == df::tile_liquid::Magma) liquidMagma.add(global_z); else liquidWater.add(global_z); @@ -388,20 +388,20 @@ DFhackCExport command_result prospector (DFHack::Core * c, vector & par case DFHack::FEATSTONE: if (blockFeatureLocal && des.bits.feature_local) { - if (blockFeatureLocal->type == DFHack::feature_Adamantine_Tube + if (blockFeatureLocal->type == df::feature_type::deep_special_tube && blockFeatureLocal->main_material == 0) // stone { veinMats[blockFeatureLocal->sub_material].add(global_z); } else if (showTemple - && blockFeatureLocal->type == DFHack::feature_Hell_Temple) + && blockFeatureLocal->type == df::feature_type::deep_surface_portal) { hasDemonTemple = true; } } if (showSlade && blockFeatureGlobal && des.bits.feature_global - && blockFeatureGlobal->type == DFHack::feature_Underworld + && blockFeatureGlobal->type == df::feature_type::feature_underworld_from_layer && blockFeatureGlobal->main_material == 0) // stone { layerMats[blockFeatureGlobal->sub_material].add(global_z); diff --git a/plugins/reveal.cpp b/plugins/reveal.cpp index bafb6e40f..d0e72ff56 100644 --- a/plugins/reveal.cpp +++ b/plugins/reveal.cpp @@ -27,10 +27,10 @@ bool isSafe(uint32_t x, uint32_t y, uint32_t z, DFHack::Maps *Maps) return false; } // Adamantine tubes and temples lead to Hell - if (local_feature && local_feature->type != DFHack::feature_Other) + if (local_feature && (local_feature->type == df::feature_type::deep_special_tube || local_feature->type == df::feature_type::deep_surface_portal)) return false; // And Hell *is* Hell. - if (global_feature && global_feature->type == DFHack::feature_Underworld) + if (global_feature && global_feature->type == df::feature_type::feature_underworld_from_layer) return false; // otherwise it's safe. return true; @@ -192,7 +192,7 @@ DFhackCExport command_result reveal(DFHack::Core * c, std::vector & { for(uint32_t z = 0; z< z_max;z++) { - df_block *block = Maps->getBlock(x,y,z); + df::map_block *block = Maps->getBlock(x,y,z); if(block) { // in 'no-hell'/'safe' mode, don't reveal blocks with hell and adamantine @@ -288,7 +288,7 @@ DFhackCExport command_result unreveal(DFHack::Core * c, std::vector for(size_t i = 0; i < hidesaved.size();i++) { hideblock & hb = hidesaved[i]; - df_block * b = Maps->getBlock(hb.x,hb.y,hb.z); + df::map_block * b = Maps->getBlock(hb.x,hb.y,hb.z); for (uint32_t i = 0; i < 16;i++) for (uint32_t j = 0; j < 16;j++) { b->designation[i][j].bits.hidden = hb.hiddens[i][j]; @@ -391,7 +391,7 @@ DFhackCExport command_result revflood(DFHack::Core * c, std::vector { for(uint32_t z = 0; z< z_max;z++) { - df_block * b = Maps->getBlock(x,y,z); + df::map_block * b = Maps->getBlock(x,y,z); if(b) { // change the hidden flag to 0 @@ -419,7 +419,7 @@ DFhackCExport command_result revflood(DFHack::Core * c, std::vector if(!MCache->testCoord(current)) continue; int16_t tt = MCache->tiletypeAt(current); - t_designation des = MCache->designationAt(current); + df::tile_designation des = MCache->designationAt(current); if(!des.bits.hidden) { continue; diff --git a/plugins/tiletypes.cpp b/plugins/tiletypes.cpp index b20764447..e237f0fdd 100644 --- a/plugins/tiletypes.cpp +++ b/plugins/tiletypes.cpp @@ -19,6 +19,7 @@ using std::set; #include "modules/Gui.h" #include "TileTypes.h" #include "modules/MapCache.h" +#include "df/tile_dig_designation.h" using namespace MapExtras; using namespace DFHack; @@ -780,13 +781,13 @@ DFhackCExport command_result df_tiletypes (Core * c, vector & parameter for (coord_vec::iterator iter = all_tiles.begin(); iter != all_tiles.end(); ++iter) { const DFHack::TileRow *source = DFHack::getTileRow(map.tiletypeAt(*iter)); - DFHack::t_designation des = map.designationAt(*iter); + df::tile_designation des = map.designationAt(*iter); if ((filter.shape > -1 && filter.shape != source->shape) || (filter.material > -1 && filter.material != source->material) || (filter.special > -1 && filter.special != source->special) || (filter.variant > -1 && filter.variant != source->variant) - || (filter.dig > -1 && (filter.dig != 0) != (des.bits.dig != DFHack::designation_no)) + || (filter.dig > -1 && (filter.dig != 0) != (des.bits.dig != df::tile_dig_designation::No)) ) { continue; @@ -865,7 +866,7 @@ DFhackCExport command_result df_tiletypes (Core * c, vector & parameter if (paint.skyview > -1) { - des.bits.skyview = paint.skyview; + des.bits.outside = paint.skyview; } // Remove liquid from walls, etc diff --git a/plugins/tubefill.cpp b/plugins/tubefill.cpp index b0a371cf1..5d6514806 100644 --- a/plugins/tubefill.cpp +++ b/plugins/tubefill.cpp @@ -86,7 +86,7 @@ DFhackCExport command_result tubefill(DFHack::Core * c, std::vector { // we're looking for addy tubes if(!locf) continue; - if(locf->type != DFHack::feature_Adamantine_Tube) continue; + if(locf->type != df::feature_type::deep_special_tube) continue; dirty=0; Mapz->ReadDesignations(x,y,z, &designations); diff --git a/plugins/vdig.cpp b/plugins/vdig.cpp index 2f9daf7d8..b899b220c 100644 --- a/plugins/vdig.cpp +++ b/plugins/vdig.cpp @@ -70,7 +70,7 @@ enum circle_what bool dig (MapExtras::MapCache & MCache, circle_what what, - e_designation type, + df::tile_dig_designation type, int32_t x, int32_t y, int32_t z, int x_max, int y_max ) @@ -90,7 +90,7 @@ bool dig (MapExtras::MapCache & MCache, return false; } uint16_t tt = MCache.tiletypeAt(at); - t_designation des = MCache.designationAt(at); + df::tile_designation des = MCache.designationAt(at); // could be potentially used to locate hidden constructions? if(tileMaterial(tt) == CONSTRUCTED && !des.bits.hidden) return false; @@ -107,7 +107,7 @@ bool dig (MapExtras::MapCache & MCache, break; } if(isFloorTerrain(tt) - && (type == designation_d_stair || type == designation_channel) + && (type == df::tile_dig_designation::DownStair || type == df::tile_dig_designation::Channel) && ts != TREE_OK && ts != TREE_DEAD ) @@ -115,7 +115,7 @@ bool dig (MapExtras::MapCache & MCache, std::cerr << "allowing tt" << tt << ", is floor\n"; break; } - if(isStairTerrain(tt) && type == designation_channel ) + if(isStairTerrain(tt) && type == df::tile_dig_designation::Channel ) break; return false; } @@ -124,25 +124,25 @@ bool dig (MapExtras::MapCache & MCache, switch(what) { case circle_set: - if(des.bits.dig == designation_no) + if(des.bits.dig == df::tile_dig_designation::No) { des.bits.dig = type; } break; case circle_unset: - if (des.bits.dig != designation_no) + if (des.bits.dig != df::tile_dig_designation::No) { - des.bits.dig = designation_no; + des.bits.dig = df::tile_dig_designation::No; } break; case circle_invert: - if(des.bits.dig == designation_no) + if(des.bits.dig == df::tile_dig_designation::No) { des.bits.dig = type; } else { - des.bits.dig = designation_no; + des.bits.dig = df::tile_dig_designation::No; } break; } @@ -153,7 +153,7 @@ bool dig (MapExtras::MapCache & MCache, bool lineX (MapExtras::MapCache & MCache, circle_what what, - e_designation type, + df::tile_dig_designation type, int32_t y1, int32_t y2, int32_t x, int32_t z, int x_max, int y_max ) @@ -167,7 +167,7 @@ bool lineX (MapExtras::MapCache & MCache, bool lineY (MapExtras::MapCache & MCache, circle_what what, - e_designation type, + df::tile_dig_designation type, int32_t x1, int32_t x2, int32_t y, int32_t z, int x_max, int y_max ) @@ -183,7 +183,7 @@ DFhackCExport command_result digcircle (Core * c, vector & parameters) { static bool filled = false; static circle_what what = circle_set; - static e_designation type = designation_default; + static df::tile_dig_designation type = df::tile_dig_designation::Default; static int diameter = 0; auto saved_d = diameter; bool force_help = false; @@ -215,27 +215,27 @@ DFhackCExport command_result digcircle (Core * c, vector & parameters) } else if(parameters[i] == "dig") { - type = designation_default; + type = df::tile_dig_designation::Default; } else if(parameters[i] == "ramp") { - type = designation_ramp; + type = df::tile_dig_designation::Ramp; } else if(parameters[i] == "dstair") { - type = designation_d_stair; + type = df::tile_dig_designation::DownStair; } else if(parameters[i] == "ustair") { - type = designation_u_stair; + type = df::tile_dig_designation::UpStair; } else if(parameters[i] == "xstair") { - type = designation_ud_stair; + type = df::tile_dig_designation::UpDownStair; } else if(parameters[i] == "chan") { - type = designation_channel; + type = df::tile_dig_designation::Channel; } else if (!from_string(diameter,parameters[i], std::dec)) { @@ -732,7 +732,7 @@ bool stamp_pattern (DFHack::Maps * maps, int x_max, int y_max ) { - df_block * bl = maps->getBlock(bx,by,z_level); + df::map_block * bl = maps->getBlock(bx,by,z_level); if(!bl) return false; int x = 0,mx = 16; @@ -749,34 +749,34 @@ bool stamp_pattern (DFHack::Maps * maps, my = 15; for(; y < my; y++) { - naked_designation & des = bl->designation[x][y].bits; + df::tile_designation & des = bl->designation[x][y]; short unsigned int tt = bl->tiletype[x][y]; // could be potentially used to locate hidden constructions? - if(tileMaterial(tt) == CONSTRUCTED && !des.hidden) + if(tileMaterial(tt) == CONSTRUCTED && !des.bits.hidden) continue; - if(!isWallTerrain(tt) && !des.hidden) + if(!isWallTerrain(tt) && !des.bits.hidden) continue; if(how == EXPLO_CLEAR) { - des.dig = designation_no; + des.bits.dig = df::tile_dig_designation::No; continue; } if(dm[y][x]) { if(what == EXPLO_ALL - || des.dig == designation_default && what == EXPLO_DESIGNATED - || des.hidden && what == EXPLO_HIDDEN) + || des.bits.dig == df::tile_dig_designation::Default && what == EXPLO_DESIGNATED + || des.bits.hidden && what == EXPLO_HIDDEN) { - des.dig = designation_default; + des.bits.dig = df::tile_dig_designation::Default; } } else if(what == EXPLO_DESIGNATED) { - des.dig = designation_no; + des.bits.dig = df::tile_dig_designation::No; } } } - bl->flags.set(BLOCK_DESIGNATED); + bl->flags.set(df::block_flags::Designated); return true; }; @@ -935,14 +935,14 @@ DFhackCExport command_result expdig (Core * c, vector & parameters) short unsigned int tt = mx.tiletypeAt(pos); if(tt == 0) continue; - t_designation des = mx.designationAt(pos); + df::tile_designation des = mx.designationAt(pos); if(tileMaterial(tt) == CONSTRUCTED && !des.bits.hidden) continue; if(!isWallTerrain(tt) && !des.bits.hidden) continue; if(cross[y][x]) { - des.bits.dig = designation_default; + des.bits.dig = df::tile_dig_designation::Default; mx.setDesignationAt(pos,des); } } @@ -1009,7 +1009,7 @@ DFhackCExport command_result vdig (Core * c, vector & parameters) return CR_FAILURE; } MapExtras::MapCache * MCache = new MapExtras::MapCache(Maps); - DFHack::t_designation des = MCache->designationAt(xy); + df::tile_designation des = MCache->designationAt(xy); int16_t tt = MCache->tiletypeAt(xy); int16_t veinmat = MCache->veinMaterialAt(xy); if( veinmat == -1 ) @@ -1034,9 +1034,9 @@ DFhackCExport command_result vdig (Core * c, vector & parameters) continue; // found a good tile, dig+unset material - DFHack::t_designation des = MCache->designationAt(current); - DFHack::t_designation des_minus; - DFHack::t_designation des_plus; + df::tile_designation des = MCache->designationAt(current); + df::tile_designation des_minus; + df::tile_designation des_plus; des_plus.whole = des_minus.whole = 0; int16_t vmat_minus = -1; int16_t vmat_plus = -1; @@ -1095,32 +1095,32 @@ DFhackCExport command_result vdig (Core * c, vector & parameters) { flood.push(current-1); - if(des_minus.bits.dig == DFHack::designation_d_stair) - des_minus.bits.dig = DFHack::designation_ud_stair; + if(des_minus.bits.dig == df::tile_dig_designation::DownStair) + des_minus.bits.dig = df::tile_dig_designation::UpDownStair; else - des_minus.bits.dig = DFHack::designation_u_stair; + des_minus.bits.dig = df::tile_dig_designation::UpStair; MCache->setDesignationAt(current-1,des_minus); - des.bits.dig = DFHack::designation_d_stair; + des.bits.dig = df::tile_dig_designation::DownStair; } if(current.z < z_max - 1 && above && vmat_plus == vmat2) { flood.push(current+ 1); - if(des_plus.bits.dig == DFHack::designation_u_stair) - des_plus.bits.dig = DFHack::designation_ud_stair; + if(des_plus.bits.dig == df::tile_dig_designation::UpStair) + des_plus.bits.dig = df::tile_dig_designation::UpDownStair; else - des_plus.bits.dig = DFHack::designation_d_stair; + des_plus.bits.dig = df::tile_dig_designation::DownStair; MCache->setDesignationAt(current+1,des_plus); - if(des.bits.dig == DFHack::designation_d_stair) - des.bits.dig = DFHack::designation_ud_stair; + if(des.bits.dig == df::tile_dig_designation::DownStair) + des.bits.dig = df::tile_dig_designation::UpDownStair; else - des.bits.dig = DFHack::designation_u_stair; + des.bits.dig = df::tile_dig_designation::UpStair; } } - if(des.bits.dig == DFHack::designation_no) - des.bits.dig = DFHack::designation_default; + if(des.bits.dig == df::tile_dig_designation::No) + des.bits.dig = df::tile_dig_designation::Default; MCache->setDesignationAt(current,des); } }