Merge branch 'master' of http://github.com/doomchild/dfhack

library/python/c api/gui.py

@@ -1,25 +0,0 @@
-from ctypes import *
-from pydfhack import libdfhack, ViewScreen
-
-libdfhack.Gui_ReadViewScreen.argtypes = [ c_void_p, c_void_p ]
-
-class Gui(object):
-    def __init__(self, ptr):
-        self._gui_ptr = ptr
-
-    def start(self):
-        return libdfhack.Gui_Start(self._gui_ptr)
-
-    def finish(self):
-        return libdfhack.Gui_Finish(self._gui_ptr)
-
-    def read_pause_state(self):
-        return libdfhack.Gui_ReadPauseState(self._pos_ptr) > 0
-
-    def read_view_screen(self):
-        s = ViewScreen()
-
-        if libdfhack.Gui_ReadViewScreen(self._gui_ptr, byref(s)) > 0:
-            return s
-        else:
-            return None

library/python/c api/materials.py

@@ -1,141 +0,0 @@
-from ctypes import *
-from pydftypes import libdfhack
-from util import *
-
-_get_arg_types = [ c_void_p, _arr_create_func ]
-
-libdfhack.Materials_getInorganic.argtypes = _get_arg_types
-libdfhack.Materials_getOrganic.argtypes = _get_arg_types
-libdfhack.Materials_getTree.argtypes = _get_arg_types
-libdfhack.Materials_getPlant.argtypes = _get_arg_types
-libdfhack.Materials_getRace.argtypes = _get_arg_types
-#libdfhack.Materials_getRaceEx.argtypes = _get_arg_types
-libdfhack.Materials_getColor.argtypes = _get_arg_types
-libdfhack.Materials_getOther.argtypes = _get_arg_types
-
-class Materials(object):
-    def __init__(self, ptr):
-        self._mat_ptr = ptr
-
-        self.inorganic = None
-        self.organic = None
-        self.tree = None
-        self.plant = None
-        self.race = None
-        self.race_ex = None
-        self.color = None
-        self.other = None
-
-    def read_inorganic(self):
-        return libdfhack.Materials_ReadInorganicMaterials(self._mat_ptr)
-
-    def read_organic(self):
-        return libdfhack.Materials_ReadOrganicMaterials(self._mat_ptr)
-
-    def read_wood(self):
-        return libdfhack.Materials_ReadWoodMaterials(self._mat_ptr)
-
-    def read_plant(self):
-        return libdfhack.Materials_ReadPlantMaterials(self._mat_ptr)
-
-    def read_creature_types(self):
-        return libdfhack.Materials_ReadCreatureTypes(self._mat_ptr)
-
-    def read_creature_types_ex(self):
-        return libdfhack.Materials_ReadCreatureTypesEx(self._mat_ptr)
-
-    def read_descriptor_colors(self):
-        return libdfhack.Materials_ReadDescriptorColors(self._mat_ptr)
-
-    def read_others(self):
-        return libdfhack.Materials_ReadOthers(self._mat_ptr)
-
-    def read_all(self):
-        libdfhack.Materials_ReadAllMaterials(self._mat_ptr)
-
-    def get_description(self, material):
-        return libdfhack.Materials_getDescription(self._mat_ptr, byref(material))
-
-    def update_inorganic_cache(self):
-        def update_callback(count):
-            allocated = _allocate_array(Matgloss, count)
-
-            self.inorganic = allocated[0]
-
-            return allocated[1]
-
-        callback = _arr_create_func(update_callback)
-
-        return libdfhack.Materials_getInorganic(self._mat_ptr, callback)
-
-    def update_organic_cache(self):
-        def update_callback(count):
-            allocated = _allocate_array(Matgloss, count)
-
-            self.organic = allocated[0]
-
-            return allocated[1]
-
-        callback = _arr_create_func(update_callback)
-
-        return libdfhack.Materials_getOrganic(self._mat_ptr, callback)
-
-    def update_tree_cache(self):
-        def update_callback(count):
-            allocated = _allocate_array(Matgloss, count)
-
-            self.tree = allocated[0]
-
-            return allocated[1]
-
-        callback = _arr_create_func(update_callback)
-
-        return libdfhack.Materials_getTree(self._mat_ptr, callback)
-
-    def update_plant_cache(self):
-        def update_callback(count):
-            allocated = _allocate_array(Matgloss, count)
-
-            self.plant = allocated[0]
-
-            return allocated[1]
-
-        callback = _arr_create_func(update_callback)
-
-        return libdfhack.Materials_getPlant(self._mat_ptr, callback)
-
-    def update_race_cache(self):
-        def update_callback(count):
-            allocated = _allocate_array(Matgloss, count)
-
-            self.race = allocated[0]
-
-            return allocated[1]
-
-        callback = _arr_create_func(update_callback)
-
-        return libdfhack.Materials_getRace(self._mat_ptr, callback)
-
-    def update_color_cache(self):
-        def update_callback(count):
-            allocated = _allocate_array(DescriptorColor, count)
-
-            self.color = allocated[0]
-            
-            return allocated[1]
-
-        callback = _arr_create_func(update_callback)
-
-        return libdfhack.Materials_getColor(self._mat_ptr, callback)
-
-    def update_other_cache(self):
-        def update_callback(count):
-            allocated = _allocate_array(MatglossOther, count)
-
-            self.other = allocated[0]
-            
-            return allocated[1]
-
-        callback = _arr_create_func(update_callback)
-
-        return libdfhack.Materials_getOther(self._mat_ptr, callback)

