diff --git a/library/CMakeLists.txt b/library/CMakeLists.txt index cf98a4888..e82f885a2 100644 --- a/library/CMakeLists.txt +++ b/library/CMakeLists.txt @@ -6,6 +6,7 @@ DFMemInfo.cpp DFProcess.cpp DFProcessManager.cpp DFHackAPI.cpp +DFHackAPIc.cpp DFTileTypes.cpp md5/md5.cpp md5/md5wrapper.cpp diff --git a/library/DFHackAPI.cpp b/library/DFHackAPI.cpp index 9d3fd3b2a..1f74c6faf 100644 --- a/library/DFHackAPI.cpp +++ b/library/DFHackAPI.cpp @@ -31,6 +31,12 @@ distribution. #include "DFHackAPI.h" #include "DFMemInfo.h" +#if defined(_MSC_VER) && _MSC_VER >= 1400 +# define fill_char_buf(buf, str) strcpy_s((buf), sizeof(buf) / sizeof((buf)[0]), (str).c_str()) +#else +# define fill_char_buf(buf, str) strncpy((buf), (str).c_str(), sizeof(buf) / sizeof((buf)[0])) +#endif + /* TODO: Test these matgloss other than stone/soil */ @@ -286,7 +292,7 @@ bool DFHackAPIImpl::ReadWoodMatgloss(vector & woods) p_matgloss.read((uint32_t)i,(uint8_t *)&temp); // read the string pointed at by - mat.id = dm->readSTLString(temp); // reads a C string given an address + fill_char_buf(mat.id, dm->readSTLString(temp)); // reads a C string given an address woods.push_back(mat); } return true; @@ -308,7 +314,7 @@ bool DFHackAPIImpl::ReadStoneMatgloss(vector & stones) p_matgloss.read((uint32_t)i,(uint8_t *)&temp); // read the string pointed at by t_matgloss mat; - mat.id = dm->readSTLString(temp); // reads a C string given an address + fill_char_buf(mat.id, dm->readSTLString(temp)); // reads a C string given an address mat.fore = (uint8_t)MreadWord(temp + matgloss_colors); mat.back = (uint8_t)MreadWord(temp + matgloss_colors + 2); mat.bright = (uint8_t)MreadWord(temp + matgloss_colors + 4); @@ -336,7 +342,7 @@ bool DFHackAPIImpl::ReadMetalMatgloss(vector & metals) // read the string pointed at by t_matgloss mat; - mat.id = dm->readSTLString(temp); // reads a C string given an address + fill_char_buf(mat.id, dm->readSTLString(temp)); // reads a C string given an address mat.fore = (uint8_t)MreadWord(temp + matgloss_colors); mat.back = (uint8_t)MreadWord(temp + matgloss_colors + 2); mat.bright = (uint8_t)MreadWord(temp + matgloss_colors + 4); @@ -366,7 +372,7 @@ bool DFHackAPIImpl::ReadPlantMatgloss(vector & plants) p_matgloss.read((uint32_t)i,(uint8_t *)&temp); // read the string pointed at by - mat.id = dm->readSTLString(temp); // reads a C string given an address + fill_char_buf(mat.id, dm->readSTLString(temp)); // reads a C string given an address plants.push_back(mat); } return true; diff --git a/library/DFHackAPIc.cpp b/library/DFHackAPIc.cpp new file mode 100644 index 000000000..126c96792 --- /dev/null +++ b/library/DFHackAPIc.cpp @@ -0,0 +1,328 @@ +/* +www.sourceforge.net/projects/dfhack +Copyright (c) 2009 Petr Mrázek (peterix), Kenneth Ferland (Impaler[WrG]), dorf + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must +not claim that you wrote the original software. If you use this +software in a product, an acknowledgment in the product documentation +would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and +must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source +distribution. +*/ + +#ifndef BUILD_DFHACK_LIB +# define BUILD_DFHACK_LIB +#endif + +#include "DFCommon.h" +#include "DFHackAPI.h" +#include "DFHackAPIc.h" + +#ifdef LINUX_BUILD +# ifndef secure_strcpy +# define secure_strcpy(dst, size, buf) strcpy((dst), (buf)) +# endif +#else +# if defined(_MSC_VER) && _MSC_VER >= 1400 +# ifndef secure_strcpy +# define secure_strcpy(dst, size, buf) strcpy_s((dst), (size), (buf)) +# endif +# else +# ifndef secure_strcpy +# define secure_strcpy(dst, size, buf) strcpy((dst), (buf)) +# endif +# endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +// The C interface for vector management +DFHACKAPI void DFHackAPIVector_free(DFHackAPIVectorC *vector) +{ + uint32_t i; + switch (vector->type) + { + case DFHackAPIVectorTypeC_Normal: + delete [] (vector->data); + break; + case DFHackAPIVectorTypeC_Matgloss: + delete [] ((t_matgloss *)vector->data); + break; + case DFHackAPIVectorTypeC_Uint16: + delete [] ((uint16_t *)vector->data); + break; + case DFHackAPIVectorTypeC_Vein: + delete [] ((t_vein *)vector->data); + break; + case DFHackAPIVectorTypeC_String: + for (i = 0; i < vector->length; i++) + delete [] ((char **)vector->data)[i]; + delete [] ((char **)vector->data); + break; + case DFHackAPIVectorTypeC_Recursive: + for (i = 0; i < vector->length; i++) + DFHackAPIVector_free(&((DFHackAPIVectorC *) vector->data)[i]); + delete [] ((DFHackAPIVectorC *)vector->data); + break; + } + + vector->type = DFHackAPIVectorTypeC_Normal; + vector->length = 0; + vector->data = 0; +} + +// The C interface to DFHackAPI (for multiple language support) +DFHACKAPI DFHackAPIHandle CreateDFHackAPI(const char *path_to_xml) +{ + return new DFHackAPIImpl(path_to_xml); +} + +DFHACKAPI void DestroyDFHackAPI(DFHackAPIHandle self) +{ + if (self != NULL) + delete self; +} + +DFHACKAPI bool DFHackAPI_Attach(DFHackAPIHandle self) +{ + return self->Attach(); +} + +DFHACKAPI bool DFHackAPI_Detach(DFHackAPIHandle self) +{ + return self->Detach(); +} + +DFHACKAPI bool DFHackAPI_isAttached(DFHackAPIHandle self) +{ + return self->isAttached(); +} + +DFHACKAPI bool DFHackAPI_ReadStoneMatgloss(DFHackAPIHandle self, DFHackAPIVectorC *output) +{ + vector result; + uint32_t i; + bool retn = self->ReadStoneMatgloss(result); + + output->type = DFHackAPIVectorTypeC_Matgloss; + output->length = result.size(); + output->data = new t_matgloss[output->length]; + for (i = 0; i < output->length; i++) + ((t_matgloss *)output->data)[i] = result[i]; + + return retn; +} + +DFHACKAPI bool DFHackAPI_ReadWoodMatgloss (DFHackAPIHandle self, DFHackAPIVectorC *output) +{ + vector result; + uint32_t i; + bool retn = self->ReadWoodMatgloss (result); + + output->type = DFHackAPIVectorTypeC_Matgloss; + output->length = result.size(); + output->data = new t_matgloss[output->length]; + for (i = 0; i < output->length; i++) + ((t_matgloss *)output->data)[i] = result[i]; + + return retn; +} + +DFHACKAPI bool DFHackAPI_ReadMetalMatgloss(DFHackAPIHandle self, DFHackAPIVectorC *output) +{ + vector result; + uint32_t i; + bool retn = self->ReadMetalMatgloss(result); + + output->type = DFHackAPIVectorTypeC_Matgloss; + output->length = result.size(); + output->data = new t_matgloss[output->length]; + for (i = 0; i < output->length; i++) + ((t_matgloss *)output->data)[i] = result[i]; + + return retn; +} + +DFHACKAPI bool DFHackAPI_ReadPlantMatgloss(DFHackAPIHandle self, DFHackAPIVectorC *output) +{ + vector result; + uint32_t i; + bool retn = self->ReadPlantMatgloss(result); + + output->type = DFHackAPIVectorTypeC_Matgloss; + output->length = result.size(); + output->data = new t_matgloss[output->length]; + for (i = 0; i < output->length; i++) + ((t_matgloss *)output->data)[i] = result[i]; + + return retn; +} + +DFHACKAPI bool DFHackAPI_ReadGeology(DFHackAPIHandle self, DFHackAPIVectorC *assign) +{ + vector< vector > result; + uint32_t i, j; + bool retn = self->ReadGeology(result); + + assign->type = DFHackAPIVectorTypeC_Recursive; + assign->length = result.size(); + assign->data = new DFHackAPIVectorC[assign->length]; + for (i = 0; i < assign->length; i++) + { + DFHackAPIVectorC ¤t = ((DFHackAPIVectorC *) assign->data)[i]; + current.type = DFHackAPIVectorTypeC_Uint16; + current.length = result[i].size(); + current.data = new uint16_t[current.length]; + for (j = 0; j < current.length; j++) + ((uint16_t *)current.data)[j] = result[i][j]; + } + + return retn; +} + +DFHACKAPI bool DFHackAPI_InitMap(DFHackAPIHandle self) +{ + return self->InitMap(); +} + +DFHACKAPI bool DFHackAPI_DestroyMap(DFHackAPIHandle self) +{ + return self->DestroyMap(); +} + +DFHACKAPI void DFHackAPI_getSize(DFHackAPIHandle self, uint32_t* x, uint32_t* y, uint32_t* z) +{ + return self->getSize(*x, *y, *z); +} + +DFHACKAPI bool DFHackAPI_isValidBlock(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz) +{ + return self->isValidBlock(blockx, blocky, blockz); +} + +DFHACKAPI bool DFHackAPI_ReadTileTypes(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, uint16_t *buffer) +{ + return self->ReadTileTypes(blockx, blocky, blockz, buffer); +} + +DFHACKAPI bool DFHackAPI_WriteTileTypes(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, uint16_t *buffer) +{ + return self->WriteTileTypes(blockx, blocky, blockz, buffer); +} + +DFHACKAPI bool DFHackAPI_ReadDesignations(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, uint32_t *buffer) +{ + return self->ReadDesignations (blockx, blocky, blockz, buffer); +} + +DFHACKAPI bool DFHackAPI_WriteDesignations (DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, uint32_t *buffer) +{ + return self->WriteDesignations (blockx, blocky, blockz, buffer); +} + +DFHACKAPI bool DFHackAPI_ReadOccupancy(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, uint32_t *buffer) +{ + return self->ReadOccupancy(blockx, blocky, blockz, buffer); +} + +DFHACKAPI bool DFHackAPI_WriteOccupancy(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, uint32_t *buffer) +{ + return self->WriteOccupancy(blockx, blocky, blockz, buffer); +} + +DFHACKAPI bool DFHackAPI_ReadRegionOffsets(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, uint8_t *buffer) +{ + return self->ReadRegionOffsets(blockx, blocky, blockz, buffer); +} + +DFHACKAPI bool DFHackAPI_ReadVeins(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, DFHackAPIVectorC * veins) +{ + vector result; + uint32_t i; + bool retn = self->ReadVeins(blockx, blocky, blockz, result); + + veins->type = DFHackAPIVectorTypeC_Vein; + veins->length = result.size(); + veins->data = new t_vein[veins->length]; + for (i = 0; i < veins->length; i++) + ((t_vein *)veins->data)[i] = result[i]; + + return retn; +} + +DFHACKAPI uint32_t DFHackAPI_InitReadConstructions(DFHackAPIHandle self) +{ + return self->InitReadConstructions(); +} + +DFHACKAPI bool DFHackAPI_ReadConstruction(DFHackAPIHandle self, const uint32_t *index, t_construction * construction) +{ + return self->ReadConstruction(*index, *construction); +} + +DFHACKAPI void DFHackAPI_FinishReadConstructions(DFHackAPIHandle self) +{ + self->FinishReadConstructions(); +} + +DFHACKAPI uint32_t DFHackAPI_InitReadBuildings(DFHackAPIHandle self, DFHackAPIVectorC *v_buildingtypes) +{ + vector result; + uint32_t i; + uint32_t retn = self->InitReadBuildings(result); + + v_buildingtypes->type = DFHackAPIVectorTypeC_String; + v_buildingtypes->length = result.size(); + v_buildingtypes->data = new char *[v_buildingtypes->length]; + for (i = 0; i < v_buildingtypes->length; i++) + { + char *str = new char[result[i].size() + 1]; + secure_strcpy(str, result[i].size() + 1, result[i].c_str()); + ((char **)v_buildingtypes->data)[i] = str; + } + + return retn; +} + +DFHACKAPI bool DFHackAPI_ReadBuilding(DFHackAPIHandle self, const uint32_t *index, t_building * building) +{ + return self->ReadBuilding(*index, *building); +} + +DFHACKAPI void DFHackAPI_FinishReadBuildings(DFHackAPIHandle self) +{ + self->FinishReadBuildings(); +} + +DFHACKAPI uint32_t DFHackAPI_InitReadVegetation(DFHackAPIHandle self) +{ + return self->InitReadVegetation(); +} + +DFHACKAPI bool DFHackAPI_ReadVegetation(DFHackAPIHandle self, const uint32_t *index, t_tree_desc * shrubbery) +{ + return self->ReadVegetation(*index, *shrubbery); +} + +DFHACKAPI void DFHackAPI_FinishReadVegetation(DFHackAPIHandle self) +{ + self->FinishReadVegetation(); +} + +#ifdef __cplusplus +} +#endif diff --git a/library/DFHackAPIc.h b/library/DFHackAPIc.h new file mode 100644 index 000000000..80f1d5d85 --- /dev/null +++ b/library/DFHackAPIc.h @@ -0,0 +1,440 @@ +/* +www.sourceforge.net/projects/dfhack +Copyright (c) 2009 Petr Mrázek (peterix), Kenneth Ferland (Impaler[WrG]), dorf + +This software is provided 'as-is', without any express or implied +warranty. In no event will the authors be held liable for any +damages arising from the use of this software. + +Permission is granted to anyone to use this software for any +purpose, including commercial applications, and to alter it and +redistribute it freely, subject to the following restrictions: + +1. The origin of this software must not be misrepresented; you must +not claim that you wrote the original software. If you use this +software in a product, an acknowledgment in the product documentation +would be appreciated but is not required. + +2. Altered source versions must be plainly marked as such, and +must not be misrepresented as being the original software. + +3. This notice may not be removed or altered from any source +distribution. +*/ + +#ifndef SIMPLEAPIC_H_INCLUDED +#define SIMPLEAPIC_H_INCLUDED + +#ifdef LINUX_BUILD +# ifndef DFHACKAPI +# define DFHACKAPI extern "C" +# endif +#else +# ifdef BUILD_DFHACK_LIB +# ifndef DFHACKAPI +# define DFHACKAPI extern "C" __declspec(dllexport) +# endif +# else +# ifndef DFHACKAPI +# define DFHACKAPI extern "C" __declspec(dllimport) +# endif +# endif +#endif + +#include + +#ifdef __cplusplus +# include +# include +using namespace std; +#endif + +typedef enum DFHackAPIVectorTypeC { + DFHackAPIVectorTypeC_Normal, // array of struct's + DFHackAPIVectorTypeC_Matgloss, // array of t_matgloss's + DFHackAPIVectorTypeC_Uint16, // array of uint16_t's + DFHackAPIVectorTypeC_Vein, // array of t_vein's + DFHackAPIVectorTypeC_String, // array of const char *'s + DFHackAPIVectorTypeC_Recursive, // array of DFHackAPIVectorC struct's + DFHackAPIVectorTypeC_DWord = 0xffffffff // Unused +} DFHackAPIVectorTypeC; + +typedef struct DFHackAPIVectorC { + void *data; + uint32_t length; + DFHackAPIVectorTypeC type; +} DFHackAPIVector; + +#ifdef __cplusplus +typedef class DFHackAPIImpl *DFHackAPIHandle; +#else +typedef struct DFHackAPIImpl *DFHackAPIHandle; +typedef char bool; +#endif + +#ifdef __cplusplus +extern "C" { +#endif // __cplusplus + +// The C interface for vector management +DFHACKAPI void DFHackAPIVector_free(DFHackAPIVectorC *vector); + +// The C interface to DFHackAPI (for multiple language support) +DFHACKAPI DFHackAPIHandle CreateDFHackAPI(const char *path_to_xml); +DFHACKAPI void DestroyDFHackAPI(DFHackAPIHandle self); + +DFHACKAPI bool DFHackAPI_Attach(DFHackAPIHandle self); +DFHACKAPI bool DFHackAPI_Detach(DFHackAPIHandle self); +DFHACKAPI bool DFHackAPI_isAttached(DFHackAPIHandle self); + +DFHACKAPI bool DFHackAPI_ReadStoneMatgloss(DFHackAPIHandle self, DFHackAPIVectorC *output); +DFHACKAPI bool DFHackAPI_ReadWoodMatgloss (DFHackAPIHandle self, DFHackAPIVectorC *output); +DFHACKAPI bool DFHackAPI_ReadMetalMatgloss(DFHackAPIHandle self, DFHackAPIVectorC *output); +DFHACKAPI bool DFHackAPI_ReadPlantMatgloss(DFHackAPIHandle self, DFHackAPIVectorC *output); + +DFHACKAPI bool DFHackAPI_ReadGeology(DFHackAPIHandle self, DFHackAPIVectorC *assign); + +DFHACKAPI bool DFHackAPI_InitMap(DFHackAPIHandle self); +DFHACKAPI bool DFHackAPI_DestroyMap(DFHackAPIHandle self); +DFHACKAPI void DFHackAPI_getSize(DFHackAPIHandle self, uint32_t* x, uint32_t* y, uint32_t* z); + +DFHACKAPI bool DFHackAPI_isValidBlock(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz); + +DFHACKAPI bool DFHackAPI_ReadTileTypes(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, uint16_t *buffer); +DFHACKAPI bool DFHackAPI_WriteTileTypes(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, uint16_t *buffer); + +DFHACKAPI bool DFHackAPI_ReadDesignations(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, uint32_t *buffer); +DFHACKAPI bool DFHackAPI_WriteDesignations (DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, uint32_t *buffer); + +DFHACKAPI bool DFHackAPI_ReadOccupancy(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, uint32_t *buffer); +DFHACKAPI bool DFHackAPI_WriteOccupancy(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, uint32_t *buffer); + +DFHACKAPI bool DFHackAPI_ReadRegionOffsets(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, uint8_t *buffer); + +DFHACKAPI bool DFHackAPI_ReadVeins(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, DFHackAPIVectorC * veins); + + +DFHACKAPI uint32_t DFHackAPI_InitReadConstructions(DFHackAPIHandle self); +DFHACKAPI bool DFHackAPI_ReadConstruction(DFHackAPIHandle self, const uint32_t *index, t_construction * construction); +DFHACKAPI void DFHackAPI_FinishReadConstructions(DFHackAPIHandle self); + +DFHACKAPI uint32_t DFHackAPI_InitReadBuildings(DFHackAPIHandle self, DFHackAPIVectorC *v_buildingtypes); +DFHACKAPI bool DFHackAPI_ReadBuilding(DFHackAPIHandle self, const uint32_t *index, t_building * building); +DFHACKAPI void DFHackAPI_FinishReadBuildings(DFHackAPIHandle self); + +DFHACKAPI uint32_t DFHackAPI_InitReadVegetation(DFHackAPIHandle self); +DFHACKAPI bool DFHackAPI_ReadVegetation(DFHackAPIHandle self, const uint32_t *index, t_tree_desc * shrubbery); +DFHACKAPI void DFHackAPI_FinishReadVegetation(DFHackAPIHandle self); + +#ifdef __cplusplus +} +#endif // __cplusplus + +// C++ wrappers for C API that use vectors +#ifdef __cplusplus +inline bool DFHackAPI_ReadStoneMatgloss(DFHackAPIHandle self, vector & output) +{ + DFHackAPIVectorC vector; + bool result = DFHackAPI_ReadStoneMatgloss(self, &vector); + uint32_t i; + for (i = 0; i < vector.length; i++) + output.push_back(((t_matgloss *) vector.data)[i]); + DFHackAPIVector_free(&vector); + return result; +} + +inline bool DFHackAPI_ReadWoodMatgloss (DFHackAPIHandle self, vector & output) +{ + DFHackAPIVectorC vector; + bool result = DFHackAPI_ReadWoodMatgloss (self, &vector); + uint32_t i; + for (i = 0; i < vector.length; i++) + output.push_back(((t_matgloss *) vector.data)[i]); + DFHackAPIVector_free(&vector); + return result; +} + +inline bool DFHackAPI_ReadMetalMatgloss(DFHackAPIHandle self, vector & output) +{ + DFHackAPIVectorC vector; + bool result = DFHackAPI_ReadMetalMatgloss(self, &vector); + uint32_t i; + for (i = 0; i < vector.length; i++) + output.push_back(((t_matgloss *) vector.data)[i]); + DFHackAPIVector_free(&vector); + return result; +} + +inline bool DFHackAPI_ReadPlantMatgloss(DFHackAPIHandle self, vector & output) +{ + DFHackAPIVectorC vector; + bool result = DFHackAPI_ReadPlantMatgloss(self, &vector); + uint32_t i; + for (i = 0; i < vector.length; i++) + output.push_back(((t_matgloss *) vector.data)[i]); + DFHackAPIVector_free(&vector); + return result; +} + +inline bool DFHackAPI_ReadGeology(DFHackAPIHandle self, vector< vector > &assign) +{ + DFHackAPIVectorC vec; + bool result = DFHackAPI_ReadGeology(self, &vec); + uint32_t i; + for (i = 0; i < vec.length; i++) + { + DFHackAPIVectorC ¤t = ((DFHackAPIVectorC *) vec.data)[i]; + vector fill; + uint32_t j; + for (j = 0; j < current.length; j++) + fill.push_back(((uint16_t *) current.data)[j]); + assign.push_back(fill); + } + DFHackAPIVector_free(&vec); + return result; +} + +inline bool DFHackAPI_ReadVeins(DFHackAPIHandle self, uint32_t blockx, uint32_t blocky, uint32_t blockz, vector & veins) +{ + DFHackAPIVectorC vector; + bool result = DFHackAPI_ReadVeins(self, blockx, blocky, blockz, &vector); + uint32_t i; + for (i = 0; i < vector.length; i++) + veins.push_back(((t_vein *) vector.data)[i]); + DFHackAPIVector_free(&vector); + return result; +} + +inline uint32_t DFHackAPI_InitReadBuildings(DFHackAPIHandle self, vector &v_buildingtypes) +{ + DFHackAPIVectorC vector; + uint32_t result = DFHackAPI_InitReadBuildings(self, &vector); + uint32_t i; + for (i = 0; i < vector.length; i++) + v_buildingtypes.push_back(((const char **) vector.data)[i]); + DFHackAPIVector_free(&vector); + return result; +} +#endif // __cplusplus + +// C++ class wrapper for C DFHackAPI +#ifdef __cplusplus +class CDFHackAPI +{ + DFHackAPIHandle handle; +public: + CDFHackAPI(const string &path_to_xml) + : handle(CreateDFHackAPI(path_to_xml.c_str())) + { + if (handle == NULL) + { + // TODO: handle failure + } + } + + inline ~CDFHackAPI() + { + DestroyDFHackAPI(handle); + handle = NULL; + } + + inline bool Attach() + { + return DFHackAPI_Attach(handle); + } + + inline bool Detach() + { + return DFHackAPI_Detach(handle); + } + + inline bool isAttached() + { + return DFHackAPI_isAttached(handle); + } + + /** + * 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 + */ + inline bool ReadStoneMatgloss(vector & output) + { + return DFHackAPI_ReadStoneMatgloss(handle, output); + } + + inline bool ReadWoodMatgloss (vector & output) + { + return DFHackAPI_ReadWoodMatgloss(handle, output); + } + + inline bool ReadMetalMatgloss(vector & output) + { + return DFHackAPI_ReadMetalMatgloss(handle, output); + } + + inline bool ReadPlantMatgloss(vector & output) + { + return DFHackAPI_ReadPlantMatgloss(handle, output); + } + + // FIXME: add creatures for all the creature products + + // read region surroundings, get their vectors of geolayers so we can do translation (or just hand the translation table to the client) + // returns an array of 9 vectors of indices into stone matgloss + /** + Method for reading the geological surrounding of the currently loaded region. + assign is a reference to an array of nine vectors of unsigned words that are to be filled with the data + array is indexed by the BiomeOffset enum + + I omitted resolving the layer matgloss in this API, because it would + introduce overhead by calling some method for each tile. You have to do it + yourself. First get the stuff from ReadGeology and then for each block get + the RegionOffsets. For each tile get the real region from RegionOffsets and + cross-reference it with the geology stuff (region -- array of vectors, depth -- + vector). I'm thinking about turning that Geology stuff into a + two-dimensional array with static size. + + this is the algorithm for applying matgloss: + void DfMap::applyGeoMatgloss(Block * b) + { + // load layer matgloss + for(int x_b = 0; x_b < BLOCK_SIZE; x_b++) + { + for(int y_b = 0; y_b < BLOCK_SIZE; y_b++) + { + int geolayer = b->designation[x_b][y_b].bits.geolayer_index; + int biome = b->designation[x_b][y_b].bits.biome; + b->material[x_b][y_b].type = Mat_Stone; + b->material[x_b][y_b].index = v_geology[b->RegionOffsets[biome]][geolayer]; + } + } + } + */ + inline bool ReadGeology( vector < vector >& assign ) + { + return DFHackAPI_ReadGeology(handle, assign); + } + + /* + * BLOCK DATA + */ + /// allocate and read pointers to map blocks + inline bool InitMap() + { + return DFHackAPI_InitMap(handle); + } + + /// destroy the mapblock cache + inline bool DestroyMap() + { + return DFHackAPI_DestroyMap(handle); + } + + /// get size of the map in tiles + inline void getSize(uint32_t& x, uint32_t& y, uint32_t& z) + { + DFHackAPI_getSize(handle, &x, &y, &z); + } + + /** + * Return false/0 on failure, buffer allocated by client app, 256 items long + */ + inline bool isValidBlock(uint32_t blockx, uint32_t blocky, uint32_t blockz) + { + return DFHackAPI_isValidBlock(handle, blockx, blocky, blockz); + } + + inline bool ReadTileTypes(uint32_t blockx, uint32_t blocky, uint32_t blockz, uint16_t *buffer) // 256 * sizeof(uint16_t) + { + return DFHackAPI_ReadTileTypes(handle, blockx, blocky, blockz, buffer); + } + + inline bool WriteTileTypes(uint32_t blockx, uint32_t blocky, uint32_t blockz, uint16_t *buffer) // 256 * sizeof(uint16_t) + { + return DFHackAPI_WriteTileTypes(handle, blockx, blocky, blockz, buffer); + } + + inline bool ReadDesignations(uint32_t blockx, uint32_t blocky, uint32_t blockz, uint32_t *buffer) // 256 * sizeof(uint32_t) + { + return DFHackAPI_ReadDesignations(handle, blockx, blocky, blockz, buffer); + } + + inline bool WriteDesignations (uint32_t blockx, uint32_t blocky, uint32_t blockz, uint32_t *buffer) + { + return DFHackAPI_WriteDesignations(handle, blockx, blocky, blockz, buffer); + } + + inline bool ReadOccupancy(uint32_t blockx, uint32_t blocky, uint32_t blockz, uint32_t *buffer) // 256 * sizeof(uint32_t) + { + return DFHackAPI_ReadOccupancy(handle, blockx, blocky, blockz, buffer); + } + + inline bool WriteOccupancy(uint32_t blockx, uint32_t blocky, uint32_t blockz, uint32_t *buffer) // 256 * sizeof(uint32_t) + { + return DFHackAPI_WriteOccupancy(handle, blockx, blocky, blockz, buffer); + } + + /// read region offsets of a block + inline bool ReadRegionOffsets(uint32_t blockx, uint32_t blocky, uint32_t blockz, uint8_t *buffer) // 16 * sizeof(uint8_t) + { + return DFHackAPI_ReadRegionOffsets(handle, blockx, blocky, blockz, buffer); + } + + /// read aggregated veins of a block + inline bool ReadVeins(uint32_t blockx, uint32_t blocky, uint32_t blockz, vector & veins) + { + return DFHackAPI_ReadVeins(handle, blockx, blocky, blockz, veins); + } + + /** + * Buildings, constructions, plants, all pretty straighforward. InitReadBuildings returns all the building types as a mapping between a numeric values and strings + */ + inline uint32_t InitReadConstructions() + { + return DFHackAPI_InitReadConstructions(handle); + } + + inline bool ReadConstruction(const uint32_t &index, t_construction & construction) + { + return DFHackAPI_ReadConstruction(handle, &index, & construction); + } + + inline void FinishReadConstructions() + { + DFHackAPI_FinishReadConstructions(handle); + } + + inline uint32_t InitReadBuildings(vector &v_buildingtypes) + { + return DFHackAPI_InitReadBuildings(handle, v_buildingtypes); + } + + inline bool ReadBuilding(const uint32_t &index, t_building & building) + { + return DFHackAPI_ReadBuilding(handle, &index, &building); + } + + inline void FinishReadBuildings() + { + DFHackAPI_FinishReadBuildings(handle); + } + + inline uint32_t InitReadVegetation() + { + return DFHackAPI_InitReadVegetation(handle); + } + + inline bool ReadVegetation(const uint32_t &index, t_tree_desc & shrubbery) + { + return DFHackAPI_ReadVegetation(handle, &index, &shrubbery); + } + + inline void FinishReadVegetation() + { + DFHackAPI_FinishReadVegetation(handle); + } +}; +#endif // __cplusplus + +#endif // SIMPLEAPIC_H_INCLUDED diff --git a/library/DFTypes.h b/library/DFTypes.h index ad03cf819..7177a8220 100644 --- a/library/DFTypes.h +++ b/library/DFTypes.h @@ -27,7 +27,7 @@ distribution. struct t_matgloss { - string id; + char id[128]; uint8_t fore; // Annoyingly the offset for this differs between types uint8_t back; uint8_t bright;