Merge branch 'master' of git://github.com/peterix/dfhack

library/modules/Creatures.cpp

@@ -359,7 +359,10 @@ int32_t Creatures::ReadCreatureInBox (int32_t index, t_creature & furball,
 
 bool Creatures::WriteLabors(const uint32_t index, uint8_t labors[NUM_CREATURE_LABORS])
 {
-	if(!d->Started) return false;
+    if(!d->Started)
+    {
+        return false;
+    }
     uint32_t temp = d->p_cre->at (index);
     Process * p = d->owner;
 
@@ -374,8 +377,9 @@ bool Creatures::WriteLabors(const uint32_t index, uint8_t labors[NUM_CREATURE_LA
 bool Creatures::WriteHappiness(const uint32_t index, const uint32_t happinessValue)
 {
     if(!d->Started)
+    {
         return false;
-
+    }
     uint32_t temp = d->p_cre->at (index);
     Process * p = d->owner;
     p->writeDWord (temp + d->creatures.happiness_offset, happinessValue);
@@ -387,8 +391,9 @@ bool Creatures::WriteFlags(const uint32_t index,
                            const uint32_t flags2)
 {
     if(!d->Started)
+    {
         return false;
-
+    }
     uint32_t temp = d->p_cre->at (index);
     Process * p = d->owner;
     p->writeDWord (temp + d->creatures.flags1_offset, flags1);
@@ -399,14 +404,18 @@ bool Creatures::WriteFlags(const uint32_t index,
 bool Creatures::WriteSkills(const uint32_t index, const t_soul &soul)
 {
     if(!d->Started)
+    {
         return false;
+    }
 
     uint32_t temp = d->p_cre->at (index);
     Process * p = d->owner;
     uint32_t souloff = p->readDWord(temp + d->creatures.default_soul_offset);
 
     if(!souloff)
+    {
         return false;
+    }
 
     DfVector<uint32_t> skills(p, souloff + d->creatures.soul_skills_vector_offset);
 
@@ -423,14 +432,18 @@ bool Creatures::WriteSkills(const uint32_t index, const t_soul &soul)
 bool Creatures::WriteAttributes(const uint32_t index, const t_creature &creature)
 {
     if(!d->Started)
+    {
         return false;
+    }
 
     uint32_t temp = d->p_cre->at (index);
     Process * p = d->owner;
     uint32_t souloff = p->readDWord(temp + d->creatures.default_soul_offset);
 
     if(!souloff)
+    {
         return false;
+    }
 
     // physical attributes
     p->write(temp + d->creatures.physical_offset,
@@ -448,7 +461,9 @@ bool Creatures::WriteAttributes(const uint32_t index, const t_creature &creature
 bool Creatures::WriteSex(const uint32_t index, const uint8_t sex)
 {
     if(!d->Started)
+    {
         return false;
+    }
 
     uint32_t temp = d->p_cre->at (index);
     Process * p = d->owner;
@@ -458,14 +473,18 @@ bool Creatures::WriteSex(const uint32_t index, const uint8_t sex)
 bool Creatures::WriteTraits(const uint32_t index, const t_soul &soul)
 {
     if(!d->Started)
+    {
         return false;
+    }
 
     uint32_t temp = d->p_cre->at (index);
     Process * p = d->owner;
     uint32_t souloff = p->readDWord(temp + d->creatures.default_soul_offset);
 
     if(!souloff)
+    {
         return false;
+    }
 
     p->write(souloff + d->creatures.soul_traits_offset,
             sizeof (uint16_t) * NUM_CREATURE_TRAITS,
@@ -477,7 +496,9 @@ bool Creatures::WriteTraits(const uint32_t index, const t_soul &soul)
 bool Creatures::WriteMood(const uint32_t index, const uint16_t mood)
 {
     if(!d->Started)
+    {
         return false;
+    }
 
     uint32_t temp = d->p_cre->at (index);
     Process * p = d->owner;

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 -*-
-"""
-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
+from ctypes import *
+from pydfhack import libdfhack, ViewScreen
 
-    def prepare(self):
-        """
-        Enforce Suspend/Start
-        """
-        if self.api.prepare():
-            if not self.started:
-                self.started = self.Start()
-            return self.started
-        else:
-            return False
+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/pydfhack/materials.py

@@ -1,42 +1,141 @@
-# -*- 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)
+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/pydfhack/position.py

@@ -1,42 +1,43 @@
-# -*- 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
+from ctypes import *
+from pydftypes import libdfhack
+
+class Position(object):
+    def __init__(self, ptr):
+        self._pos_ptr = ptr
 
-    @suspend
-    def get_window_size(self):
-        wsize = self.window_size
-        return wsize
+        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()
 
-    @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
+        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 None
+            return (-1, -1)

library/python/pydfhack/vegetation.py

@@ -1,18 +1,25 @@
-# -*- coding: utf-8 -*-
-"""
-Python class for DF_Hack::Vegetation
-"""
-from ._pydfhack import _VegetationManager
-from .mixins import NeedsStart
-from .decorators import suspend
+from ctypes import *
+from pydftypes import libdfhack, Tree
 
-class Vegetation(NeedsStart, _VegetationManager):
-    api = None
-    cls = _VegetationManager
-    def __init__(self, api, *args, **kwds):
-        self.cls.__init__(self, args, kwds)
-        self.api = api
+class Vegetation(object):
+    def __init__(self, ptr):
+        self._v_ptr = ptr
 
-    @suspend
-    def Read(self, *args, **kw):
-        return self.cls.Read(self, *args, **kw)
+    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

tools/playground/incrementalsearch.cpp

@@ -47,13 +47,13 @@ class address
         addr_ = addr;
         valid = false;
     }
-        address & operator=(const uint64_t in)
+    virtual address & operator=(const uint64_t in)
     {
         addr_ = in;
         valid = false;
         return *this;
     }
-        bool isValid(SegmentedFinder& sff)
+    virtual bool isValid(SegmentedFinder& sff)
     {
         if(valid) return true;
         if(sff.getSegmentForAddress(addr_))
@@ -61,15 +61,43 @@ class address
             valid = 1;
         }
     }
+    virtual bool equals (SegmentedFinder & sf, address & rhs)
+    {
+        return rhs.addr_ == addr_;
+    }
 };
 
+// pointer to a null-terminated byte string
 class Cstr: public address
 {
     void print(SegmentedFinder & sf)
     {
         cout << hex << "0x" << addr_ << ": \"" << sf.Translate<char>(addr_) << "\"" << endl;
     }
+    bool equals(SegmentedFinder & sf,const char * rhs)
+    {
+        uint32_t addr2 = *(sf.Translate<uint32_t>(addr_));
+        return strcmp(sf.Translate<const char>(addr2), rhs) == 0;
+    }
+    template <class Predicate, class inType>
+    bool equalsP(SegmentedFinder & sf,inType rhs)
+    {
+        return Predicate(addr_, sf, rhs);
+    }
+    bool isValid(SegmentedFinder& sf)
+    {
+        if (address::isValid(sf))
+        {
+            // read the pointer
+            uint32_t addr2 = *(sf.Translate<uint32_t>(addr_));
+            // is it a real pointer? a pretty weak test, but whatever.
+            if(sf.getSegmentForAddress(addr2))
+                return true;
+        }
+        return false;
+    }
 };
+
 // STL STRING
 #ifdef LINUX_BUILD
 class STLstr: public address