library/python/c api/position.py

@@ -1,43 +0,0 @@
-from ctypes import *
-from pydftypes import libdfhack
-
-class Position(object):
-    def __init__(self, ptr):
-        self._pos_ptr = ptr
-
-        self._vx, self._vy, self._vz = c_int(), c_int(), c_int()
-        self._cx, self._cy, self._cz = c_int(), c_int(), c_int()
-        self._ww, self._wh = c_int(), c_int()
-
-    def get_view_coords(self):
-        if libdfhack.Position_getViewCoords(self._pos_ptr, byref(self._vx), byref(self._vy), byref(self._vz)) > 0:
-            return (self._vx.value, self._vy.value, self._vz.value)
-        else:
-            return (-1, -1, -1)
-
-    def set_view_coords(self, v_coords):
-        self._vx.value, self._vy.value, self._vz.value = v_coords
-
-        libdfhack.Position_setViewCoords(self._pos_ptr, self._vx, self._vy, self._vz)
-
-    view_coords = property(get_view_coords, set_view_coords)
-    
-    def get_cursor_coords(self):
-        if libdfhack.Position_getCursorCoords(self._pos_ptr, byref(self._cx), byref(self._cy), byref(self._cz)) > 0:
-            return (self._cx.value, self._cy.value, self._cz.value)
-        else:
-            return (-1, -1, -1)
-
-    def set_cursor_coords(self, c_coords):
-        self._cx.value, self._cy.value, self_cz.value = c_coords
-
-        libdfhack.Position_setCursorCoords(self._pos_ptr, self._cx, self._cy, self._cz)
-
-    cursor_coords = property(get_cursor_coords, set_cursor_coords)
-
-    @property
-    def window_size(self):
-        if libdfhack.Position_getWindowSize(self._pos_ptr, byref(self._ww), byref(self._wh)) > 0:
-            return (self._ww.value, self._wh.value)
-        else:
-            return (-1, -1)

library/python/c api/vegetation.py

@@ -1,25 +0,0 @@
-from ctypes import *
-from pydftypes import libdfhack, Tree
-
-class Vegetation(object):
-    def __init__(self, ptr):
-        self._v_ptr = ptr
-
-    def start(self):
-        n = c_uint(0)
-        
-        if libdfhack.Vegetation_Start(self._v_ptr, byref(n)) > 0:
-            return int(n.value)
-        else:
-            return -1
-
-    def finish(self):
-        return libdfhack.Vegetation_Finish(self._v_ptr) > 0
-
-    def read(self, index):
-        t = Tree()
-
-        if libdfhack.Vegetation_Read(self._v_ptr, c_uint(index), byref(t)) > 0:
-            return t
-        else:
-            return None

library/python/deprecated/pydfhack/__init__.py

@@ -0,0 +1 @@
+from .pydfapi import API

