Merge branch 'canStepBetween' into recent

Conflicts:
	library/modules/Maps.cpp

library/LuaApi.cpp

@@ -1314,7 +1314,7 @@ static const LuaWrapper::FunctionReg dfhack_maps_module[] = {
     WRAPM(Maps, enableBlockUpdates),
     WRAPM(Maps, getGlobalInitFeature),
     WRAPM(Maps, getLocalInitFeature),
-    WRAPM(Maps, canWalkBetween),
+    WRAPM(Maps, canPathBetween),
     WRAPM(Maps, spawnFlow),
     WRAPN(hasTileAssignment, hasTileAssignment),
     WRAPN(getTileAssignment, getTileAssignment),

library/include/modules/Maps.h

@@ -307,7 +307,8 @@ extern DFHACK_EXPORT bool SortBlockEvents(df::map_block *block,
 /// remove a block event from the block by address
 extern DFHACK_EXPORT bool RemoveBlockEvent(uint32_t x, uint32_t y, uint32_t z, df::block_square_event * which );
 
-DFHACK_EXPORT bool canWalkBetween(df::coord pos1, df::coord pos2);
+DFHACK_EXPORT bool canPathBetween(df::coord pos1, df::coord pos2);
+DFHACK_EXPORT bool canStepBetween(df::coord pos1, df::coord pos2);
 }
 }
 #endif

library/modules/Maps.cpp

@@ -30,10 +30,12 @@ distribution.
 #include <map>
 #include <set>
 #include <cstdlib>
+#include <iostream>
 using namespace std;
 
 #include "modules/Maps.h"
 #include "modules/MapCache.h"
+#include "ColorText.h"
 #include "Error.h"
 #include "VersionInfo.h"
 #include "MemAccess.h"
@@ -60,6 +62,7 @@ using namespace std;
 #include "df/region_map_entry.h"
 #include "df/flow_info.h"
 #include "df/plant.h"
+#include "df/building_type.h"
 
 using namespace DFHack;
 using namespace df::enums;
@@ -522,7 +525,7 @@ bool Maps::ReadGeology(vector<vector<int16_t> > *layer_mats, vector<df::coord2d>
     return true;
 }
 
-bool Maps::canWalkBetween(df::coord pos1, df::coord pos2)
+bool Maps::canPathBetween(df::coord pos1, df::coord pos2)
 {
     auto block1 = getTileBlock(pos1);
     auto block2 = getTileBlock(pos2);
@@ -536,6 +539,129 @@ bool Maps::canWalkBetween(df::coord pos1, df::coord pos2)
     return tile1 && tile1 == tile2;
 }
 
