added sneaking/crouching and changelog

diff --git a/doc/changelog.txt b/doc/changelog.txt
new file mode 100644 (file)
index 0000000..892d4a0
--- /dev/null
+++ b/doc/changelog.txt
@@ -0,0 +1,7 @@
+Minetest-c55 changelog
+----------------------
+
+2011-02-14:
+- Created changelog.txt
+- Added sneaking/crouching
+

diff --git a/src/environment.cpp b/src/environment.cpp
index ecf853b7c6a72703e3cfe236fb897e903e2b9616..07437ec400057dc175d60622eea739812c7c4699 100644 (file)
--- a/src/environment.cpp
+++ b/src/environment.cpp
@@ -67,10 +67,15 @@ void Environment::step(float dtime)
        }
        //playerspeed.stop();
        
+       /*
+               Maximum position increment
+       */
+       //f32 position_max_increment = 0.05*BS;
+       f32 position_max_increment = 0.1*BS;
+
        // Maximum time increment (for collision detection etc)
-       // Allow 0.1 blocks per increment
        // time = distance / speed
-       f32 dtime_max_increment = 0.1*BS / maximum_player_speed;
+       f32 dtime_max_increment = position_max_increment / maximum_player_speed;
        // Maximum time increment is 10ms or lower
        if(dtime_max_increment > 0.01)
                dtime_max_increment = 0.01;
@@ -137,7 +142,7 @@ void Environment::step(float dtime)
                                Move the player.
                                For local player, this also calculates collision detection.
                        */
-                       player->move(dtime_part, *m_map);
+                       player->move(dtime_part, *m_map, position_max_increment);
                        
                        /*
                                Update lighting on remote players on client

diff --git a/src/guiPauseMenu.cpp b/src/guiPauseMenu.cpp
index 99347b052197c8282460f3875b0556ba0bf5657e..b6f913d6be6a2a432b8fb899b81d2c8dde24bedf 100644 (file)
--- a/src/guiPauseMenu.cpp
+++ b/src/guiPauseMenu.cpp
@@ -116,6 +116,7 @@ void GUIPauseMenu::regenerateGui(v2u32 screensize)
                L"- Mouse right: place blocks\n"\r
                L"- Mouse wheel: select item\n"\r
                L"- 0...9: select item\n"\r
+               L"- Shift: sneak\n"\r
                L"- R: Toggle viewing all loaded chunks\n"\r
                L"- I: Inventory menu\n"\r
                L"- ESC: This menu\n"\r

diff --git a/src/main.cpp b/src/main.cpp
index e82dc68fccbf311cfb4522f6ef3577e13ebbf7ab..1399907730275934be46e27c91f64b32bdb4e5db 100644 (file)
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -78,6 +78,7 @@ SUGG: Split MapBlockObject serialization to to-client and to-disk
 \r
 SUGG: MovingObject::move and Player::move are basically the same.\r
       combine them.\r
+         - NOTE: Player::move is more up-to-date.\r
 \r
 SUGG: Precalculate lighting translation table at runtime (at startup)\r
       - This is not doable because it is currently hand-made and not\r
@@ -2261,6 +2262,7 @@ int main(int argc, char *argv[])
                        bool a_right,\r
                        bool a_jump,\r
                        bool a_superspeed,\r
+                       bool a_sneak,\r
                        float a_pitch,\r
                        float a_yaw*/\r
                        PlayerControl control(\r
@@ -2270,6 +2272,8 @@ int main(int argc, char *argv[])
                                g_input->isKeyDown(irr::KEY_KEY_D),\r
                                g_input->isKeyDown(irr::KEY_SPACE),\r
                                g_input->isKeyDown(irr::KEY_KEY_E),\r
+                               g_input->isKeyDown(irr::KEY_LSHIFT)\r
+                                               || g_input->isKeyDown(irr::KEY_RSHIFT),\r
                                camera_pitch,\r
                                camera_yaw\r
                        );\r