library/python/deprecated/pydfhack/gui.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+"""
+Python class for DF_Hack::GUI
+"""
+from ._pydfhack import _GUIManager
+class GUI(_GUIManager):
+    api = None
+    started = False
+    def __init__(self, api, *args, **kwds):
+        _GUIManager.__init__(self, args, kwds)
+        self.api = api
+
+    def prepare(self):
+        """
+        Enforce Suspend/Start
+        """
+        if self.api.prepare():
+            if not self.started:
+                self.started = self.Start()
+            return self.started
+        else:
+            return False
+                
+        
+

library/python/deprecated/pydfhack/materials.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+"""
+Python class for DF_Hack::Materials
+"""
+from ._pydfhack import _MaterialsManager
+from .mixins import NoStart
+from .decorators import suspend
+
+class Materials(NoStart, _MaterialsManager):
+    api = None
+    cls = _MaterialsManager
+    def __init__(self, api, *args, **kwds):
+        cls.__init__(self, args, kwds)
+        self.api = api
+
+    @suspend
+    def Read_Wood_Materials(self, *args, **kw):
+        return self.cls.Read_Wood_Materials(self, *args, **kw)
+
+    @suspend
+    def Read_Plant_Materials(self, *args, **kw):
+        return self.cls.Read_Plant_Materials(self, *args, **kw)
+
+    @suspend
+    def Read_Inorganic_Materials(self, *args, **kw):
+        return self.cls.Read_Inorganic_Materials(self, *args, **kw)
+
+    @suspend
+    def Read_Descriptor_Colors(self, *args, **kw):
+        return self.cls.Read_Descriptor_Colors(self, *args, **kw)
+
+    @suspend
+    def Read_Creature_Types(self, *args, **kw):
+        return self.cls.Read_Creature_Types(self, *args, **kw)
+
+    @suspend
+    def Read_Organic_Materials(self, *args, **kw):
+        return self.cls.Read_Organic_Materials(self, *args, **kw)
+
+    @suspend
+    def Read_Creature_Types_Ex(self, *args, **kw):
+        return self.cls.Read_Creature_Types_Ex(self, *args, **kw)

library/python/deprecated/pydfhack/position.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+"""
+Python class for DF_Hack::Position
+"""
+from ._pydfhack import _PositionManager
+from .blocks import Point, Block
+from .mixins import NoStart
+from .decorators import suspend
+
+class Position(NoStart, _PositionManager):
+    api = None
+    cls = _PositionManager
+    def __init__(self, api, *args, **kwds):
+        self.cls.__init__(self, args, kwds)
+        self.api = api
+
+    @suspend
+    def get_cursor(self):
+        coords = self.cursor_coords
+        if coords:
+            return Point(*coords)
+        else:
+            return None
+
+    @suspend
+    def get_window_size(self):
+        wsize = self.window_size
+        return wsize
+
+    @suspend
+    def get_view_coords(self):
+        coords = self.view_coords
+        return Point(*coords)
+
+    @suspend
+    def get_cursor_tile(self):
+        point = self.get_cursor()
+        if point:
+            tile = self.api.maps.get_tile(point=point)
+            return tile
+        else:
+            return None

library/python/deprecated/pydfhack/vegetation.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+"""
+Python class for DF_Hack::Vegetation
+"""
+from ._pydfhack import _VegetationManager
+from .mixins import NeedsStart
+from .decorators import suspend
+
+class Vegetation(NeedsStart, _VegetationManager):
+    api = None
+    cls = _VegetationManager
+    def __init__(self, api, *args, **kwds):
+        self.cls.__init__(self, args, kwds)
+        self.api = api
+        
+    @suspend
+    def Read(self, *args, **kw):
+        return self.cls.Read(self, *args, **kw)

library/python/pydfhack/__init__.py

@@ -1 +1,14 @@
-from .pydfapi import API
+import context
+
+__all__ = [ "buildings", 
+                "constructions", 
+                "context", 
+                "creatures", 
+                "dftypes",
+                "flags",
+                "gui", 
+                "items", 
+                "maps", 
+                "materials",
+                "position"
+                "vegetation" ]

library/python/pydfhack/context.py

@@ -168,38 +168,3 @@ class Context(object):
             self._tran_obj = translation.Translation(libdfhack.Context_getTranslation(self._c_ptr))
 
         return self._tran_obj