+bool Maps::canStepBetween(df::coord pos1, df::coord pos2)
+{
+    color_ostream& out = Core::getInstance().getConsole();
+    int32_t dx = pos2.x-pos1.x;
+    int32_t dy = pos2.y-pos1.y;
+    int32_t dz = pos2.z-pos1.z;
+
+    if ( dx*dx > 1 || dy*dy > 1 || dz*dz > 1 )
+        return false;
+
+    if ( pos2.z < pos1.z ) {
+        df::coord temp = pos1;
+        pos1 = pos2;
+        pos2 = temp;
+    }
+
+    df::map_block* block1 = getTileBlock(pos1);
+    df::map_block* block2 = getTileBlock(pos2);
+
+    if ( !block1 || !block2 )
+        return false;
+
+    if ( !index_tile<uint16_t>(block1->walkable,pos1) || !index_tile<uint16_t>(block2->walkable,pos2) ) {
+        return false;
+    }
+
+    if ( dz == 0 )
+        return true;
+
+    df::tiletype* type1 = Maps::getTileType(pos1);
+    df::tiletype* type2 = Maps::getTileType(pos2);
+
+    df::tiletype_shape shape1 = ENUM_ATTR(tiletype,shape,*type1);
+    df::tiletype_shape shape2 = ENUM_ATTR(tiletype,shape,*type2);
+
+    if ( dx == 0 && dy == 0 ) {
+        //check for forbidden hatches and floors and such
+        df::enums::tile_building_occ::tile_building_occ upOcc = index_tile<df::tile_occupancy>(block2->occupancy,pos2).bits.building;
+        if ( upOcc == df::enums::tile_building_occ::Impassable || upOcc == df::enums::tile_building_occ::Obstacle || upOcc == df::enums::tile_building_occ::Floored )
+            return false;
+
+        if ( shape1 == tiletype_shape::STAIR_UPDOWN && shape2 == shape1 )
+            return true;
+        if ( shape1 == tiletype_shape::STAIR_UPDOWN && shape2 == tiletype_shape::STAIR_DOWN )
+            return true;
+        if ( shape1 == tiletype_shape::STAIR_UP && shape2 == tiletype_shape::STAIR_UPDOWN )
+            return true;
+        if ( shape1 == tiletype_shape::STAIR_UP && shape2 == tiletype_shape::STAIR_DOWN )
+            return true;
+        if ( shape1 == tiletype_shape::RAMP && shape2 == tiletype_shape::RAMP_TOP ) {
+            //it depends
+            //there has to be a wall next to the ramp
+            bool foundWall = false;
+            for ( int32_t x = -1; x <= 1; x++ ) {
+                for ( int32_t y = -1; y <= 1; y++ ) {
+                    if ( x == 0 && y == 0 )
+                        continue;
+                    df::tiletype* type = Maps::getTileType(df::coord(pos1.x+x,pos1.y+y,pos1.z));
+                    df::tiletype_shape shape1 = ENUM_ATTR(tiletype,shape,*type);
+                    if ( shape1 == tiletype_shape::WALL ) {
+                        foundWall = true;
+                        x = 2;
+                        break;
+                    }
+                }
+            }
+            if ( !foundWall )
+                return false; //unusable ramp
+            
+            //there has to be an unforbidden hatch above the ramp
+            if ( index_tile<df::tile_occupancy>(block2->occupancy,pos2).bits.building != df::enums::tile_building_occ::Dynamic )
+                return false;
+            //note that forbidden hatches have Floored occupancy. unforbidden ones have dynamic occupancy
+            df::building* building = Buildings::findAtTile(pos2);
+            if ( building == NULL ) {
+                out << __FILE__ << ", line " << __LINE__ << ": couldn't find hatch.\n";
+                return false;
+            }
+            if ( building->getType() != df::enums::building_type::Hatch ) {
+                return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    
+    //diagonal up: has to be a ramp
+    if ( shape1 == tiletype_shape::RAMP /*&& shape2 == tiletype_shape::RAMP*/ ) {
+        df::coord up = df::coord(pos1.x,pos1.y,pos1.z+1);
+        bool foundWall = false;
+        for ( int32_t x = -1; x <= 1; x++ ) {
+            for ( int32_t y = -1; y <= 1; y++ ) {
+                if ( x == 0 && y == 0 )
+                    continue;
+                df::tiletype* type = Maps::getTileType(df::coord(pos1.x+x,pos1.y+y,pos1.z));
+                df::tiletype_shape shape1 = ENUM_ATTR(tiletype,shape,*type);
+                if ( shape1 == tiletype_shape::WALL ) {
+                    foundWall = true;
+                    x = 2;
+                    break;
+                }
+            }
+        }
+        if ( !foundWall )
+            return false; //unusable ramp
+        df::tiletype* typeUp = Maps::getTileType(up);
+        df::tiletype_shape shapeUp = ENUM_ATTR(tiletype,shape,*typeUp);
+        if ( shapeUp != tiletype_shape::RAMP_TOP )
+            return false;
+        
+        df::map_block* blockUp = getTileBlock(up);
+        if ( !blockUp )
+            return false;
+        
+        df::enums::tile_building_occ::tile_building_occ occupancy = index_tile<df::tile_occupancy>(blockUp->occupancy,up).bits.building;
+        if ( occupancy == df::enums::tile_building_occ::Obstacle || occupancy == df::enums::tile_building_occ::Floored || occupancy == df::enums::tile_building_occ::Impassable )
+            return false;
+        return true;
+    }
+
+    return false;
+}
+
 #define COPY(a,b) memcpy(&a,&b,sizeof(a))
 
 MapExtras::Block::Block(MapCache *parent, DFCoord _bcoord) : parent(parent)

plugins/devel/CMakeLists.txt

@@ -22,3 +22,4 @@ DFHACK_PLUGIN(eventExample eventExample.cpp)
 IF(UNIX)
 DFHACK_PLUGIN(ref-index ref-index.cpp)
 ENDIF()
+DFHACK_PLUGIN(stepBetween stepBetween.cpp)

plugins/devel/stepBetween.cpp

@@ -0,0 +1,87 @@
+
+#include "Core.h"
+#include <Console.h>
+#include <Export.h>
+#include <PluginManager.h>
+
+// DF data structure definition headers
+#include "DataDefs.h"
+#include "df/world.h"
+
+#include "modules/Gui.h"
+#include "modules/Maps.h"
+
+using namespace DFHack;
+using namespace df::enums;
+
+
+
+command_result stepBetween (color_ostream &out, std::vector <std::string> & parameters);
+
+// A plugin must be able to return its name and version.
+// The name string provided must correspond to the filename - skeleton.plug.so or skeleton.plug.dll in this case
+DFHACK_PLUGIN("stepBetween");
+
+// Mandatory init function. If you have some global state, create it here.
+DFhackCExport command_result plugin_init ( color_ostream &out, std::vector <PluginCommand> &commands)
+{
+    // Fill the command list with your commands.
+    commands.push_back(PluginCommand(
+        "stepBetween", "Do nothing, look pretty.",
+        stepBetween, false, /* true means that the command can't be used from non-interactive user interface */
+        // Extended help string. Used by CR_WRONG_USAGE and the help command:
+        "  This command does nothing at all.\n"
+    ));
+    return CR_OK;
+}
+
+// This is called right before the plugin library is removed from memory.
+DFhackCExport command_result plugin_shutdown ( color_ostream &out )
+{
+    // You *MUST* kill all threads you created before this returns.
+    // If everything fails, just return CR_FAILURE. Your plugin will be
+    // in a zombie state, but things won't crash.
+    return CR_OK;
+}
+
+// Called to notify the plugin about important state changes.
+// Invoked with DF suspended, and always before the matching plugin_onupdate.
+// More event codes may be added in the future.
+/*
+DFhackCExport command_result plugin_onstatechange(color_ostream &out, state_change_event event)
+{
+    switch (event) {
+    case SC_GAME_LOADED:
+        // initialize from the world just loaded
+        break;
+    case SC_GAME_UNLOADED:
+        // cleanup
+        break;
+    default:
+        break;
+    }
+    return CR_OK;
+}
+*/
+
+// Whatever you put here will be done in each game step. Don't abuse it.
+// It's optional, so you can just comment it out like this if you don't need it.
+/*
+DFhackCExport command_result plugin_onupdate ( color_ostream &out )
+{
+    // whetever. You don't need to suspend DF execution here.
+    return CR_OK;
+}
+*/
+
+df::coord prev;
+
+// A command! It sits around and looks pretty. And it's nice and friendly.
+command_result stepBetween (color_ostream &out, std::vector <std::string> & parameters)
+{
+    df::coord bob = Gui::getCursorPos();
+    out.print("(%d,%d,%d), (%d,%d,%d): canWalkBetween = %d, canPathBetween = %d\n", prev.x, prev.y, prev.z, bob.x, bob.y, bob.z, Maps::canStepBetween(prev, bob), Maps::canPathBetween(prev,bob));
+
+    prev = bob;
+    return CR_OK;
+}

plugins/fix-armory.cpp

@@ -477,7 +477,7 @@ static bool try_store_item(df::building *target, df::item *item)
     df::coord tpos(target->centerx, target->centery, target->z);
     df::coord ipos = Items::getPosition(item);
 
-    if (!Maps::canWalkBetween(tpos, ipos))
+    if (!Maps::canPathBetween(tpos, ipos))
         return false;
 
     // Check if the target has enough space left