diff --git a/src/map.cpp b/src/map.cpp
index bd9d8b0fea2fd16d8975a890cbf06edefd73651c..e213360194bae6602debb5e1547903196812f973 100644 (file)
--- a/src/map.cpp
+++ b/src/map.cpp
@@ -4479,6 +4479,9 @@ MapBlock * ServerMap::emergeBlock(
        {
                dstream<<"emergeBlock: emergeSector() failed: "
                                <<e.what()<<std::endl;
+               dstream<<"Path to failed sector: "<<getSectorDir(p2d)
+                               <<std::endl
+                               <<"You could try to delete it."<<std::endl;
                throw e;
        }
 

diff --git a/src/player.cpp b/src/player.cpp
index 4619e870f5a3d9659291502b8ab3ab3af0064b5e..60ab73b66f801f9aefda7616eae0d55e48067da9 100644 (file)
--- a/src/player.cpp
+++ b/src/player.cpp
@@ -235,7 +235,7 @@ void RemotePlayer::updateName(const char *name)
        }
 }
 
-void RemotePlayer::move(f32 dtime, Map &map)
+void RemotePlayer::move(f32 dtime, Map &map, f32 pos_max_d)
 {
        m_pos_animation_time_counter += dtime;
        m_pos_animation_counter += dtime;
@@ -259,7 +259,8 @@ void RemotePlayer::move(f32 dtime, Map &map)
        LocalPlayer
 */
 
-LocalPlayer::LocalPlayer()
+LocalPlayer::LocalPlayer():
+       m_last_walked_node(32767,32767,32767)
 {
 }
 
@@ -267,7 +268,7 @@ LocalPlayer::~LocalPlayer()
 {
 }
 
-void LocalPlayer::move(f32 dtime, Map &map)
+void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d)
 {
        v3f position = getPosition();
        v3f oldpos = position;
@@ -276,13 +277,14 @@ void LocalPlayer::move(f32 dtime, Map &map)
        /*std::cout<<"oldpos_i=("<<oldpos_i.X<<","<<oldpos_i.Y<<","
                        <<oldpos_i.Z<<")"<<std::endl;*/
 
+       /*
+               Calculate new position
+       */
        position += m_speed * dtime;
 
+       // Skip collision detection if a special movement mode is used
        bool free_move = g_settings.getBool("free_move");
-       
-       // Skip collision detection if player is non-local or
-       // a special movement mode is used
-       if(isLocal() == false || free_move)
+       if(free_move)
        {
                setPosition(position);
                return;
@@ -291,21 +293,24 @@ void LocalPlayer::move(f32 dtime, Map &map)
        /*
                Collision detection
        */
-
+       
+       // Player position in nodes
        v3s16 pos_i = floatToInt(position);
        
        /*
                Check if player is in water (the oscillating value)
        */
        try{
+               // If in water, the threshold of coming out is at higher y
                if(in_water)
                {
-                       v3s16 pp = floatToInt(position + v3f(0,0,0));
+                       v3s16 pp = floatToInt(position + v3f(0,BS*0.1,0));
                        in_water = content_liquid(map.getNode(pp).d);
                }
+               // If not in water, the threshold of going in is at lower y
                else
                {
-                       v3s16 pp = floatToInt(position + v3f(0,BS/2,0));
+                       v3s16 pp = floatToInt(position + v3f(0,BS*0.5,0));
                        in_water = content_liquid(map.getNode(pp).d);
                }
        }
@@ -326,31 +331,76 @@ void LocalPlayer::move(f32 dtime, Map &map)
                in_water_stable = false;
        }
 
-       // The frame length is limited to the player going 0.1*BS per call
-       f32 d = (float)BS * 0.15;
+       /*
+               Collision uncertainty radius
+               Make it a bit larger than the maximum distance of movement
+       */
+       //f32 d = pos_max_d * 1.1;
+       // A fairly large value in here makes moving much smoother
+       f32 d = 0.15*BS;
+
+       // This should always apply, otherwise there are glitches
+       assert(d > pos_max_d);
 
-#define PLAYER_RADIUS (BS*0.3)
-#define PLAYER_HEIGHT (BS*1.7)
+       float player_radius = BS*0.35;
+       float player_height = BS*1.7;
+       
+       // Maximum distance over border for sneaking
+       f32 sneak_max = BS*0.4;
+
+       /*
+               If sneaking, player has larger collision radius to keep from
+               falling
+       */
+       /*if(control.sneak)
+               player_radius = sneak_max + d*1.1;*/
+       
+       /*
+               If sneaking, keep in range from the last walked node and don't
+               fall off from it
+       */
+       if(control.sneak)
+       {
+               f32 maxd = 0.5*BS + sneak_max;
+               v3f lwn_f = intToFloat(m_last_walked_node);
+               position.X = rangelim(position.X, lwn_f.X-maxd, lwn_f.X+maxd);
+               position.Z = rangelim(position.Z, lwn_f.Z-maxd, lwn_f.Z+maxd);
+               
+               f32 min_y = lwn_f.Y + 0.5*BS;
+               if(position.Y < min_y)
+               {
+                       position.Y = min_y;
+                       if(m_speed.Y < 0)
+                               m_speed.Y = 0;
+               }
+       }
 
+       /*
+               Calculate player collision box (new and old)
+       */
        core::aabbox3d<f32> playerbox(
-               position.X - PLAYER_RADIUS,
+               position.X - player_radius,
                position.Y - 0.0,
-               position.Z - PLAYER_RADIUS,
-               position.X + PLAYER_RADIUS,
-               position.Y + PLAYER_HEIGHT,
-               position.Z + PLAYER_RADIUS
+               position.Z - player_radius,
+               position.X + player_radius,
+               position.Y + player_height,
+               position.Z + player_radius
        );
        core::aabbox3d<f32> playerbox_old(
-               oldpos.X - PLAYER_RADIUS,
+               oldpos.X - player_radius,
                oldpos.Y - 0.0,
-               oldpos.Z - PLAYER_RADIUS,
-               oldpos.X + PLAYER_RADIUS,
-               oldpos.Y + PLAYER_HEIGHT,
-               oldpos.Z + PLAYER_RADIUS
+               oldpos.Z - player_radius,
+               oldpos.X + player_radius,
+               oldpos.Y + player_height,
+               oldpos.Z + player_radius
        );
 
-       //hilightboxes.push_back(playerbox);
+       /*
+               If the player's feet touch the topside of any node, this is
+               set to true.
 
+               Player is allowed to jump when this is true.
+       */
        touching_ground = false;
        
        /*std::cout<<"Checking collisions for ("
@@ -358,88 +408,183 @@ void LocalPlayer::move(f32 dtime, Map &map)
                        <<") -> ("
                        <<pos_i.X<<","<<pos_i.Y<<","<<pos_i.Z
                        <<"):"<<std::endl;*/
+       
+       /*
+               Go through every node around the player
+       */
+       for(s16 y = oldpos_i.Y - 1; y <= oldpos_i.Y + 2; y++)
+       for(s16 z = oldpos_i.Z - 1; z <= oldpos_i.Z + 1; z++)
+       for(s16 x = oldpos_i.X - 1; x <= oldpos_i.X + 1; x++)
+       {
+               try{
+                       if(content_walkable(map.getNode(v3s16(x,y,z)).d) == false){
+                               continue;
+                       }
+               }
+               catch(InvalidPositionException &e)
+               {
+                       // Doing nothing here will block the player from
+                       // walking over map borders
+               }
 
-       for(s16 y = oldpos_i.Y - 1; y <= oldpos_i.Y + 2; y++){
-               for(s16 z = oldpos_i.Z - 1; z <= oldpos_i.Z + 1; z++){
-                       for(s16 x = oldpos_i.X - 1; x <= oldpos_i.X + 1; x++){
-                               try{
-                                       if(content_walkable(map.getNode(v3s16(x,y,z)).d) == false){
-                                               continue;
-                                       }
-                               }
-                               catch(InvalidPositionException &e)
+               core::aabbox3d<f32> nodebox = Map::getNodeBox(
+                               v3s16(x,y,z));
+               
+               /*
+                       See if the player is touching ground.
+
+                       Player touches ground if player's minimum Y is near node's
+                       maximum Y and player's X-Z-area overlaps with the node's
+                       X-Z-area.
+
+                       Use 0.15*BS so that it is easier to get on a node.
+               */
+               if(
+                               //fabs(nodebox.MaxEdge.Y-playerbox.MinEdge.Y) < d
+                               fabs(nodebox.MaxEdge.Y-playerbox.MinEdge.Y) < 0.15*BS
+                               && nodebox.MaxEdge.X-d > playerbox.MinEdge.X
+                               && nodebox.MinEdge.X+d < playerbox.MaxEdge.X
+                               && nodebox.MaxEdge.Z-d > playerbox.MinEdge.Z
+                               && nodebox.MinEdge.Z+d < playerbox.MaxEdge.Z
+               ){
+                       touching_ground = true;
+               }
+               
+               // If player doesn't intersect with node, ignore node.
+               if(playerbox.intersectsWithBox(nodebox) == false)
+                       continue;
+               
+               /*
+                       Go through every axis
+               */
+               v3f dirs[3] = {
+                       v3f(0,0,1), // back-front
+                       v3f(0,1,0), // top-bottom
+                       v3f(1,0,0), // right-left
+               };
+               for(u16 i=0; i<3; i++)
+               {
+                       /*
+                               Calculate values along the axis
+                       */
+                       f32 nodemax = nodebox.MaxEdge.dotProduct(dirs[i]);
+                       f32 nodemin = nodebox.MinEdge.dotProduct(dirs[i]);
+                       f32 playermax = playerbox.MaxEdge.dotProduct(dirs[i]);
+                       f32 playermin = playerbox.MinEdge.dotProduct(dirs[i]);
+                       f32 playermax_old = playerbox_old.MaxEdge.dotProduct(dirs[i]);
+                       f32 playermin_old = playerbox_old.MinEdge.dotProduct(dirs[i]);
+                       
+                       /*
+                               Check collision for the axis.
+                               Collision happens when player is going through a surface.
+                       */
+                       /*f32 neg_d = d;
+                       f32 pos_d = d;
+                       // Make it easier to get on top of a node
+                       if(i == 1)
+                               neg_d = 0.15*BS;
+                       bool negative_axis_collides =
+                               (nodemax > playermin && nodemax <= playermin_old + neg_d
+                                       && m_speed.dotProduct(dirs[i]) < 0);
+                       bool positive_axis_collides =
+                               (nodemin < playermax && nodemin >= playermax_old - pos_d
+                                       && m_speed.dotProduct(dirs[i]) > 0);*/
+                       bool negative_axis_collides =
+                               (nodemax > playermin && nodemax <= playermin_old + d
+                                       && m_speed.dotProduct(dirs[i]) < 0);
+                       bool positive_axis_collides =
+                               (nodemin < playermax && nodemin >= playermax_old - d
+                                       && m_speed.dotProduct(dirs[i]) > 0);
+                       bool main_axis_collides =
+                                       negative_axis_collides || positive_axis_collides;
+                       
+                       /*
+                               Check overlap of player and node in other axes
+                       */
+                       bool other_axes_overlap = true;
+                       for(u16 j=0; j<3; j++)
+                       {
+                               if(j == i)
+                                       continue;
+                               f32 nodemax = nodebox.MaxEdge.dotProduct(dirs[j]);
+                               f32 nodemin = nodebox.MinEdge.dotProduct(dirs[j]);
+                               f32 playermax = playerbox.MaxEdge.dotProduct(dirs[j]);
+                               f32 playermin = playerbox.MinEdge.dotProduct(dirs[j]);
+                               if(!(nodemax - d > playermin && nodemin + d < playermax))
                                {
-                                       // Doing nothing here will block the player from
-                                       // walking over map borders
+                                       other_axes_overlap = false;
+                                       break;
                                }
+                       }
+                       
+                       /*
+                               If this is a collision, revert the position in the main
+                               direction.
+                       */
+                       if(other_axes_overlap && main_axis_collides)
+                       {
+                               m_speed -= m_speed.dotProduct(dirs[i]) * dirs[i];
+                               position -= position.dotProduct(dirs[i]) * dirs[i];
+                               position += oldpos.dotProduct(dirs[i]) * dirs[i];
+                       }
+               
+               }
+       } // xyz
 
-                               core::aabbox3d<f32> nodebox = Map::getNodeBox(
-                                               v3s16(x,y,z));
-                               
-                               // See if the player is touching ground
-                               if(
-                                               fabs(nodebox.MaxEdge.Y-playerbox.MinEdge.Y) < d
-                                               && nodebox.MaxEdge.X-d > playerbox.MinEdge.X
-                                               && nodebox.MinEdge.X+d < playerbox.MaxEdge.X
-                                               && nodebox.MaxEdge.Z-d > playerbox.MinEdge.Z
-                                               && nodebox.MinEdge.Z+d < playerbox.MaxEdge.Z
-                               ){
-                                       touching_ground = true;
-                               }
-                               
-                               if(playerbox.intersectsWithBox(nodebox))
-                               {
-                               
-       v3f dirs[3] = {
-               v3f(0,0,1), // back
-               v3f(0,1,0), // top
-               v3f(1,0,0), // right
-       };
-       for(u16 i=0; i<3; i++)
+       /*
+               If there is a walkable node directly under the player, save
+               the position of it.
+       */
+       try{
+               v3s16 pos_i_bottom = floatToInt(position - v3f(0,BS/2,0));
+               if(content_walkable(map.getNode(pos_i_bottom).d))
+               {
+                       m_last_walked_node = pos_i_bottom;
+               }
+       }
+       catch(InvalidPositionException &e)
        {
-               f32 nodemax = nodebox.MaxEdge.dotProduct(dirs[i]);
-               f32 nodemin = nodebox.MinEdge.dotProduct(dirs[i]);
-               f32 playermax = playerbox.MaxEdge.dotProduct(dirs[i]);
-               f32 playermin = playerbox.MinEdge.dotProduct(dirs[i]);
-               f32 playermax_old = playerbox_old.MaxEdge.dotProduct(dirs[i]);
-               f32 playermin_old = playerbox_old.MinEdge.dotProduct(dirs[i]);
-
-               bool main_edge_collides = 
-                       ((nodemax > playermin && nodemax <= playermin_old + d
-                               && m_speed.dotProduct(dirs[i]) < 0)
-                       ||
-                       (nodemin < playermax && nodemin >= playermax_old - d
-                               && m_speed.dotProduct(dirs[i]) > 0));
-
-               bool other_edges_collide = true;
-               for(u16 j=0; j<3; j++)
+       }
+       
+       /*
+               Check the neighbors of m_last_walked_node that are closer to
+               the player. If walkable, set m_last_walked_node to such.
+       */
+       {
+               v3s16 pos_i_bottom = floatToInt(position - v3f(0,BS/2,0));
+               v3f lastwalkednode_pf = intToFloat(m_last_walked_node);
+               v2f lastwalkednode_p2df(lastwalkednode_pf.X, lastwalkednode_pf.Z);
+               v2f player_p2df(position.X, position.Z);
+               f32 min_distance_f = player_p2df.getDistanceFrom(lastwalkednode_p2df);
+               v3s16 new_last_walked_node = m_last_walked_node;
+               for(s16 x=-1; x<=1; x++)
+               for(s16 z=-1; z<=1; z++)
                {
-                       if(j == i)
+                       v3s16 p = m_last_walked_node + v3s16(x,0,z);
+                       v3f pf = intToFloat(p);
+                       v2f node_p2df(pf.X, pf.Z);
+                       f32 distance_f = player_p2df.getDistanceFrom(node_p2df);
+                       if(distance_f > min_distance_f)
                                continue;
-                       f32 nodemax = nodebox.MaxEdge.dotProduct(dirs[j]);
-                       f32 nodemin = nodebox.MinEdge.dotProduct(dirs[j]);
-                       f32 playermax = playerbox.MaxEdge.dotProduct(dirs[j]);
-                       f32 playermin = playerbox.MinEdge.dotProduct(dirs[j]);
-                       if(!(nodemax - d > playermin && nodemin + d < playermax))
+                       try{
+                               if(content_walkable(map.getNode(p).d) == false)
+                                       continue;
+                       }
+                       catch(InvalidPositionException &e)
                        {
-                               other_edges_collide = false;
-                               break;
+                               continue;
                        }
+
+                       min_distance_f = distance_f;
+                       new_last_walked_node = p;
                }
                
-               if(main_edge_collides && other_edges_collide)
-               {
-                       m_speed -= m_speed.dotProduct(dirs[i]) * dirs[i];
-                       position -= position.dotProduct(dirs[i]) * dirs[i];
-                       position += oldpos.dotProduct(dirs[i]) * dirs[i];
-               }
-       
+               m_last_walked_node = new_last_walked_node;
        }
-                               } // if(playerbox.intersectsWithBox(nodebox))
-                       } // for x
-               } // for z
-       } // for y
-
+       
+       /*
+               Set new position
+       */
        setPosition(position);
 }
 