-
-def reveal():
-    df_cm = ContextManager("Memory.xml")
-    df = df_cm.get_single_context()
-    
-    df.attach()
-
-    m = df.maps
-
-    m.start()
-
-    m_x, m_y, m_z = m.size
-
-    for x in xrange(m_x):
-        for y in xrange(m_y):
-            for z in xrange(m_z):
-                if m.is_valid_block(x, y, z):
-                    d = m.read_designations(x, y, z)
-
-                    for i in d:
-                        for j in i:
-                            j.bits.hidden = 0
-
-                    m.write_designations(x, y, z, d)
-
-    m.finish()
-    df.detach()
-
-def resume():
-    df_cm = ContextManager("Memory.xml")
-    df = df_cm.get_single_context()
-
-    df.attach()
-    df.force_resume()
-    df.detach()

library/python/pydfhack/gui.py

@@ -1,25 +1,25 @@
-# -*- coding: utf-8 -*-
+from ctypes import *
-"""
+from pydfhack import libdfhack, ViewScreen
-Python class for DF_Hack::GUI
-"""
-from ._pydfhack import _GUIManager
-class GUI(_GUIManager):
-    api = None
-    started = False
-    def __init__(self, api, *args, **kwds):
-        _GUIManager.__init__(self, args, kwds)
-        self.api = api
 
-    def prepare(self):
+libdfhack.Gui_ReadViewScreen.argtypes = [ c_void_p, c_void_p ]
-        """
+
-        Enforce Suspend/Start
+class Gui(object):
-        """
+    def __init__(self, ptr):
-        if self.api.prepare():
+        self._gui_ptr = ptr
-            if not self.started:
+
-                self.started = self.Start()
+    def start(self):
-            return self.started
+        return libdfhack.Gui_Start(self._gui_ptr)
-        else:
-            return False
 
+    def finish(self):
+        return libdfhack.Gui_Finish(self._gui_ptr)
 
+    def read_pause_state(self):
+        return libdfhack.Gui_ReadPauseState(self._pos_ptr) > 0
 
+    def read_view_screen(self):
+        s = ViewScreen()
+
+        if libdfhack.Gui_ReadViewScreen(self._gui_ptr, byref(s)) > 0:
+            return s
+        else:
+            return None

library/python/pydfhack/materials.py

