From 93058506e08730336521c7831633ffa01d7c0b33 Mon Sep 17 00:00:00 2001 From: unknown Date: Wed, 31 Mar 2010 17:33:36 -0500 Subject: [PATCH] first commit Read/Write Designations works Signed-off-by: doomchild --- library/pydfhack/DF_API.cpp | 909 +++++++++++++++++++++++++++++++++ library/pydfhack/UnionBase.cpp | 191 +++++++ library/pydfhack/pydfhack.cpp | 31 ++ library/pydfhack/pydftypes.py | 423 +++++++++++++++ library/pydfhack/setup.py | 9 + library/pydfhack/test.py | 1 + 6 files changed, 1564 insertions(+) create mode 100644 library/pydfhack/DF_API.cpp create mode 100644 library/pydfhack/UnionBase.cpp create mode 100644 library/pydfhack/pydfhack.cpp create mode 100644 library/pydfhack/pydftypes.py create mode 100644 library/pydfhack/setup.py create mode 100644 library/pydfhack/test.py diff --git a/library/pydfhack/DF_API.cpp b/library/pydfhack/DF_API.cpp new file mode 100644 index 000000000..0b5c46f9d --- /dev/null +++ b/library/pydfhack/DF_API.cpp @@ -0,0 +1,909 @@ +#ifndef __DFAPI__ +#define __DFAPI__ + +#include "Python.h" +#include +#include +#include "DFTypes.h" +#include "DFHackAPI.h" +#include "UnionBase.cpp" + +using namespace std; +using namespace DFHack; + +struct DF_API +{ + PyObject_HEAD + DFHack::API* api_Ptr; +}; + +// API type Allocation, Deallocation, and Initialization + +static PyObject* DF_API_new(PyTypeObject* type, PyObject* args, PyObject* kwds) +{ + DF_API* self; + + self = (DF_API*)type->tp_alloc(type, 0); + + if(self != NULL) + self->api_Ptr = NULL; + + return (PyObject*)self; +} + +static int DF_API_init(DF_API* self, PyObject* args, PyObject* kwds) +{ + const char* memFileString = NULL; + + if(self->api_Ptr == NULL) + { + if(!PyArg_ParseTuple(args, "s", &memFileString)) + return -1; + + if(memFileString) + self->api_Ptr = new DFHack::API(std::string(memFileString)); + else + return -1; + } + + return 0; +} + +static void DF_API_dealloc(DF_API* self) +{ + if(self != NULL) + { + if(self->api_Ptr != NULL) + { + delete self->api_Ptr; + + self->api_Ptr = NULL; + } + + self->ob_type->tp_free((PyObject*)self); + } +} + +// Accessors + +static PyObject* DF_API_getIsAttached(DF_API* self, void* closure) +{ + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->isAttached()) + Py_RETURN_TRUE; + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to read attached flag"); + Py_RETURN_FALSE; + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_getIsSuspended(DF_API* self, void* closure) +{ + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->isSuspended()) + Py_RETURN_TRUE; + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to read suspension flag"); + Py_RETURN_FALSE; + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_getIsPaused(DF_API* self, void* closure) +{ + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->ReadPauseState()) + Py_RETURN_TRUE; + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to read pause state"); + Py_RETURN_FALSE; + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_getMenuState(DF_API* self, void* closure) +{ + uint32_t menuState = 0; + + try + { + if(self->api_Ptr != NULL) + { + menuState = self->api_Ptr->ReadMenuState(); + + return PyInt_FromLong(menuState); + } + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to read menu state"); + Py_RETURN_NONE; + } + + Py_RETURN_NONE; +} + +static PyObject* DF_API_getViewCoords(DF_API* self, void* closure) +{ + int32_t x, y, z; + bool success; + + try + { + if(self->api_Ptr != NULL) + { + success = self->api_Ptr->getViewCoords(x, y, z); + + if(success) + { + return Py_BuildValue("iii", x, y, z); + } + else + Py_RETURN_NONE; + } + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to get view coordinates"); + Py_RETURN_NONE; + } + + Py_RETURN_NONE; +} + +static PyObject* DF_API_getSize(DF_API* self, void* closure) +{ + uint32_t x, y, z; + + try + { + if(self->api_Ptr != NULL) + { + self->api_Ptr->getSize(x, y, z); + return Py_BuildValue("III", x, y, z); + } + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to get view coordinates"); + Py_RETURN_NONE; + } + + Py_RETURN_NONE; +} + +static PyGetSetDef DF_API_getterSetters[] = +{ + {"is_attached", (getter)DF_API_getIsAttached, NULL, "is_attached", NULL}, + {"is_suspended", (getter)DF_API_getIsSuspended, NULL, "is_suspended", NULL}, + {"is_paused", (getter)DF_API_getIsPaused, NULL, "is_paused", NULL}, + {"menu_state", (getter)DF_API_getMenuState, NULL, "menu_state", NULL}, + {"view_coords", (getter)DF_API_getViewCoords, NULL, "view_coords", NULL}, + {"map_size", (getter)DF_API_getSize, NULL, "max_size", NULL}, + {NULL} // Sentinel +}; + +// API type methods + +static PyObject* DF_API_Attach(DF_API* self) +{ + if(self->api_Ptr != NULL) + if(self->api_Ptr->Attach()) + Py_RETURN_TRUE; + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_Detach(DF_API* self) +{ + if(self->api_Ptr != NULL) + if(self->api_Ptr->Detach()) + Py_RETURN_TRUE; + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_Suspend(DF_API* self) +{ + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->Suspend()) + Py_RETURN_TRUE; + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to suspend"); + Py_RETURN_FALSE; + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_Resume(DF_API* self) +{ + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->Resume()) + Py_RETURN_TRUE; + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to resume"); + Py_RETURN_FALSE; + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_AsyncSuspend(DF_API* self) +{ + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->AsyncSuspend()) + Py_RETURN_TRUE; + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to asynchronously suspend"); + Py_RETURN_FALSE; + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_ForceResume(DF_API* self) +{ + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->ForceResume()) + Py_RETURN_TRUE; + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to force resume"); + Py_RETURN_FALSE; + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_InitMap(DF_API* self) +{ + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->InitMap()) + Py_RETURN_TRUE; + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to initialize map"); + Py_RETURN_FALSE; + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_DestroyMap(DF_API* self) +{ + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->DestroyMap()) + Py_RETURN_TRUE; + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to destroy map"); + Py_RETURN_FALSE; + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_InitReadConstructions(DF_API* self) +{ + uint32_t numConstructions = 0; + + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->InitReadConstructions(numConstructions)) + return PyInt_FromLong(numConstructions); + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to read constructions"); + } + + Py_RETURN_NONE; +} + +static PyObject* DF_API_FinishReadConstructions(DF_API* self) +{ + try + { + if(self->api_Ptr != NULL) + { + self->api_Ptr->FinishReadConstructions(); + Py_RETURN_TRUE; + } + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to finish reading constructions"); + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_InitReadBuildings(DF_API* self) +{ + uint32_t numBuildings = 0; + + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->InitReadBuildings(numBuildings)) + return PyInt_FromLong(numBuildings); + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to read buildings"); + } + + Py_RETURN_NONE; +} + +static PyObject* DF_API_FinishReadBuildings(DF_API* self) +{ + try + { + if(self->api_Ptr != NULL) + { + self->api_Ptr->FinishReadBuildings(); + Py_RETURN_TRUE; + } + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to finish reading buildings"); + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_InitReadEffects(DF_API* self) +{ + uint32_t numEffects = 0; + + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->InitReadEffects(numEffects)) + return PyInt_FromLong(numEffects); + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to read effects"); + } + + Py_RETURN_NONE; +} + +static PyObject* DF_API_FinishReadEffects(DF_API* self) +{ + try + { + if(self->api_Ptr != NULL) + { + self->api_Ptr->FinishReadEffects(); + Py_RETURN_TRUE; + } + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to finish reading effects"); + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_InitReadVegetation(DF_API* self) +{ + uint32_t numVegetation = 0; + + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->InitReadVegetation(numVegetation)) + return PyInt_FromLong(numVegetation); + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to read vegetation"); + } + + Py_RETURN_NONE; +} + +static PyObject* DF_API_FinishReadVegetation(DF_API* self) +{ + try + { + if(self->api_Ptr != NULL) + { + self->api_Ptr->FinishReadVegetation(); + Py_RETURN_TRUE; + } + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to finish reading vegetation"); + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_InitReadCreatures(DF_API* self) +{ + uint32_t numCreatures = 0; + + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->InitReadCreatures(numCreatures)) + return PyInt_FromLong(numCreatures); + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to read creatures"); + } + + Py_RETURN_NONE; +} + +static PyObject* DF_API_FinishReadCreatures(DF_API* self) +{ + try + { + if(self->api_Ptr != NULL) + { + self->api_Ptr->FinishReadCreatures(); + Py_RETURN_TRUE; + } + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to finish reading creatures"); + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_InitReadNotes(DF_API* self) +{ + uint32_t numNotes = 0; + + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->InitReadNotes(numNotes)) + return PyInt_FromLong(numNotes); + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to read notes"); + } + + Py_RETURN_NONE; +} + +static PyObject* DF_API_FinishReadNotes(DF_API* self) +{ + try + { + if(self->api_Ptr != NULL) + { + self->api_Ptr->FinishReadNotes(); + Py_RETURN_TRUE; + } + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to finish reading notes"); + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_InitReadSettlements(DF_API* self) +{ + uint32_t numSettlements = 0; + + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->InitReadSettlements(numSettlements)) + return PyInt_FromLong(numSettlements); + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to read settlements"); + } + + Py_RETURN_NONE; +} + +static PyObject* DF_API_FinishReadSettlements(DF_API* self) +{ + try + { + if(self->api_Ptr != NULL) + { + self->api_Ptr->FinishReadSettlements(); + Py_RETURN_TRUE; + } + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to finish reading settlements"); + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_InitReadItems(DF_API* self) +{ + uint32_t numItems = 0; + + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->InitReadItems(numItems)) + return PyInt_FromLong(numItems); + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to read items"); + } + + Py_RETURN_NONE; +} + +static PyObject* DF_API_FinishReadItems(DF_API* self) +{ + try + { + if(self->api_Ptr != NULL) + { + self->api_Ptr->FinishReadItems(); + Py_RETURN_TRUE; + } + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to finish reading items"); + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_InitReadHotkeys(DF_API* self) +{ + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->InitReadHotkeys()) + Py_RETURN_TRUE; + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to initialize hotkey reader"); + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_InitViewSize(DF_API* self) +{ + try + { + if(self->api_Ptr != NULL) + if(self->api_Ptr->InitViewSize()) + Py_RETURN_TRUE; + } + catch(...) + { + PyErr_SetString(PyExc_ValueError, "Error trying to initialize view size"); + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_IsValidBlock(DF_API* self, PyObject* args) +{ + uint32_t blockx, blocky, blockz; + bool valid; + + if(self->api_Ptr != NULL) + { + if(!PyArg_ParseTuple(args, "III", &blockx, &blocky, &blockz)) + Py_RETURN_NONE; + + valid = self->api_Ptr->isValidBlock(blockx, blocky, blockz); + + if(valid) + Py_RETURN_TRUE; + else + Py_RETURN_FALSE; + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_ReadDesignations(DF_API* self, PyObject* args) +{ + uint32_t blockx, blocky, blockz; + DFHack::designations40d designations; + PyObject* list = NULL; + + if(self->api_Ptr != NULL) + { + if(!PyArg_ParseTuple(args, "III", &blockx, &blocky, &blockz)) + Py_RETURN_NONE; + + self->api_Ptr->ReadDesignations(blockx, blocky, blockz, &designations); + + list = PyList_New(16); + + for(int i = 0; i < 16; i++) + { + PyObject* innerList = PyList_New(16); + + for(int j = 0; j < 16; j++) + { + PyList_SetItem(innerList, j, PyInt_FromLong(designations[i][j].whole)); + } + + PyList_SetItem(list, i, innerList); + } + } + + return list; +} + +static PyObject* DF_API_WriteDesignations(DF_API* self, PyObject* args) +{ + uint32_t blockx, blocky, blockz; + DFHack::designations40d designations; + PyObject* list; + + if(self->api_Ptr != NULL) + { + if(!PyArg_ParseTuple(args, "IIIO", &blockx, &blocky, &blockz, &list)) + Py_RETURN_NONE; + + for(int i = 0; i < 16; i++) + { + PyObject* innerList = PyList_GetItem(list, i); + + for(int j = 0; j < 16; j++) + { + UnionBase* obj = (UnionBase*)PyList_GetItem(innerList, j); + + designations[i][j].whole = obj->whole; + } + } + + self->api_Ptr->WriteDesignations(blockx, blocky, blockz, &designations); + + Py_RETURN_TRUE; + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_ReadOccupancy(DF_API* self, PyObject* args) +{ + uint32_t blockx, blocky, blockz; + DFHack::occupancies40d occupancies; + PyObject* list = NULL; + + if(self->api_Ptr != NULL) + { + if(!PyArg_ParseTuple(args, "III", &blockx, &blocky, &blockz)) + Py_RETURN_NONE; + + self->api_Ptr->ReadOccupancy(blockx, blocky, blockz, &occupancies); + + list = PyList_New(16); + + for(int i = 0; i < 16; i++) + { + PyObject* innerList = PyList_New(16); + + for(int j = 0; j < 16; j++) + { + PyList_SetItem(innerList, j, PyInt_FromLong(occupancies[i][j].whole)); + } + + PyList_SetItem(list, i, innerList); + } + } + + return list; +} + +static PyObject* DF_API_WriteOccupancy(DF_API* self, PyObject* args) +{ + uint32_t blockx, blocky, blockz; + DFHack::occupancies40d occupancies; + PyObject* list; + + if(self->api_Ptr != NULL) + { + if(!PyArg_ParseTuple(args, "IIIO", &blockx, &blocky, &blockz, &list)) + Py_RETURN_NONE; + + for(int i = 0; i < 16; i++) + { + PyObject* innerList = PyList_GetItem(list, i); + + for(int j = 0; j < 16; j++) + { + UnionBase* obj = (UnionBase*)PyList_GetItem(innerList, j); + + occupancies[i][j].whole = obj->whole; + } + } + + self->api_Ptr->WriteOccupancy(blockx, blocky, blockz, &occupancies); + + Py_RETURN_TRUE; + } + + Py_RETURN_FALSE; +} + +static PyObject* DF_API_ReadDirtyBit(DF_API* self, PyObject* args) +{ + uint32_t blockx, blocky, blockz; + bool dirty; + + if(self->api_Ptr == NULL) + return NULL; + else + { + if(!PyArg_ParseTuple(args, "III", &blockx, &blocky, &blockz)) + return NULL; + + self->api_Ptr->ReadDirtyBit(blockx, blocky, blockz, dirty); + + if(dirty) + Py_RETURN_TRUE; + else + Py_RETURN_FALSE; + } +} + +static PyObject* DF_API_WriteDirtyBit(DF_API* self, PyObject* args) +{ + uint32_t blockx, blocky, blockz; + int dirtyFlag; + + if(self->api_Ptr == NULL) + return NULL; + else + { + if(!PyArg_ParseTuple(args, "IIIi", &blockx, &blocky, &blockz, &dirtyFlag)) + return NULL; + + self->api_Ptr->WriteDirtyBit(blockx, blocky, blockz, dirtyFlag); + + Py_RETURN_TRUE; + } +} + +static PyMethodDef DF_API_methods[] = +{ + {"Attach", (PyCFunction)DF_API_Attach, METH_NOARGS, "Attach to the DF process"}, + {"Detach", (PyCFunction)DF_API_Detach, METH_NOARGS, "Detach from the DF process"}, + {"Suspend", (PyCFunction)DF_API_Suspend, METH_NOARGS, "Suspend the DF process"}, + {"Resume", (PyCFunction)DF_API_Resume, METH_NOARGS, "Resume the DF process"}, + {"Async_Suspend", (PyCFunction)DF_API_AsyncSuspend, METH_NOARGS, "Asynchronously suspend the DF process"}, + {"Force_Resume", (PyCFunction)DF_API_ForceResume, METH_NOARGS, "Force the DF process to resume"}, + {"Init_Map", (PyCFunction)DF_API_InitMap, METH_NOARGS, "Initialize the DFHack map reader"}, + {"Destroy_Map", (PyCFunction)DF_API_DestroyMap, METH_NOARGS, "Shut down the DFHack map reader"}, + {"Init_Read_Constructions", (PyCFunction)DF_API_InitReadConstructions, METH_NOARGS, "Initialize construction reader"}, + {"Finish_Read_Constructions", (PyCFunction)DF_API_FinishReadConstructions, METH_NOARGS, "Shut down construction reader"}, + {"Init_Read_Buildings", (PyCFunction)DF_API_InitReadBuildings, METH_NOARGS, "Initialize building reader"}, + {"Finish_Read_Buildings", (PyCFunction)DF_API_FinishReadBuildings, METH_NOARGS, "Shut down building reader"}, + {"Init_Read_Effects", (PyCFunction)DF_API_InitReadEffects, METH_NOARGS, "Initialize effect reader"}, + {"Finish_Read_Effects", (PyCFunction)DF_API_FinishReadEffects, METH_NOARGS, "Shut down effect reader"}, + {"Init_Read_Vegetation", (PyCFunction)DF_API_InitReadVegetation, METH_NOARGS, "Initialize vegetation reader"}, + {"Finish_Read_Vegetation", (PyCFunction)DF_API_FinishReadVegetation, METH_NOARGS, "Shut down vegetation reader"}, + {"Init_Read_Creatures", (PyCFunction)DF_API_InitReadCreatures, METH_NOARGS, "Initialize creature reader"}, + {"Finish_Read_Creatures", (PyCFunction)DF_API_FinishReadCreatures, METH_NOARGS, "Shut down creature reader"}, + {"Init_Read_Notes", (PyCFunction)DF_API_InitReadNotes, METH_NOARGS, "Initialize note reader"}, + {"Finish_Read_Notes", (PyCFunction)DF_API_FinishReadNotes, METH_NOARGS, "Shut down note reader"}, + {"Init_Read_Settlements", (PyCFunction)DF_API_InitReadSettlements, METH_NOARGS, "Initialize settlement reader"}, + {"Finish_Read_Settlements", (PyCFunction)DF_API_FinishReadSettlements, METH_NOARGS, "Shut down settlement reader"}, + {"Init_Read_Items", (PyCFunction)DF_API_InitReadItems, METH_NOARGS, "Initialize item reader"}, + {"Finish_Read_Items", (PyCFunction)DF_API_FinishReadItems, METH_NOARGS, "Shut down item reader"}, + {"Init_Read_Hotkeys", (PyCFunction)DF_API_InitReadHotkeys, METH_NOARGS, "Initialize hotkey reader"}, + {"Init_View_Size", (PyCFunction)DF_API_InitViewSize, METH_NOARGS, "Initialize view size reader"}, + {"Is_Valid_Block", (PyCFunction)DF_API_IsValidBlock, METH_VARARGS, ""}, + {"Read_Designations", (PyCFunction)DF_API_ReadDesignations, METH_VARARGS, "Read a block's designations"}, + {"Write_Designations", (PyCFunction)DF_API_WriteDesignations, METH_VARARGS, ""}, + {"Read_Occupancy", (PyCFunction)DF_API_ReadOccupancy, METH_VARARGS, ""}, + {"Write_Occupancy", (PyCFunction)DF_API_WriteOccupancy, METH_VARARGS, ""}, + {"Read_Dirty_Bit", (PyCFunction)DF_API_ReadDirtyBit, METH_VARARGS, ""}, + {"Write_Dirty_Bit", (PyCFunction)DF_API_WriteDirtyBit, METH_VARARGS, ""}, + {NULL} // Sentinel +}; + +static PyTypeObject DF_API_type = +{ + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "pydfhack.API", /*tp_name*/ + sizeof(DF_API), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + (destructor)DF_API_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "pydfhack API objects", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + DF_API_methods, /* tp_methods */ + 0, /* tp_members */ + DF_API_getterSetters, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)DF_API_init, /* tp_init */ + 0, /* tp_alloc */ + DF_API_new, /* tp_new */ +}; + +#endif \ No newline at end of file diff --git a/library/pydfhack/UnionBase.cpp b/library/pydfhack/UnionBase.cpp new file mode 100644 index 000000000..6a32a66a7 --- /dev/null +++ b/library/pydfhack/UnionBase.cpp @@ -0,0 +1,191 @@ +#ifndef __UNIONBASE__ +#define __UNIONBASE__ + +#include + +struct UnionBase +{ + PyObject_HEAD + unsigned int whole; +}; + +static PyObject* UnionBase_new(PyTypeObject* type, PyObject* args, PyObject* kwds) +{ + UnionBase* self; + + self = (UnionBase*)type->tp_alloc(type, 0); + + if(self != NULL) + self->whole = 0; + else + return NULL; + + return (PyObject*)self; +} + +static int UnionBase_init(UnionBase* self, PyObject* args, PyObject* kwds) +{ + if(!PyArg_ParseTuple(args, "|I", &self->whole)) + return -1; + + return 0; +} + +static void UnionBase_dealloc(UnionBase* self) +{ + self->ob_type->tp_free((PyObject*)self); +} + +static PyObject* UnionBase_GetBitMask(UnionBase* self, PyObject* args) +{ + unsigned int mask; + + if(!PyArg_ParseTuple(args, "I", &mask)) + Py_RETURN_NONE; + + if((self->whole & mask) != 0) + Py_RETURN_TRUE; + + Py_RETURN_FALSE; +} + +static PyObject* UnionBase_SetBitMask(UnionBase* self, PyObject* args) +{ + unsigned int mask; + int on; + + if(!PyArg_ParseTuple(args, "Ii", &mask, &on)) + return NULL; + + if(on) + self->whole |= mask; + else + self->whole &= ~mask; + + Py_RETURN_TRUE; +} + +static PyObject* UnionBase_GetSingleBit(UnionBase* self, PyObject* args) +{ + unsigned int mask; + + if(!PyArg_ParseTuple(args, "I", &mask)) + Py_RETURN_NONE; + + if((self->whole & (1 << mask)) != 0) + Py_RETURN_TRUE; + + Py_RETURN_FALSE; +} + +static PyObject* UnionBase_SetSingleBit(UnionBase* self, PyObject* args) +{ + unsigned int mask; + int on; + + if(!PyArg_ParseTuple(args, "Ii", &mask, &on)) + return NULL; + + if(on) + self->whole |= (1 << mask); + else + self->whole &= ~(1 << mask); + + Py_RETURN_TRUE; +} + +static PyObject* UnionBase_int(PyObject* self) +{ + return PyInt_FromLong(((UnionBase*)self)->whole); +} + +static PyObject* UnionBase_long(PyObject* self) +{ + return PyInt_FromLong(((UnionBase*)self)->whole); +} + +static PyObject* UnionBase_hex(PyObject* self) +{ + return PyNumber_ToBase(PyInt_FromLong(((UnionBase*)self)->whole), 16); +} + +static PyMethodDef UnionBase_methods[] = +{ + {"_get_mask_bit", (PyCFunction)UnionBase_GetSingleBit, METH_VARARGS, "Get mask bit"}, + {"_set_mask_bit", (PyCFunction)UnionBase_SetSingleBit, METH_VARARGS, "Set mask bit"}, + {"_get_mask", (PyCFunction)UnionBase_GetBitMask, METH_VARARGS, ""}, + {"_set_mask", (PyCFunction)UnionBase_SetBitMask, METH_VARARGS, ""}, + {NULL} //Sentinel +}; + +static PyNumberMethods UnionBase_as_number[] = +{ + 0, // binaryfunc nb_add; /* __add__ */ + 0, // binaryfunc nb_subtract; /* __sub__ */ + 0, // binaryfunc nb_multiply; /* __mul__ */ + 0, // binaryfunc nb_divide; /* __div__ */ + 0, // binaryfunc nb_remainder; /* __mod__ */ + 0, // binaryfunc nb_divmod; /* __divmod__ */ + 0, // ternaryfunc nb_power; /* __pow__ */ + 0, // unaryfunc nb_negative; /* __neg__ */ + 0, // unaryfunc nb_positive; /* __pos__ */ + 0, // unaryfunc nb_absolute; /* __abs__ */ + 0, // inquiry nb_nonzero; /* __nonzero__ */ + 0, // unaryfunc nb_invert; /* __invert__ */ + 0, // binaryfunc nb_lshift; /* __lshift__ */ + 0, // binaryfunc nb_rshift; /* __rshift__ */ + 0, // binaryfunc nb_and; /* __and__ */ + 0, // binaryfunc nb_xor; /* __xor__ */ + 0, // binaryfunc nb_or; /* __or__ */ + 0, // coercion nb_coerce; /* __coerce__ */ + UnionBase_int, // unaryfunc nb_int; /* __int__ */ + UnionBase_long, // unaryfunc nb_long; /* __long__ */ + 0, // unaryfunc nb_float; /* __float__ */ + 0, // unaryfunc nb_oct; /* __oct__ */ + UnionBase_hex, // unaryfunc nb_hex; /* __hex__ */ +}; + +static PyTypeObject UnionBase_type = +{ + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "pydfhack.UnionBase", /*tp_name*/ + sizeof(UnionBase), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + (destructor)UnionBase_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + UnionBase_as_number, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "pydfhack UnionBase objects", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + UnionBase_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)UnionBase_init, /* tp_init */ + 0, /* tp_alloc */ + UnionBase_new, /* tp_new */ +}; + +#endif \ No newline at end of file diff --git a/library/pydfhack/pydfhack.cpp b/library/pydfhack/pydfhack.cpp new file mode 100644 index 000000000..ea6dc1e75 --- /dev/null +++ b/library/pydfhack/pydfhack.cpp @@ -0,0 +1,31 @@ +#include "Python.h" +#include "UnionBase.cpp" +#include "DF_API.cpp" + +#ifndef PyMODINIT_FUNC +#define PyMODINIT_FUNC void +#endif + +static PyMethodDef module_methods[] = +{ + {NULL} //Sentinel +}; + +PyMODINIT_FUNC initpydfhack(void) +{ + PyObject* module; + + if(PyType_Ready(&UnionBase_type) < 0) + return; + + if(PyType_Ready(&DF_API_type) < 0) + return; + + module = Py_InitModule3("pydfhack", module_methods, "pydfhack extension module"); + + Py_INCREF(&UnionBase_type); + Py_INCREF(&DF_API_type); + + PyModule_AddObject(module, "UnionBase", (PyObject*)&UnionBase_type); + PyModule_AddObject(module, "API", (PyObject*)&DF_API_type); +} \ No newline at end of file diff --git a/library/pydfhack/pydftypes.py b/library/pydfhack/pydftypes.py new file mode 100644 index 000000000..81c0b23dd --- /dev/null +++ b/library/pydfhack/pydftypes.py @@ -0,0 +1,423 @@ +from pydfhack import * + +class DFAPI(API): + def Read_Designations(self, x, y, z): + d_list = [DesignationFlags(d) for d in API.Read_Designations(self, x, y, z)] + + return d_list + def Read_Occupancy(self, x, y, z): + o_list = [OccupancyFlags(o) for o in API.Read_Occupancy(self, x, y, z)] + + return o_list + +class CreatureFlags1(_UnionBase): + move_state = property(fget = lambda self: self._get_mask_bit(0), + fset = lambda self, val: self._set_mask_bit(0, val)) + dead = property(fget = lambda self: self._get_mask_bit(1), + fset = lambda self, val: self._set_mask_bit(1, val)) + has_mood = property(fget = lambda self: self._get_mask_bit(2), + fset = lambda self, val: self._set_mask_bit(2, val)) + had_mood = property(fget = lambda self: self._get_mask_bit(3), + fset = lambda self, val: self._set_mask_bit(3, val)) + + marauder = property(fget = lambda self: self._get_mask_bit(4), + fset = lambda self, val: self._set_mask_bit(4, val)) + drowning = property(fget = lambda self: self._get_mask_bit(5), + fset = lambda self, val: self._set_mask_bit(5, val)) + merchant = property(fget = lambda self: self._get_mask_bit(6), + fset = lambda self, val: self._set_mask_bit(6, val)) + forest = property(fget = lambda self: self._get_mask_bit(7), + fset = lambda self, val: self._set_mask_bit(7, val)) + + left = property(fget = lambda self: self._get_mask_bit(8), + fset = lambda self, val: self._set_mask_bit(8, val)) + rider = property(fget = lambda self: self._get_mask_bit(9), + fset = lambda self, val: self._set_mask_bit(9, val)) + incoming = property(fget = lambda self: self._get_mask_bit(10), + fset = lambda self, val: self._set_mask_bit(10, val)) + diplomat = property(fget = lambda self: self._get_mask_bit(11), + fset = lambda self, val: self._set_mask_bit(11, val)) + + zombie = property(fget = lambda self: self._get_mask_bit(12), + fset = lambda self: self._set_mask_bit(12, val)) + skeleton = property(fget = lambda self: self._get_mask_bit(13), + fset = lambda self, val: self._set_mask_bit(13, val)) + can_swap = property(fget = lambda self: self._get_mask_bit(14), + fset = lambda self, val: self._set_mask_bit(14, val)) + on_ground = property(fget = lambda self: self._get_mask_bit(15), + fset = lambda self, val: self._set_mask_bit(15, val)) + + projectile = property(fget = lambda self: self._get_mask_bit(16), + fset = lambda self, val: self._set_mask_bit(16, val)) + active_invader = property(fget = lambda self: self._get_mask_bit(17), + fset = lambda self, val: self._set_mask_bit(17, val)) + hidden_in_ambush = property(fget = lambda self: self._get_mask_bit(18), + fset = lambda self, val: self._set_mask_bit(18, val)) + invader_origin = property(fget = lambda self: self._get_mask_bit(19), + fset = lambda self, val: self._set_mask_bit(19, val)) + + coward = property(fget = lambda self: self._get_mask_bit(20), + fset = lambda self, val: self._set_mask_bit(20, val)) + hidden_ambusher = property(fget = lambda self: self._get_mask_bit(21), + fset = lambda self, val: self._set_mask_bit(21, val)) + invades = property(fget = lambda self: self._get_mask_bit(22), + fset = lambda self, val: self._set_mask_bit(22, val)) + check_flows = property(fget = lambda self: self._get_mask_bit(23), + fset = lambda self, val: self._set_mask_bit(23, val)) + + ridden = property(fget = lambda self: self._get_mask_bit(24), + fset = lambda self, val: self._set_mask_bit(24, val)) + caged = property(fget = lambda self: self._get_mask_bit(25), + fset = lambda self, val: self._set_mask_bit(25, val)) + tame = property(fget = lambda self: self._get_mask_bit(26), + fset = lambda self, val: self._set_mask_bit(26, val)) + chained = property(fget = lambda self: self._get_mask_bit(27), + fset = lambda self, val: self._set_mask_bit(27, val)) + + royal_guard = property(fget = lambda self: self._get_mask_bit(28), + fset = lambda self, val: self._set_mask_bit(28, val)) + fortress_guard = property(fget = lambda self: self._get_mask_bit(29), + fset = lambda self, val: self._set_mask_bit(29, val)) + suppress_wield = property(fget = lambda self: self._get_mask_bit(30), + fset = lambda self, val: self._set_mask_bit(30, val)) + important_historial_figure = property(fget = lambda self: self._get_mask_bit(31), + fset = lambda self, val: self._set_mask_bit(31, val)) + +class CreatureFlags2(_UnionBase): + swimming = property(fget = lambda self: self._get_mask_bit(0), + fset = lambda self, val: self._set_mask_bit(0, val)) + sparring = property(fget = lambda self: self._get_mask_bit(1), + fset = lambda self, val: self._set_mask_bit(1, val)) + no_notify = property(fget = lambda self: self._get_mask_bit(2), + fset = lambda self, val: self._set_mask_bit(2, val)) + unused = property(fget = lambda self: self._get_mask_bit(3), + fset = lambda self, val: self._set_mask_bit(3, val)) + + calculated_nerves = property(fget = lambda self: self._get_mask_bit(4), + fset = lambda self, val: self._set_mask_bit(4, val)) + calculated_bodyparts = property(fget = lambda self: self._get_mask_bit(5), + fset = lambda self, val: self._set_mask_bit(5, val)) + important_historical_figure = property(fget = lambda self: self._get_mask_bit(6), + fset = lambda self, val: self._set_mask_bit(6, val)) + killed = property(fget = lambda self: self._get_mask_bit(7), + fset = lambda self, val: self._set_mask_bit(7, val)) + + cleanup_1 = property(fget = lambda self: self._get_mask_bit(8), + fset = lambda self, val: self._set_mask_bit(8, val)) + cleanup_2 = property(fget = lambda self: self._get_mask_bit(9), + fset = lambda self, val: self._set_mask_bit(9, val)) + cleanup_3 = property(fget = lambda self: self._get_mask_bit(10), + fset = lambda self, val: self._set_mask_bit(10, val)) + for_trade = property(fget = lambda self: self._get_mask_bit(11), + fset = lambda self, val: self._set_mask_bit(11, val)) + + trade_resolved = property(fget = lambda self: self._get_mask_bit(12), + fset = lambda self: self._set_mask_bit(12, val)) + has_breaks = property(fget = lambda self: self._get_mask_bit(13), + fset = lambda self, val: self._set_mask_bit(13, val)) + gutted = property(fget = lambda self: self._get_mask_bit(14), + fset = lambda self, val: self._set_mask_bit(14, val)) + circulatory_spray = property(fget = lambda self: self._get_mask_bit(15), + fset = lambda self, val: self._set_mask_bit(15, val)) + + locked_in_for_trading = property(fget = lambda self: self._get_mask_bit(16), + fset = lambda self, val: self._set_mask_bit(16, val)) + slaughter = property(fget = lambda self: self._get_mask_bit(17), + fset = lambda self, val: self._set_mask_bit(17, val)) + underworld = property(fget = lambda self: self._get_mask_bit(18), + fset = lambda self, val: self._set_mask_bit(18, val)) + resident = property(fget = lambda self: self._get_mask_bit(19), + fset = lambda self, val: self._set_mask_bit(19, val)) + + cleanup_4 = property(fget = lambda self: self._get_mask_bit(20), + fset = lambda self, val: self._set_mask_bit(20, val)) + calculated_insulation = property(fget = lambda self: self._get_mask_bit(21), + fset = lambda self, val: self._set_mask_bit(21, val)) + visitor_uninvited = property(fget = lambda self: self._get_mask_bit(22), + fset = lambda self, val: self._set_mask_bit(22, val)) + visitor = property(fget = lambda self: self._get_mask_bit(23), + fset = lambda self, val: self._set_mask_bit(23, val)) + + calculated_inventory = property(fget = lambda self: self._get_mask_bit(24), + fset = lambda self, val: self._set_mask_bit(24, val)) + vision_good = property(fget = lambda self: self._get_mask_bit(25), + fset = lambda self, val: self._set_mask_bit(25, val)) + vision_damaged = property(fget = lambda self: self._get_mask_bit(26), + fset = lambda self, val: self._set_mask_bit(26, val)) + vision_missing = property(fget = lambda self: self._get_mask_bit(27), + fset = lambda self, val: self._set_mask_bit(27, val)) + + breathing_good = property(fget = lambda self: self._get_mask_bit(28), + fset = lambda self, val: self._set_mask_bit(28, val)) + breathing_problem = property(fget = lambda self: self._get_mask_bit(29), + fset = lambda self, val: self._set_mask_bit(29, val)) + roaming_wilderness_population_source = property(fget = lambda self: self._get_mask_bit(30), + fset = lambda self, val: self._set_mask_bit(30, val)) + roaming_wilderness_population_source_not_a_map_feature = property(fget = lambda self: self._get_mask_bit(31), + fset = lambda self, val: self._set_mask_bit(31, val)) + +class ItemFlags(_UnionBase): + on_ground = property(fget = lambda self: self._get_mask_bit(0), + fset = lambda self, val: self._set_mask_bit(0, val)) + in_job = property(fget = lambda self: self._get_mask_bit(1), + fset = lambda self, val: self._set_mask_bit(1, val)) + in_inventory = property(fget = lambda self: self._get_mask_bit(2), + fset = lambda self, val: self._set_mask_bit(2, val)) + u_ngrd1 = property(fget = lambda self: self._get_mask_bit(3), + fset = lambda self, val: self._set_mask_bit(3, val)) + + in_workshop = property(fget = lambda self: self._get_mask_bit(4), + fset = lambda self, val: self._set_mask_bit(4, val)) + u_ngrd2 = property(fget = lambda self: self._get_mask_bit(5), + fset = lambda self, val: self._set_mask_bit(5, val)) + u_ngrd3 = property(fget = lambda self: self._get_mask_bit(6), + fset = lambda self, val: self._set_mask_bit(6, val)) + rotten = property(fget = lambda self: self._get_mask_bit(7), + fset = lambda self, val: self._set_mask_bit(7, val)) + + unk1 = property(fget = lambda self: self._get_mask_bit(8), + fset = lambda self, val: self._set_mask_bit(8, val)) + u_ngrd4 = property(fget = lambda self: self._get_mask_bit(9), + fset = lambda self, val: self._set_mask_bit(9, val)) + unk2 = property(fget = lambda self: self._get_mask_bit(10), + fset = lambda self, val: self._set_mask_bit(10, val)) + u_ngrd5 = property(fget = lambda self: self._get_mask_bit(11), + fset = lambda self, val: self._set_mask_bit(11, val)) + + unk3 = property(fget = lambda self: self._get_mask_bit(12), + fset = lambda self: self._set_mask_bit(12, val)) + u_ngrd6 = property(fget = lambda self: self._get_mask_bit(13), + fset = lambda self, val: self._set_mask_bit(13, val)) + narrow = property(fget = lambda self: self._get_mask_bit(14), + fset = lambda self, val: self._set_mask_bit(14, val)) + u_ngrd7 = property(fget = lambda self: self._get_mask_bit(15), + fset = lambda self, val: self._set_mask_bit(15, val)) + + worn = property(fget = lambda self: self._get_mask_bit(16), + fset = lambda self, val: self._set_mask_bit(16, val)) + unk4 = property(fget = lambda self: self._get_mask_bit(17), + fset = lambda self, val: self._set_mask_bit(17, val)) + u_ngrd8 = property(fget = lambda self: self._get_mask_bit(18), + fset = lambda self, val: self._set_mask_bit(18, val)) + forbid = property(fget = lambda self: self._get_mask_bit(19), + fset = lambda self, val: self._set_mask_bit(19, val)) + + unk5 = property(fget = lambda self: self._get_mask_bit(20), + fset = lambda self, val: self._set_mask_bit(20, val)) + dump = property(fget = lambda self: self._get_mask_bit(21), + fset = lambda self, val: self._set_mask_bit(21, val)) + on_fire = property(fget = lambda self: self._get_mask_bit(22), + fset = lambda self, val: self._set_mask_bit(22, val)) + melt = property(fget = lambda self: self._get_mask_bit(23), + fset = lambda self, val: self._set_mask_bit(23, val)) + + hidden = property(fget = lambda self: self._get_mask_bit(24), + fset = lambda self, val: self._set_mask_bit(24, val)) + u_ngrd9 = property(fget = lambda self: self._get_mask_bit(25), + fset = lambda self, val: self._set_mask_bit(25, val)) + unk6 = property(fget = lambda self: self._get_mask_bit(26), + fset = lambda self, val: self._set_mask_bit(26, val)) + unk7 = property(fget = lambda self: self._get_mask_bit(27), + fset = lambda self, val: self._set_mask_bit(27, val)) + + unk8 = property(fget = lambda self: self._get_mask_bit(28), + fset = lambda self, val: self._set_mask_bit(28, val)) + unk9 = property(fget = lambda self: self._get_mask_bit(29), + fset = lambda self, val: self._set_mask_bit(29, val)) + unk10 = property(fget = lambda self: self._get_mask_bit(30), + fset = lambda self, val: self._set_mask_bit(30, val)) + unk11 = property(fget = lambda self: self._get_mask_bit(31), + fset = lambda self, val: self._set_mask_bit(31, val)) + +dig_types = { "no" : 0, + "default" : 1, + "ud_stair" : 2, + "channel" : 3, + "ramp" : 4, + "d_stair" : 5, + "u_stair" : 6, + "whatever" : 7 } + +traffic_types = { "normal" : 0, + "low" : 1, + "high" : 2, + "restricted" : 3 } + +class DesignationFlags(_UnionBase): + def dig(self, dig_type): + if dig_type == "no": + self.dig_1 = False; self.dig_2 = False; self.dig_3 = False + elif dig_type == "default": + self.dig_1 = True; self.dig_2 = False; self.dig_3 = False + elif dig_type == "ud_stair": + self.dig_1 = False; self.dig_2 = True; self.dig_3 = False + elif dig_type == "channel": + self.dig_1 = True; self.dig_2 = True; self.dig_3 = False + elif dig_type == "ramp": + self.dig_1 = False; self.dig_2 = False; self.dig_3 = True + elif dig_type == "d_stair": + self.dig_1 = True; self.dig_2 = False; self.dig_3 = True + elif dig_type == "u_stair": + self.dig_1 = False; self.dig_2 = True; self.dig_3 = True + elif dig_type == "whatever": + self.dig_1 = True; self.dig_2 = True; self.dig_3 = True + + def set_traffic(self, traffic_type): + if traffic_type == "normal": + self.traffic_1 = False; self.traffic_2 = False + elif traffic_type == "low": + self.traffic_1 = True; self.traffic_2 = False + elif traffic_type == "high": + self.traffic_1 = False; self.traffic_2 = True + elif traffic_type == "restricted": + self.traffic_1 = True; self.traffic_2 = True + + flow_size_1 = property(fget = lambda self: self._get_mask_bit(0), + fset = lambda self, val: self._set_mask_bit(0, val)) + flow_size_2 = property(fget = lambda self: self._get_mask_bit(1), + fset = lambda self, val: self._set_mask_bit(1, val)) + flow_size_3 = property(fget = lambda self: self._get_mask_bit(2), + fset = lambda self, val: self._set_mask_bit(2, val)) + pile = property(fget = lambda self: self._get_mask_bit(3), + fset = lambda self, val: self._set_mask_bit(3, val)) + + dig_1 = property(fget = lambda self: self._get_mask_bit(4), + fset = lambda self, val: self._set_mask_bit(4, val)) + dig_2 = property(fget = lambda self: self._get_mask_bit(5), + fset = lambda self, val: self._set_mask_bit(5, val)) + dig_3 = property(fget = lambda self: self._get_mask_bit(6), + fset = lambda self, val: self._set_mask_bit(6, val)) + smooth_1 = property(fget = lambda self: self._get_mask_bit(7), + fset = lambda self, val: self._set_mask_bit(7, val)) + + smooth_2 = property(fget = lambda self: self._get_mask_bit(8), + fset = lambda self, val: self._set_mask_bit(8, val)) + hidden = property(fget = lambda self: self._get_mask_bit(9), + fset = lambda self, val: self._set_mask_bit(9, val)) + geolayer_index_1 = property(fget = lambda self: self._get_mask_bit(10), + fset = lambda self, val: self._set_mask_bit(10, val)) + geolayer_index_2 = property(fget = lambda self: self._get_mask_bit(11), + fset = lambda self, val: self._set_mask_bit(11, val)) + + geolayer_index_3 = property(fget = lambda self: self._get_mask_bit(12), + fset = lambda self, val: self._set_mask_bit(12, val)) + geolayer_index_4 = property(fget = lambda self: self._get_mask_bit(13), + fset = lambda self: self._set_mask_bit(13, val)) + light = property(fget = lambda self: self._get_mask_bit(14), + fset = lambda self, val: self._set_mask_bit(14, val)) + subterranean = property(fget = lambda self: self._get_mask_bit(15), + fset = lambda self, val: self._set_mask_bit(15, val)) + + skyview = property(fget = lambda self: self._get_mask_bit(16), + fset = lambda self, val: self._set_mask_bit(16, val)) + biome_1 = property(fget = lambda self: self._get_mask_bit(17), + fset = lambda self, val: self._set_mask_bit(17, val)) + biome_2 = property(fget = lambda self: self._get_mask_bit(18), + fset = lambda self, val: self._set_mask_bit(18, val)) + biome_3 = property(fget = lambda self: self._get_mask_bit(19), + fset = lambda self, val: self._set_mask_bit(19, val)) + + biome_4 = property(fget = lambda self: self._get_mask_bit(20), + fset = lambda self, val: self._set_mask_bit(20, val)) + liquid_type = property(fget = lambda self: self._get_mask_bit(21), + fset = lambda self, val: self._set_mask_bit(21, val)) + water_table = property(fget = lambda self: self._get_mask_bit(22), + fset = lambda self, val: self._set_mask_bit(22, val)) + rained = property(fget = lambda self: self._get_mask_bit(23), + fset = lambda self, val: self._set_mask_bit(23, val)) + + traffic_1 = property(fget = lambda self: self._get_mask_bit(24), + fset = lambda self, val: self._set_mask_bit(24, val)) + traffic_2 = property(fget = lambda self: self._get_mask_bit(25), + fset = lambda self, val: self._set_mask_bit(25, val)) + flow_forbid = property(fget = lambda self: self._get_mask_bit(26), + fset = lambda self, val: self._set_mask_bit(26, val)) + liquid_static = property(fget = lambda self: self._get_mask_bit(27), + fset = lambda self, val: self._set_mask_bit(27, val)) + + moss = property(fget = lambda self: self._get_mask_bit(28), + fset = lambda self, val: self._set_mask_bit(28, val)) + feature_present = property(fget = lambda self: self._get_mask_bit(29), + fset = lambda self, val: self._set_mask_bit(29, val)) + liquid_character_1 = property(fget = lambda self: self._get_mask_bit(30), + fset = lambda self, val: self._set_mask_bit(30, val)) + liquid_character_2 = property(fget = lambda self: self._get_mask_bit(31), + fset = lambda self, val: self._set_mask_bit(31, val)) + +class OccupancyFlags(_UnionBase): + def set_splatter(self, state): + if state: + self.whole &= 0xFFFFFFC0 + else: + self.whole &= ~0xFFFFFFC0 + building_1 = property(fget = lambda self: self._get_mask_bit(0), + fset = lambda self, val: self._set_mask_bit(0, val)) + building_2 = property(fget = lambda self: self._get_mask_bit(1), + fset = lambda self, val: self._set_mask_bit(1, val)) + building_3 = property(fget = lambda self: self._get_mask_bit(2), + fset = lambda self, val: self._set_mask_bit(2, val)) + unit = property(fget = lambda self: self._get_mask_bit(3), + fset = lambda self, val: self._set_mask_bit(3, val)) + + unit_grounded = property(fget = lambda self: self._get_mask_bit(4), + fset = lambda self, val: self._set_mask_bit(4, val)) + item = property(fget = lambda self: self._get_mask_bit(5), + fset = lambda self, val: self._set_mask_bit(5, val)) + mud = property(fget = lambda self: self._get_mask_bit(6), + fset = lambda self, val: self._set_mask_bit(6, val)) + vomit = property(fget = lambda self: self._get_mask_bit(7), + fset = lambda self, val: self._set_mask_bit(7, val)) + + broken_arrows_color_1 = property(fget = lambda self: self._get_mask_bit(8), + fset = lambda self, val: self._set_mask_bit(8, val)) + broken_arrows_color_2 = property(fget = lambda self: self._get_mask_bit(9), + fset = lambda self, val: self._set_mask_bit(9, val)) + broken_arrows_color_3 = property(fget = lambda self: self._get_mask_bit(10), + fset = lambda self, val: self._set_mask_bit(10, val)) + broken_arrows_color_4 = property(fget = lambda self: self._get_mask_bit(11), + fset = lambda self, val: self._set_mask_bit(11, val)) + + blood_g = property(fget = lambda self: self._get_mask_bit(12), + fset = lambda self: self._set_mask_bit(12, val)) + blood_g2 = property(fget = lambda self: self._get_mask_bit(13), + fset = lambda self, val: self._set_mask_bit(13, val)) + blood_b = property(fget = lambda self: self._get_mask_bit(14), + fset = lambda self, val: self._set_mask_bit(14, val)) + blood_b2 = property(fget = lambda self: self._get_mask_bit(15), + fset = lambda self, val: self._set_mask_bit(15, val)) + + blood_y = property(fget = lambda self: self._get_mask_bit(16), + fset = lambda self, val: self._set_mask_bit(16, val)) + blood_y2 = property(fget = lambda self: self._get_mask_bit(17), + fset = lambda self, val: self._set_mask_bit(17, val)) + blood_m = property(fget = lambda self: self._get_mask_bit(18), + fset = lambda self, val: self._set_mask_bit(18, val)) + blood_m2 = property(fget = lambda self: self._get_mask_bit(19), + fset = lambda self, val: self._set_mask_bit(19, val)) + + blood_c = property(fget = lambda self: self._get_mask_bit(20), + fset = lambda self, val: self._set_mask_bit(20, val)) + blood_c2 = property(fget = lambda self: self._get_mask_bit(21), + fset = lambda self, val: self._set_mask_bit(21, val)) + blood_w = property(fget = lambda self: self._get_mask_bit(22), + fset = lambda self, val: self._set_mask_bit(22, val)) + blood_w2 = property(fget = lambda self: self._get_mask_bit(23), + fset = lambda self, val: self._set_mask_bit(23, val)) + + blood_o = property(fget = lambda self: self._get_mask_bit(24), + fset = lambda self, val: self._set_mask_bit(24, val)) + blood_o2 = property(fget = lambda self: self._get_mask_bit(25), + fset = lambda self, val: self._set_mask_bit(25, val)) + slime = property(fget = lambda self: self._get_mask_bit(26), + fset = lambda self, val: self._set_mask_bit(26, val)) + slime2 = property(fget = lambda self: self._get_mask_bit(27), + fset = lambda self, val: self._set_mask_bit(27, val)) + + blood = property(fget = lambda self: self._get_mask_bit(28), + fset = lambda self, val: self._set_mask_bit(28, val)) + blood2 = property(fget = lambda self: self._get_mask_bit(29), + fset = lambda self, val: self._set_mask_bit(29, val)) + broken_arrows_variant = property(fget = lambda self: self._get_mask_bit(30), + fset = lambda self, val: self._set_mask_bit(30, val)) + snow = property(fget = lambda self: self._get_mask_bit(31), + fset = lambda self, val: self._set_mask_bit(31, val)) diff --git a/library/pydfhack/setup.py b/library/pydfhack/setup.py new file mode 100644 index 000000000..237e5515f --- /dev/null +++ b/library/pydfhack/setup.py @@ -0,0 +1,9 @@ +from distutils.core import setup, Extension + +e = Extension("pydfhack", + sources=["UnionBase.cpp", "pydfhack.cpp", "DF_API.cpp"], + include_dirs=["..\\"], + library_dirs=["..\\..\\output"], + libraries=["libdfhack"]) + +setup(name="PyDFHack", version="1.0", ext_modules=[e]) diff --git a/library/pydfhack/test.py b/library/pydfhack/test.py new file mode 100644 index 000000000..c6a7218c7 --- /dev/null +++ b/library/pydfhack/test.py @@ -0,0 +1 @@ +import pydfhack