@@ -449,10 +594,8 @@ void LocalPlayer::applyControl(float dtime)
        swimming_up = false;
 
        // Random constants
-#define WALK_ACCELERATION (4.0 * BS)
-#define WALKSPEED_MAX (4.0 * BS)
-       f32 walk_acceleration = WALK_ACCELERATION;
-       f32 walkspeed_max = WALKSPEED_MAX;
+       f32 walk_acceleration = 4.0 * BS;
+       f32 walkspeed_max = 4.0 * BS;
        
        setPitch(control.pitch);
        setYaw(control.yaw);
@@ -538,6 +681,11 @@ void LocalPlayer::applyControl(float dtime)
                else if(touching_ground)
                {
                        v3f speed = getSpeed();
+                       /*
+                               NOTE: The d value in move() affects jump height by
+                               raising the height at which the jump speed is kept
+                               at its starting value
+                       */
                        speed.Y = 6.5*BS;
                        setSpeed(speed);
                }
@@ -554,7 +702,9 @@ void LocalPlayer::applyControl(float dtime)
 
        // The speed of the player (Y is ignored)
        if(superspeed)
-               speed = speed.normalize() * walkspeed_max * 5;
+               speed = speed.normalize() * walkspeed_max * 5.0;
+       else if(control.sneak)
+               speed = speed.normalize() * walkspeed_max / 3.0;
        else
                speed = speed.normalize() * walkspeed_max;
        