@@ -1,42 +1,141 @@
-# -*- coding: utf-8 -*-
+from ctypes import *
-"""
+from pydftypes import libdfhack
-Python class for DF_Hack::Materials
+from util import *
-"""
+
-from ._pydfhack import _MaterialsManager
+_get_arg_types = [ c_void_p, _arr_create_func ]
-from .mixins import NoStart
+
-from .decorators import suspend
+libdfhack.Materials_getInorganic.argtypes = _get_arg_types
-
+libdfhack.Materials_getOrganic.argtypes = _get_arg_types
-class Materials(NoStart, _MaterialsManager):
+libdfhack.Materials_getTree.argtypes = _get_arg_types
-    api = None
+libdfhack.Materials_getPlant.argtypes = _get_arg_types
-    cls = _MaterialsManager
+libdfhack.Materials_getRace.argtypes = _get_arg_types
-    def __init__(self, api, *args, **kwds):
+#libdfhack.Materials_getRaceEx.argtypes = _get_arg_types
-        cls.__init__(self, args, kwds)
+libdfhack.Materials_getColor.argtypes = _get_arg_types
-        self.api = api
+libdfhack.Materials_getOther.argtypes = _get_arg_types
-
+
-    @suspend
+class Materials(object):
-    def Read_Wood_Materials(self, *args, **kw):
+    def __init__(self, ptr):
-        return self.cls.Read_Wood_Materials(self, *args, **kw)
+        self._mat_ptr = ptr
-
+
-    @suspend
+        self.inorganic = None
-    def Read_Plant_Materials(self, *args, **kw):
+        self.organic = None
-        return self.cls.Read_Plant_Materials(self, *args, **kw)
+        self.tree = None
-
+        self.plant = None
-    @suspend
+        self.race = None
-    def Read_Inorganic_Materials(self, *args, **kw):
+        self.race_ex = None
-        return self.cls.Read_Inorganic_Materials(self, *args, **kw)
+        self.color = None
-
+        self.other = None
-    @suspend
+
-    def Read_Descriptor_Colors(self, *args, **kw):
+    def read_inorganic(self):
-        return self.cls.Read_Descriptor_Colors(self, *args, **kw)
+        return libdfhack.Materials_ReadInorganicMaterials(self._mat_ptr)
-
+
-    @suspend
+    def read_organic(self):
-    def Read_Creature_Types(self, *args, **kw):
+        return libdfhack.Materials_ReadOrganicMaterials(self._mat_ptr)
-        return self.cls.Read_Creature_Types(self, *args, **kw)
+
-
+    def read_wood(self):
-    @suspend
+        return libdfhack.Materials_ReadWoodMaterials(self._mat_ptr)
-    def Read_Organic_Materials(self, *args, **kw):
+
-        return self.cls.Read_Organic_Materials(self, *args, **kw)
+    def read_plant(self):
-
+        return libdfhack.Materials_ReadPlantMaterials(self._mat_ptr)
-    @suspend
+
-    def Read_Creature_Types_Ex(self, *args, **kw):
+    def read_creature_types(self):
-        return self.cls.Read_Creature_Types_Ex(self, *args, **kw)
+        return libdfhack.Materials_ReadCreatureTypes(self._mat_ptr)
+
+    def read_creature_types_ex(self):
+        return libdfhack.Materials_ReadCreatureTypesEx(self._mat_ptr)
+
+    def read_descriptor_colors(self):
+        return libdfhack.Materials_ReadDescriptorColors(self._mat_ptr)
+
+    def read_others(self):
+        return libdfhack.Materials_ReadOthers(self._mat_ptr)
+
+    def read_all(self):
+        libdfhack.Materials_ReadAllMaterials(self._mat_ptr)
+
+    def get_description(self, material):
+        return libdfhack.Materials_getDescription(self._mat_ptr, byref(material))
+
+    def update_inorganic_cache(self):
+        def update_callback(count):
+            allocated = _allocate_array(Matgloss, count)
+
+            self.inorganic = allocated[0]
+
+            return allocated[1]
+
+        callback = _arr_create_func(update_callback)
+
+        return libdfhack.Materials_getInorganic(self._mat_ptr, callback)
+
+    def update_organic_cache(self):
+        def update_callback(count):
+            allocated = _allocate_array(Matgloss, count)
+
+            self.organic = allocated[0]
+
+            return allocated[1]
+
+        callback = _arr_create_func(update_callback)
+
+        return libdfhack.Materials_getOrganic(self._mat_ptr, callback)
+
+    def update_tree_cache(self):
+        def update_callback(count):
+            allocated = _allocate_array(Matgloss, count)
+
+            self.tree = allocated[0]
+
+            return allocated[1]
+
+        callback = _arr_create_func(update_callback)
+
+        return libdfhack.Materials_getTree(self._mat_ptr, callback)
+
+    def update_plant_cache(self):
+        def update_callback(count):
+            allocated = _allocate_array(Matgloss, count)
+
+            self.plant = allocated[0]
+
+            return allocated[1]
+
+        callback = _arr_create_func(update_callback)
+
+        return libdfhack.Materials_getPlant(self._mat_ptr, callback)
+
+    def update_race_cache(self):
+        def update_callback(count):
+            allocated = _allocate_array(Matgloss, count)
+
+            self.race = allocated[0]
+
+            return allocated[1]
+
+        callback = _arr_create_func(update_callback)
+
+        return libdfhack.Materials_getRace(self._mat_ptr, callback)
+
+    def update_color_cache(self):
+        def update_callback(count):
+            allocated = _allocate_array(DescriptorColor, count)
+
+            self.color = allocated[0]
+            
+            return allocated[1]
+
+        callback = _arr_create_func(update_callback)
+
+        return libdfhack.Materials_getColor(self._mat_ptr, callback)
+
+    def update_other_cache(self):
+        def update_callback(count):
+            allocated = _allocate_array(MatglossOther, count)
+
+            self.other = allocated[0]
+            
+            return allocated[1]
+
+        callback = _arr_create_func(update_callback)
+
+        return libdfhack.Materials_getOther(self._mat_ptr, callback)

