merged C API patch from Jifodus

develop
Petr Mrázek 2009-10-22 00:18:49 +00:00
parent c1299b0b7c
commit b5137240dc
5 changed files with 780 additions and 5 deletions

@ -6,6 +6,7 @@ DFMemInfo.cpp
DFProcess.cpp DFProcess.cpp
DFProcessManager.cpp DFProcessManager.cpp
DFHackAPI.cpp DFHackAPI.cpp
DFHackAPIc.cpp
DFTileTypes.cpp DFTileTypes.cpp
md5/md5.cpp md5/md5.cpp
md5/md5wrapper.cpp md5/md5wrapper.cpp

@ -31,6 +31,12 @@ distribution.
#include "DFHackAPI.h" #include "DFHackAPI.h"
#include "DFMemInfo.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 /* TODO: Test these
matgloss other than stone/soil matgloss other than stone/soil
*/ */
@ -286,7 +292,7 @@ bool DFHackAPIImpl::ReadWoodMatgloss(vector<t_matgloss> & woods)
p_matgloss.read((uint32_t)i,(uint8_t *)&temp); p_matgloss.read((uint32_t)i,(uint8_t *)&temp);
// read the string pointed at by // 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); woods.push_back(mat);
} }
return true; return true;
@ -308,7 +314,7 @@ bool DFHackAPIImpl::ReadStoneMatgloss(vector<t_matgloss> & stones)
p_matgloss.read((uint32_t)i,(uint8_t *)&temp); p_matgloss.read((uint32_t)i,(uint8_t *)&temp);
// read the string pointed at by // read the string pointed at by
t_matgloss mat; 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.fore = (uint8_t)MreadWord(temp + matgloss_colors);
mat.back = (uint8_t)MreadWord(temp + matgloss_colors + 2); mat.back = (uint8_t)MreadWord(temp + matgloss_colors + 2);
mat.bright = (uint8_t)MreadWord(temp + matgloss_colors + 4); mat.bright = (uint8_t)MreadWord(temp + matgloss_colors + 4);
@ -336,7 +342,7 @@ bool DFHackAPIImpl::ReadMetalMatgloss(vector<t_matgloss> & metals)
// read the string pointed at by // read the string pointed at by
t_matgloss mat; 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.fore = (uint8_t)MreadWord(temp + matgloss_colors);
mat.back = (uint8_t)MreadWord(temp + matgloss_colors + 2); mat.back = (uint8_t)MreadWord(temp + matgloss_colors + 2);
mat.bright = (uint8_t)MreadWord(temp + matgloss_colors + 4); mat.bright = (uint8_t)MreadWord(temp + matgloss_colors + 4);
@ -366,7 +372,7 @@ bool DFHackAPIImpl::ReadPlantMatgloss(vector<t_matgloss> & plants)
p_matgloss.read((uint32_t)i,(uint8_t *)&temp); p_matgloss.read((uint32_t)i,(uint8_t *)&temp);
// read the string pointed at by // 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); plants.push_back(mat);
} }
return true; return true;

@ -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<t_matgloss> 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<t_matgloss> 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<t_matgloss> 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<t_matgloss> 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<uint16_t> > 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 &current = ((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<t_vein> 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<string> 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

@ -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 <stdint.h>
#ifdef __cplusplus
# include <vector>
# include <string>
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<t_matgloss> & 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<t_matgloss> & 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<t_matgloss> & 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<t_matgloss> & 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<uint16_t> > &assign)
{
DFHackAPIVectorC vec;
bool result = DFHackAPI_ReadGeology(self, &vec);
uint32_t i;
for (i = 0; i < vec.length; i++)
{
DFHackAPIVectorC &current = ((DFHackAPIVectorC *) vec.data)[i];
vector<uint16_t> 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 <t_vein> & 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 <string> &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<t_matgloss> & output)
{
return DFHackAPI_ReadStoneMatgloss(handle, output);
}
inline bool ReadWoodMatgloss (vector<t_matgloss> & output)
{
return DFHackAPI_ReadWoodMatgloss(handle, output);
}
inline bool ReadMetalMatgloss(vector<t_matgloss> & output)
{
return DFHackAPI_ReadMetalMatgloss(handle, output);
}
inline bool ReadPlantMatgloss(vector<t_matgloss> & 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 <uint16_t> >& 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 <t_vein> & 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 <string> &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

@ -27,7 +27,7 @@ distribution.
struct t_matgloss struct t_matgloss
{ {
string id; char id[128];
uint8_t fore; // Annoyingly the offset for this differs between types uint8_t fore; // Annoyingly the offset for this differs between types
uint8_t back; uint8_t back;
uint8_t bright; uint8_t bright;