From 14fafc72177fdc77bf8c8955363c77719f74e33b Mon Sep 17 00:00:00 2001 From: Perttu Ahola Date: Mon, 14 Feb 2011 02:54:15 +0200 Subject: [PATCH] added sneaking/crouching and changelog --- doc/changelog.txt | 7 + src/environment.cpp | 11 +- src/guiPauseMenu.cpp | 1 + src/main.cpp | 4 + src/map.cpp | 3 + src/player.cpp | 360 ++++++++++++++++++++++++++++++------------- src/player.h | 14 +- src/voxel.h | 31 +++- 8 files changed, 318 insertions(+), 113 deletions(-) create mode 100644 doc/changelog.txt diff --git a/doc/changelog.txt b/doc/changelog.txt new file mode 100644 index 000000000..892d4a037 --- /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 ecf853b7c..07437ec40 100644 --- 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 99347b052..b6f913d6b 100644 --- a/src/guiPauseMenu.cpp +++ b/src/guiPauseMenu.cpp @@ -116,6 +116,7 @@ void GUIPauseMenu::regenerateGui(v2u32 screensize) L"- Mouse right: place blocks\n" L"- Mouse wheel: select item\n" L"- 0...9: select item\n" + L"- Shift: sneak\n" L"- R: Toggle viewing all loaded chunks\n" L"- I: Inventory menu\n" L"- ESC: This menu\n" diff --git a/src/main.cpp b/src/main.cpp index e82dc68fc..139990773 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -78,6 +78,7 @@ SUGG: Split MapBlockObject serialization to to-client and to-disk SUGG: MovingObject::move and Player::move are basically the same. combine them. + - NOTE: Player::move is more up-to-date. SUGG: Precalculate lighting translation table at runtime (at startup) - This is not doable because it is currently hand-made and not @@ -2261,6 +2262,7 @@ int main(int argc, char *argv[]) bool a_right, bool a_jump, bool a_superspeed, + bool a_sneak, float a_pitch, float a_yaw*/ PlayerControl control( @@ -2270,6 +2272,8 @@ int main(int argc, char *argv[]) g_input->isKeyDown(irr::KEY_KEY_D), g_input->isKeyDown(irr::KEY_SPACE), g_input->isKeyDown(irr::KEY_KEY_E), + g_input->isKeyDown(irr::KEY_LSHIFT) + || g_input->isKeyDown(irr::KEY_RSHIFT), camera_pitch, camera_yaw ); diff --git a/src/map.cpp b/src/map.cpp index bd9d8b0fe..e21336019 100644 --- a/src/map.cpp +++ b/src/map.cpp @@ -4479,6 +4479,9 @@ MapBlock * ServerMap::emergeBlock( { dstream<<"emergeBlock: emergeSector() failed: " < pos_max_d); + 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 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 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) <<") -> (" < 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++) + + /* + 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++) { - 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++) - { - if(j == i) + try{ + if(content_walkable(map.getNode(v3s16(x,y,z)).d) == false){ 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)) - { - other_edges_collide = false; - break; } } - - if(main_edge_collides && other_edges_collide) + catch(InvalidPositionException &e) { - m_speed -= m_speed.dotProduct(dirs[i]) * dirs[i]; - position -= position.dotProduct(dirs[i]) * dirs[i]; - position += oldpos.dotProduct(dirs[i]) * dirs[i]; + // Doing nothing here will block the player from + // walking over map borders } - - } - } // if(playerbox.intersectsWithBox(nodebox)) - } // for x - } // for z - } // for y + core::aabbox3d 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)) + { + 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 + + /* + 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) + { + } + + /* + 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++) + { + 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; + try{ + if(content_walkable(map.getNode(p).d) == false) + continue; + } + catch(InvalidPositionException &e) + { + continue; + } + + min_distance_f = distance_f; + new_last_walked_node = p; + } + + m_last_walked_node = new_last_walked_node; + } + + /* + 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 51e2320bc..27ce1f5aa 100644 --- 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 c5aa48006..eced43ed5 100644 --- 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