library/python/pydfhack/position.py

@@ -1,42 +1,43 @@
-# -*- coding: utf-8 -*-
+from ctypes import *
-"""
+from pydftypes import libdfhack
-Python class for DF_Hack::Position
+
-"""
+class Position(object):
-from ._pydfhack import _PositionManager
+    def __init__(self, ptr):
-from .blocks import Point, Block
+        self._pos_ptr = ptr
-from .mixins import NoStart
-from .decorators import suspend
-
-class Position(NoStart, _PositionManager):
-    api = None
-    cls = _PositionManager
-    def __init__(self, api, *args, **kwds):
-        self.cls.__init__(self, args, kwds)
-        self.api = api
-
-    @suspend
-    def get_cursor(self):
-        coords = self.cursor_coords
-        if coords:
-            return Point(*coords)
-        else:
-            return None
 
-    @suspend
+        self._vx, self._vy, self._vz = c_int(), c_int(), c_int()
-    def get_window_size(self):
+        self._cx, self._cy, self._cz = c_int(), c_int(), c_int()
-        wsize = self.window_size
+        self._ww, self._wh = c_int(), c_int()
-        return wsize
 
-    @suspend
     def get_view_coords(self):
-        coords = self.view_coords
+        if libdfhack.Position_getViewCoords(self._pos_ptr, byref(self._vx), byref(self._vy), byref(self._vz)) > 0:
-        return Point(*coords)
+            return (self._vx.value, self._vy.value, self._vz.value)
-
+        else:
-    @suspend
+            return (-1, -1, -1)
-    def get_cursor_tile(self):
+
-        point = self.get_cursor()
+    def set_view_coords(self, v_coords):
-        if point:
+        self._vx.value, self._vy.value, self._vz.value = v_coords
-            tile = self.api.maps.get_tile(point=point)
+
-            return tile
+        libdfhack.Position_setViewCoords(self._pos_ptr, self._vx, self._vy, self._vz)
+
+    view_coords = property(get_view_coords, set_view_coords)
+    
+    def get_cursor_coords(self):
+        if libdfhack.Position_getCursorCoords(self._pos_ptr, byref(self._cx), byref(self._cy), byref(self._cz)) > 0:
+            return (self._cx.value, self._cy.value, self._cz.value)
+        else:
+            return (-1, -1, -1)
+
+    def set_cursor_coords(self, c_coords):
+        self._cx.value, self._cy.value, self_cz.value = c_coords
+
+        libdfhack.Position_setCursorCoords(self._pos_ptr, self._cx, self._cy, self._cz)
+
+    cursor_coords = property(get_cursor_coords, set_cursor_coords)
+
+    @property
+    def window_size(self):
+        if libdfhack.Position_getWindowSize(self._pos_ptr, byref(self._ww), byref(self._wh)) > 0:
+            return (self._ww.value, self._wh.value)
         else:
-            return None
+            return (-1, -1)

library/python/pydfhack/vegetation.py

@@ -1,18 +1,25 @@
-# -*- coding: utf-8 -*-
+from ctypes import *
-"""
+from pydftypes import libdfhack, Tree
-Python class for DF_Hack::Vegetation
-"""
-from ._pydfhack import _VegetationManager
-from .mixins import NeedsStart
-from .decorators import suspend
 
-class Vegetation(NeedsStart, _VegetationManager):
+class Vegetation(object):
-    api = None
+    def __init__(self, ptr):
-    cls = _VegetationManager
+        self._v_ptr = ptr
-    def __init__(self, api, *args, **kwds):
-        self.cls.__init__(self, args, kwds)
-        self.api = api
 
-    @suspend
+    def start(self):
-    def Read(self, *args, **kw):
+        n = c_uint(0)
-        return self.cls.Read(self, *args, **kw)
+        
+        if libdfhack.Vegetation_Start(self._v_ptr, byref(n)) > 0:
+            return int(n.value)
+        else:
+            return -1
+
+    def finish(self):
+        return libdfhack.Vegetation_Finish(self._v_ptr) > 0
+
+    def read(self, index):
+        t = Tree()
+
+        if libdfhack.Vegetation_Read(self._v_ptr, c_uint(index), byref(t)) > 0:
+            return t
+        else:
+            return None