diff --git a/src/player.h b/src/player.h
index 51e2320bc1d9caf7a320c3f236dec5562cdce303..27ce1f5aafdc909116a61b9523e65e44e03f3012 100644 (file)
--- a/src/player.h
+++ b/src/player.h
@@ -42,7 +42,7 @@ public:
        void resetInventory();
 
        //void move(f32 dtime, Map &map);
-       virtual void move(f32 dtime, Map &map) = 0;
+       virtual void move(f32 dtime, Map &map, f32 pos_max_d) = 0;
 
        v3f getSpeed()
        {
@@ -147,7 +147,7 @@ public:
                return false;
        }
 
-       virtual void move(f32 dtime, Map &map)
+       virtual void move(f32 dtime, Map &map, f32 pos_max_d)
        {
        }
 
@@ -240,7 +240,7 @@ public:
                }
        }
        
-       void move(f32 dtime, Map &map);
+       void move(f32 dtime, Map &map, f32 pos_max_d);
 
 private:
        scene::IMeshSceneNode *m_node;
@@ -267,6 +267,7 @@ struct PlayerControl
                right = false;
                jump = false;
                aux1 = false;
+               sneak = false;
                pitch = 0;
                yaw = 0;
        }
@@ -277,6 +278,7 @@ struct PlayerControl
                bool a_right,
                bool a_jump,
                bool a_aux1,
