diff --git a/library/DFTypes_C.cpp b/library/DFTypes_C.cpp index 6d3f8d789..b8f0a6a9b 100644 --- a/library/DFTypes_C.cpp +++ b/library/DFTypes_C.cpp @@ -67,6 +67,40 @@ int (*alloc_empty_creaturetype_callback)(c_creaturetype*) = NULL; int (*alloc_creaturetype_callback)(c_creaturetype*, const char*, uint32_t, uint32_t, uint8_t, uint16_t, uint16_t, uint16_t) = NULL; int (*alloc_creaturetype_buffer_callback)(c_creaturetype*, uint32_t) = NULL; +int (*alloc_vein_buffer_callback)(t_vein*, uint32_t) = NULL; +int (*alloc_frozenliquidvein_buffer_callback)(t_frozenliquidvein*, uint32_t) = NULL; +int (*alloc_spattervein_buffer_callback)(t_spattervein*, uint32_t) = NULL; + +int DFHack_isWallTerrain(int in) +{ + return DFHack::isWallTerrain(in); +} + +int DFHack_isFloorTerrain(int in) +{ + return DFHack::isFloorTerrain(in); +} + +int DFHack_isRampTerrain(int in) +{ + return DFHack::isRampTerrain(in); +} + +int DFHack_isStairTerrain(int in) +{ + return DFHack::isStairTerrain(in); +} + +int DFHack_isOpenTerrain(int in) +{ + return DFHack::isOpenTerrain(in); +} + +int DFHack_getVegetationType(int in) +{ + return DFHack::getVegetationType(in); +} + #ifdef __cplusplus } #endif diff --git a/library/include/dfhack-c/DFTypes_C.h b/library/include/dfhack-c/DFTypes_C.h index bf604e13e..fbd883ead 100644 --- a/library/include/dfhack-c/DFTypes_C.h +++ b/library/include/dfhack-c/DFTypes_C.h @@ -27,6 +27,7 @@ distribution. #include "DFHack_C.h" #include "dfhack/DFTypes.h" +#include "dfhack/modules/Maps.h" #include "dfhack/modules/Materials.h" #ifdef __cplusplus @@ -100,6 +101,17 @@ DFHACK_EXPORT extern int (*alloc_empty_creaturetype_callback)(c_creaturetype*); DFHACK_EXPORT extern int (*alloc_creaturetype_callback)(c_creaturetype*, const char*, uint32_t, uint32_t, uint8_t, uint16_t, uint16_t, uint16_t); DFHACK_EXPORT extern int (*alloc_creaturetype_buffer_callback)(c_creaturetype*, uint32_t); +DFHACK_EXPORT extern int (*alloc_vein_buffer_callback)(t_vein*, uint32_t); +DFHACK_EXPORT extern int (*alloc_frozenliquidvein_buffer_callback)(t_frozenliquidvein*, uint32_t); +DFHACK_EXPORT extern int (*alloc_spattervein_buffer_callback)(t_spattervein*, uint32_t); + +DFHACK_EXPORT extern int DFHack_isWallTerrain(int in); +DFHACK_EXPORT extern int DFHack_isFloorTerrain(int in); +DFHACK_EXPORT extern int DFHack_isRampTerrain(int in); +DFHACK_EXPORT extern int DFHack_isStairTerrain(int in); +DFHACK_EXPORT extern int DFHack_isOpenTerrain(int in); +DFHACK_EXPORT extern int DFHack_getVegetationType(int in); + #ifdef __cplusplus } #endif diff --git a/library/include/dfhack-c/modules/Maps_C.h b/library/include/dfhack-c/modules/Maps_C.h index 299f0d5f5..d1bad823e 100644 --- a/library/include/dfhack-c/modules/Maps_C.h +++ b/library/include/dfhack-c/modules/Maps_C.h @@ -69,6 +69,10 @@ DFHACK_EXPORT int Maps_WriteBlockFlags(DFHackObject* maps, uint32_t x, uint32_t DFHACK_EXPORT int Maps_ReadRegionOffsets(DFHackObject* maps, uint32_t x, uint32_t y, uint32_t z, biome_indices40d* buffer); +DFHACK_EXPORT t_vein* Maps_ReadStandardVeins(DFHackObject* maps, uint32_t x, uint32_t y, uint32_t z); +DFHACK_EXPORT t_frozenliquidvein* Maps_ReadFrozenVeins(DFHackObject* maps, uint32_t x, uint32_t y, uint32_t z); +DFHACK_EXPORT t_spattervein* Maps_ReadSpatterVeins(DFHackObject* maps, uint32_t x, uint32_t y, uint32_t z); + #ifdef __cplusplus } #endif diff --git a/library/modules/Maps_C.cpp b/library/modules/Maps_C.cpp index 5b41fff07..0700e0a9a 100644 --- a/library/modules/Maps_C.cpp +++ b/library/modules/Maps_C.cpp @@ -22,6 +22,12 @@ must not be misrepresented as being the original software. distribution. */ +#include +#include + +using namespace std; + +#include "dfhack-c/DFTypes_C.h" #include "dfhack-c/modules/Maps_C.h" #ifdef __cplusplus @@ -268,6 +274,98 @@ int Maps_ReadRegionOffsets(DFHackObject* maps, uint32_t x, uint32_t y, uint32_t return -1; } +t_vein* Maps_ReadStandardVeins(DFHackObject* maps, uint32_t x, uint32_t y, uint32_t z) +{ + if(maps != NULL) + { + if(alloc_vein_buffer_callback == NULL) + return NULL; + + vector veins; + bool result = ((DFHack::Maps*)maps)->ReadVeins(x, y, z, &veins); + + if(result) + { + t_vein* v_buf = NULL; + + if(veins.size() > 0) + { + ((*alloc_vein_buffer_callback)(v_buf, veins.size())); + + copy(veins.begin(), veins.end(), v_buf); + } + + return v_buf; + } + else + return NULL; + } + + return NULL; +} + +t_frozenliquidvein* Maps_ReadFrozenVeins(DFHackObject* maps, uint32_t x, uint32_t y, uint32_t z) +{ + if(maps != NULL) + { + if(alloc_frozenliquidvein_callback == NULL) + return NULL; + + vector veins; + vector frozen_veins; + bool result = ((DFHack::Maps*)maps)->ReadVeins(x, y, z, &veins, &frozen_veins); + + if(result) + { + t_frozenliquidvein* fv_buf = NULL; + + if(frozen_veins.size() > 0) + { + ((*alloc_frozenliquidvein_buffer_callback)(fv_buf, frozen_veins.size())); + + copy(frozen_veins.begin(), frozen_veins.end(), fv_buf); + } + + return fv_buf; + } + else + return NULL; + } + + return NULL; +} + +t_spattervein* Maps_ReadSpatterVeins(DFHackObject* maps, uint32_t x, uint32_t y, uint32_t z) +{ + if(maps != NULL) + { + if(alloc_spattervein_callback == NULL) + return NULL; + + vector veins; + vector spatter_veins; + bool result = ((DFHack::Maps*)maps)->ReadVeins(x, y, z, &veins, 0, &spatter_veins); + + if(result) + { + t_spattervein* sv_buf = NULL; + + if(spatter_veins.size() > 0) + { + ((*alloc_spattervein_buffer_callback)(sv_buf, spatter_veins.size())); + + copy(spatter_veins.begin(), spatter_veins.end(), sv_buf); + } + + return sv_buf; + } + else + return NULL; + } + + return NULL; +} + #ifdef __cplusplus } #endif diff --git a/library/python/pydfhack/buildings.py b/library/python/pydfhack/buildings.py index c61fd9f2b..32c330201 100644 --- a/library/python/pydfhack/buildings.py +++ b/library/python/pydfhack/buildings.py @@ -4,7 +4,7 @@ import util libdfhack.Buildings_GetCustomWorkshopType.argtypes = [ c_void_p, POINTER(CustomWorkshop) ] -def Buildings(object): +class Buildings(object): def __init__(self, ptr): self._b_ptr = ptr diff --git a/library/python/pydfhack/maps.py b/library/python/pydfhack/maps.py index f5f69cfb5..c889719e8 100644 --- a/library/python/pydfhack/maps.py +++ b/library/python/pydfhack/maps.py @@ -2,6 +2,9 @@ from ctypes import * from pydftypes import * from util import _uintify, uint_ptr +_MAX_DIM = 0x300 +_MAX_DIM_SQR = _MAX_DIM * _MAX_DIM + libdfhack.Maps_getSize.argtypes = [ c_void_p, uint_ptr, uint_ptr, uint_ptr ] libdfhack.Maps_ReadTileTypes.argtypes = [ c_void_p, c_uint, c_uint, c_uint, POINTER(TileTypes40d) ] libdfhack.Maps_WriteTileTypes.argtypes = [ c_void_p, c_uint, c_uint, c_uint, POINTER(TileTypes40d) ] @@ -161,3 +164,63 @@ class Maps(object): return (int(x.value), int(y.value), int(z.value)) else: return (-1, -1, -1) + +class MapPoint(object): + __slots__ = ["_x", "_y", "_z", "_cmp_val"] + + def __init__(self, x = 0, y = 0, z = 0): + self._x, self._y, self._z = x, y, z + + self._cmp_val = self._get_cmp_value() + + def _val_set(self, which, val): + if which == 0: + self._x = val + elif which == 1: + self._y = val + elif which == 2: + self._z = val + + self._cmp_val = self._get_cmp_value() + + x = property(fget = lambda self: self._x, fset = lambda self, v: self._val_set(0, v)) + y = property(fget = lambda self: self._y, fset = lambda self, v: self._val_set(1, v)) + z = property(fget = lambda self: self._z, fset = lambda self, v: self._val_set(2, v)) + + def _get_cmp_value(self): + return (self.z * _MAX_DIM_SQR) + (self.y * _MAX_DIM) + self.x + + #comparison operators + def __eq__(self, other): + return self.x == other.x and self.y == other.y and self.z == other.z + + def __ne__(self, other): + return not self == other + + def __lt__(self, other): + return self._cmp_val < other._cmp_val + + def __le__(self, other): + return self < other or self == other + + def __gt__(self, other): + return self._cmp_val > other._cmp_val + + def __ge__(self, other): + return self > other or self == other + + #arithmetic operators + def __add__(self, num): + return MapPoint(self.x, self.y, self.z + num) + + def __sub__(self, num): + return MapPoint(self.x, self.y, self.z - num) + + def __div__(self, num): + return MapPoint(self.x / num, self.y / num, self.z) + + def __mul__(self, num): + return MapPoint(self.x * num, self.y * num, self.z) + + def __mod__(self, num): + return MapPoint(self.x % num, self.y % num, self.z) \ No newline at end of file