+               bool a_sneak,
                float a_pitch,
                float a_yaw
        )
@@ -287,6 +289,7 @@ struct PlayerControl
                right = a_right;
                jump = a_jump;
                aux1 = a_aux1;
+               sneak = a_sneak;
                pitch = a_pitch;
                yaw = a_yaw;
        }
@@ -296,6 +299,7 @@ struct PlayerControl
        bool right;
        bool jump;
        bool aux1;
+       bool sneak;
        float pitch;
        float yaw;
 };
@@ -311,13 +315,15 @@ public:
                return true;
        }
 
-       void move(f32 dtime, Map &map);
+       void move(f32 dtime, Map &map, f32 pos_max_d);
 
        void applyControl(float dtime);
        
        PlayerControl control;
 
 private:
+       // This is used for determining the sneaking range
+       v3s16 m_last_walked_node;
 };
 #endif // !SERVER
 

diff --git a/src/voxel.h b/src/voxel.h
index c5aa48006e643693f158af47d12b1653fd0f18db..eced43ed544f50134badeaae38e8ed22e9834186 100644 (file)
--- a/src/voxel.h
+++ b/src/voxel.h
@@ -30,7 +30,11 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #undef max
 
 /*
-       A fast voxel manipulator class
+       A fast voxel manipulator class.
+
+       In normal operation, it fetches more map when it is requested.
+       It can also be used so that all allowed area is fetched at the
+       start, using ManualMapVoxelManipulator.
 
        Not thread-safe.
 */
@@ -401,6 +405,31 @@ public:
                
                return m_data[m_area.index(p)];
        }*/
+       
+       /*
+               Set stuff if available without an emerge.
+               Return false if failed.
+               This is convenient but slower than playing around directly
+               with the m_data table with indices.
+       */
+       bool setNodeNoEmerge(v3s16 p, MapNode n)
+       {
+               if(m_area.contains(p) == false)
+                       return false;
+               m_data[m_area.index(p)] = n;
+       }
+       bool setNodeNoEmerge(s32 i, MapNode n)
+       {
+               if(m_area.contains(i) == false)
+                       return false;
+               m_data[i] = n;
+       }
+       /*bool setContentNoEmerge(v3s16 p, u8 c)
+       {
+               if(isValidPosition(p) == false)
+                       return false;
+               m_data[m_area.index(p)].d = c;
+       }*/
 
        /*
                Control