X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fplayer.cpp;h=40b7a249793298aefec58d9b09c429f837b2077d;hb=569fca53089b7b7e87b02edd44e2ad47166f7af6;hp=d5d122bd643227937c77303bf4c9d30e4660b70c;hpb=813b6a91b36548532ba4236033369435c5c36017;p=minetest.git diff --git a/src/player.cpp b/src/player.cpp index d5d122bd6..40b7a2497 100644 --- a/src/player.cpp +++ b/src/player.cpp @@ -1,6 +1,6 @@ /* Minetest-c55 -Copyright (C) 2010 celeron55, Perttu Ahola +Copyright (C) 2010-2011 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -17,35 +17,73 @@ with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -/* -(c) 2010 Perttu Ahola -*/ - #include "player.h" #include "map.h" #include "connection.h" #include "constants.h" - -Player::Player(): +#include "utility.h" +#ifndef SERVER +#include +#endif +#include "main.h" // For g_settings +#include "settings.h" +#include "nodedef.h" +#include "collision.h" +#include "environment.h" +#include "gamedef.h" + +Player::Player(IGameDef *gamedef): touching_ground(false), in_water(false), - peer_id(PEER_ID_NEW), + in_water_stable(false), + is_climbing(false), + swimming_up(false), + inventory(gamedef->idef()), + inventory_backup(NULL), + hp(20), + peer_id(PEER_ID_INEXISTENT), +// protected + m_gamedef(gamedef), + m_pitch(0), + m_yaw(0), m_speed(0,0,0), m_position(0,0,0) { updateName(""); - inventory.addList("main", PLAYER_INVENTORY_SIZE); - inventory.addList("craft", 9); - inventory.addList("craftresult", 1); + resetInventory(); } Player::~Player() { + delete inventory_backup; +} + +void Player::resetInventory() +{ + inventory.clear(); + inventory.addList("main", PLAYER_INVENTORY_SIZE); + inventory.addList("craft", 9); + inventory.addList("craftpreview", 1); + inventory.addList("craftresult", 1); } // Y direction is ignored void Player::accelerate(v3f target_speed, f32 max_increase) { + v3f d_wanted = target_speed - m_speed; + d_wanted.Y = 0; + f32 dl_wanted = d_wanted.getLength(); + f32 dl = dl_wanted; + if(dl > max_increase) + dl = max_increase; + + v3f d = d_wanted.normalize() * dl; + + m_speed.X += d.X; + m_speed.Z += d.Z; + //m_speed += d; + +#if 0 // old code if(m_speed.X < target_speed.X - max_increase) m_speed.X += max_increase; else if(m_speed.X > target_speed.X + max_increase) @@ -63,153 +101,126 @@ void Player::accelerate(v3f target_speed, f32 max_increase) m_speed.Z = target_speed.Z; else if(m_speed.Z > target_speed.Z) m_speed.Z = target_speed.Z; +#endif } -/* - RemotePlayer -*/ - -#ifndef SERVER - -RemotePlayer::RemotePlayer( - scene::ISceneNode* parent, - IrrlichtDevice *device, - s32 id): - scene::ISceneNode(parent, (device==NULL)?NULL:device->getSceneManager(), id), - m_text(NULL) +v3s16 Player::getLightPosition() const { - m_box = core::aabbox3d(-BS/2,0,-BS/2,BS/2,BS*2,BS/2); - - if(parent != NULL && device != NULL) - { - // ISceneNode stores a member called SceneManager - scene::ISceneManager* mgr = SceneManager; - video::IVideoDriver* driver = mgr->getVideoDriver(); - gui::IGUIEnvironment* gui = device->getGUIEnvironment(); - - // Add a text node for showing the name - wchar_t wname[1] = {0}; - m_text = mgr->addTextSceneNode(gui->getBuiltInFont(), - wname, video::SColor(255,255,255,255), this); - m_text->setPosition(v3f(0, (f32)BS*2.1, 0)); - - // Attach a simple mesh to the player for showing an image - scene::SMesh *mesh = new scene::SMesh(); - { // Front - scene::IMeshBuffer *buf = new scene::SMeshBuffer(); - video::SColor c(255,255,255,255); - video::S3DVertex vertices[4] = - { - video::S3DVertex(-BS/2,0,0, 0,0,0, c, 0,1), - video::S3DVertex(BS/2,0,0, 0,0,0, c, 1,1), - video::S3DVertex(BS/2,BS*2,0, 0,0,0, c, 1,0), - video::S3DVertex(-BS/2,BS*2,0, 0,0,0, c, 0,0), - }; - u16 indices[] = {0,1,2,2,3,0}; - buf->append(vertices, 4, indices, 6); - // Set material - buf->getMaterial().setFlag(video::EMF_LIGHTING, false); - //buf->getMaterial().setFlag(video::EMF_BACK_FACE_CULLING, false); - buf->getMaterial().setTexture(0, driver->getTexture("../data/player.png")); - buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false); - buf->getMaterial().setFlag(video::EMF_FOG_ENABLE, true); - //buf->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL; - buf->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF; - // Add to mesh - mesh->addMeshBuffer(buf); - buf->drop(); - } - { // Back - scene::IMeshBuffer *buf = new scene::SMeshBuffer(); - video::SColor c(255,255,255,255); - video::S3DVertex vertices[4] = - { - video::S3DVertex(BS/2,0,0, 0,0,0, c, 1,1), - video::S3DVertex(-BS/2,0,0, 0,0,0, c, 0,1), - video::S3DVertex(-BS/2,BS*2,0, 0,0,0, c, 0,0), - video::S3DVertex(BS/2,BS*2,0, 0,0,0, c, 1,0), - }; - u16 indices[] = {0,1,2,2,3,0}; - buf->append(vertices, 4, indices, 6); - // Set material - buf->getMaterial().setFlag(video::EMF_LIGHTING, false); - //buf->getMaterial().setFlag(video::EMF_BACK_FACE_CULLING, false); - buf->getMaterial().setTexture(0, driver->getTexture("../data/player_back.png")); - buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false); - buf->getMaterial().setFlag(video::EMF_FOG_ENABLE, true); - buf->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF; - // Add to mesh - mesh->addMeshBuffer(buf); - buf->drop(); - } - m_node = mgr->addMeshSceneNode(mesh, this); - mesh->drop(); - m_node->setPosition(v3f(0,0,0)); - } + return floatToInt(m_position + v3f(0,BS+BS/2,0), BS); } -RemotePlayer::~RemotePlayer() +void Player::serialize(std::ostream &os) { - if(SceneManager != NULL) - ISceneNode::remove(); + // Utilize a Settings object for storing values + Settings args; + args.setS32("version", 1); + args.set("name", m_name); + //args.set("password", m_password); + args.setFloat("pitch", m_pitch); + args.setFloat("yaw", m_yaw); + args.setV3F("position", m_position); + args.setS32("hp", hp); + + args.writeLines(os); + + os<<"PlayerArgsEnd\n"; + + // If actual inventory is backed up due to creative mode, save it + // instead of the dummy creative mode inventory + if(inventory_backup) + inventory_backup->serialize(os); + else + inventory.serialize(os); } -void RemotePlayer::updateName(const char *name) +void Player::deSerialize(std::istream &is) { - Player::updateName(name); - if(m_text != NULL) + Settings args; + + for(;;) { - wchar_t wname[PLAYERNAME_SIZE]; - mbstowcs(wname, m_name, strlen(m_name)+1); - m_text->setText(wname); + if(is.eof()) + throw SerializationError + ("Player::deSerialize(): PlayerArgsEnd not found"); + std::string line; + std::getline(is, line); + std::string trimmedline = trim(line); + if(trimmedline == "PlayerArgsEnd") + break; + args.parseConfigLine(line); } -} -void RemotePlayer::move(f32 dtime, Map &map) -{ - m_pos_animation_time_counter += dtime; - m_pos_animation_counter += dtime; - v3f movevector = m_position - m_oldpos; - f32 moveratio; - if(m_pos_animation_time < 0.001) - moveratio = 1.0; - else - moveratio = m_pos_animation_counter / m_pos_animation_time; - if(moveratio > 1.5) - moveratio = 1.5; - m_showpos = m_oldpos + movevector * moveratio; - - ISceneNode::setPosition(m_showpos); -} + //args.getS32("version"); // Version field value not used + std::string name = args.get("name"); + updateName(name.c_str()); + setPitch(args.getFloat("pitch")); + setYaw(args.getFloat("yaw")); + setPosition(args.getV3F("position")); + try{ + hp = args.getS32("hp"); + }catch(SettingNotFoundException &e){ + hp = 20; + } -#endif + inventory.deSerialize(is); + + if(inventory.getList("craftpreview") == NULL) + { + // Convert players without craftpreview + inventory.addList("craftpreview", 1); + + bool craftresult_is_preview = true; + if(args.exists("craftresult_is_preview")) + craftresult_is_preview = args.getBool("craftresult_is_preview"); + if(craftresult_is_preview) + { + // Clear craftresult + inventory.getList("craftresult")->changeItem(0, ItemStack()); + } + } +} #ifndef SERVER /* LocalPlayer */ -LocalPlayer::LocalPlayer() +LocalPlayer::LocalPlayer(IGameDef *gamedef): + Player(gamedef), + m_sneak_node(32767,32767,32767), + m_sneak_node_exists(false) { + // Initialize hp to 0, so that no hearts will be shown if server + // doesn't support health points + hp = 0; } LocalPlayer::~LocalPlayer() { } -void LocalPlayer::move(f32 dtime, Map &map) +void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d, + core::list *collision_info) { + INodeDefManager *nodemgr = m_gamedef->ndef(); + v3f position = getPosition(); v3f oldpos = position; - v3s16 oldpos_i = floatToInt(oldpos); + v3s16 oldpos_i = floatToInt(oldpos, BS); + + v3f old_speed = m_speed; /*std::cout<<"oldpos_i=("<getBool("free_move"); + if(free_move) { setPosition(position); return; @@ -218,22 +229,25 @@ void LocalPlayer::move(f32 dtime, Map &map) /* Collision detection */ - - v3s16 pos_i = floatToInt(position); + + // Player position in nodes + v3s16 pos_i = floatToInt(position, BS); /* - Check if player is in water + 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)); - in_water = content_liquid(map.getNode(pp).d); + v3s16 pp = floatToInt(position + v3f(0,BS*0.1,0), BS); + in_water = nodemgr->get(map.getNode(pp).getContent()).isLiquid(); } + // If not in water, the threshold of going in is at lower y else { - v3s16 pp = floatToInt(position + v3f(0,BS/2,0)); - in_water = content_liquid(map.getNode(pp).d); + v3s16 pp = floatToInt(position + v3f(0,BS*0.5,0), BS); + in_water = nodemgr->get(map.getNode(pp).getContent()).isLiquid(); } } catch(InvalidPositionException &e) @@ -241,130 +255,374 @@ void LocalPlayer::move(f32 dtime, Map &map) in_water = false; } - // The frame length is limited to the player going 0.1*BS per call - f32 d = (float)BS * 0.15; + /* + Check if player is in water (the stable value) + */ + try{ + v3s16 pp = floatToInt(position + v3f(0,0,0), BS); + in_water_stable = nodemgr->get(map.getNode(pp).getContent()).isLiquid(); + } + catch(InvalidPositionException &e) + { + in_water_stable = false; + } + + /* + Check if player is climbing + */ -#define PLAYER_RADIUS (BS*0.3) -#define PLAYER_HEIGHT (BS*1.7) + try { + v3s16 pp = floatToInt(position + v3f(0,0.5*BS,0), BS); + v3s16 pp2 = floatToInt(position + v3f(0,-0.2*BS,0), BS); + is_climbing = ((nodemgr->get(map.getNode(pp).getContent()).climbable || + nodemgr->get(map.getNode(pp2).getContent()).climbable) && !free_move); + } + catch(InvalidPositionException &e) + { + is_climbing = false; + } + + /* + 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 smoother + f32 d = 0.15*BS; + + // This should always apply, otherwise there are glitches + assert(d > pos_max_d); + + float player_radius = BS*0.30; + float player_height = BS*1.55; + + // 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 && m_sneak_node_exists) + { + f32 maxd = 0.5*BS + sneak_max; + v3f lwn_f = intToFloat(m_sneak_node, BS); + 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; + + //v3f old_speed = m_speed; + + if(m_speed.Y < 0) + m_speed.Y = 0; + + /*if(collision_info) + { + // Report fall collision + if(old_speed.Y < m_speed.Y - 0.1) + { + CollisionInfo info; + info.t = COLLISION_FALL; + info.speed = m_speed.Y - old_speed.Y; + collision_info->push_back(info); + } + }*/ + } + } + /* + 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 (" < (" <get(map.getNode(v3s16(x,y,z))).walkable == false) + continue; + } + catch(InvalidPositionException &e) + { + is_unloaded = true; + // 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 nodebox = getNodeBox(v3s16(x,y,z), BS); + + /* + 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(is_unloaded) + standing_on_unloaded = 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) + { + //v3f old_speed = m_speed; - core::aabbox3d 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; - } + m_speed -= m_speed.dotProduct(dirs[i]) * dirs[i]; + position -= position.dotProduct(dirs[i]) * dirs[i]; + position += oldpos.dotProduct(dirs[i]) * dirs[i]; - if(playerbox.intersectsWithBox(nodebox)) + /*if(collision_info) { - - 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++) + // Report fall collision + if(old_speed.Y < m_speed.Y - 0.1) + { + CollisionInfo info; + info.t = COLLISION_FALL; + info.speed = m_speed.Y - old_speed.Y; + collision_info->push_back(info); + } + }*/ + } + + } + } // xyz + + /* + Check the nodes under the player to see from which node the + player is sneaking from, if any. + */ { - 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++) + v3s16 pos_i_bottom = floatToInt(position - v3f(0,BS/2,0), BS); + v2f player_p2df(position.X, position.Z); + f32 min_distance_f = 100000.0*BS; + // If already seeking from some node, compare to it. + /*if(m_sneak_node_exists) + { + v3f sneaknode_pf = intToFloat(m_sneak_node, BS); + v2f sneaknode_p2df(sneaknode_pf.X, sneaknode_pf.Z); + f32 d_horiz_f = player_p2df.getDistanceFrom(sneaknode_p2df); + f32 d_vert_f = fabs(sneaknode_pf.Y + BS*0.5 - position.Y); + // Ignore if player is not on the same level (likely dropped) + if(d_vert_f < 0.15*BS) + min_distance_f = d_horiz_f; + }*/ + v3s16 new_sneak_node = m_sneak_node; + for(s16 x=-1; x<=1; x++) + for(s16 z=-1; z<=1; z++) { - if(j == i) + v3s16 p = pos_i_bottom + v3s16(x,0,z); + v3f pf = intToFloat(p, BS); + v2f node_p2df(pf.X, pf.Z); + f32 distance_f = player_p2df.getDistanceFrom(node_p2df); + f32 max_axis_distance_f = MYMAX( + fabs(player_p2df.X-node_p2df.X), + fabs(player_p2df.Y-node_p2df.Y)); + + if(distance_f > min_distance_f || + max_axis_distance_f > 0.5*BS + sneak_max + 0.1*BS) 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{ + // The node to be sneaked on has to be walkable + if(nodemgr->get(map.getNode(p)).walkable == false) + continue; + // And the node above it has to be nonwalkable + if(nodemgr->get(map.getNode(p+v3s16(0,1,0))).walkable == true) + continue; + } + catch(InvalidPositionException &e) { - other_edges_collide = false; - break; + continue; } + + min_distance_f = distance_f; + new_sneak_node = p; } - if(main_edge_collides && other_edges_collide) + bool sneak_node_found = (min_distance_f < 100000.0*BS*0.9); + + if(control.sneak && m_sneak_node_exists) + { + if(sneak_node_found) + m_sneak_node = new_sneak_node; + } + else { - m_speed -= m_speed.dotProduct(dirs[i]) * dirs[i]; - position -= position.dotProduct(dirs[i]) * dirs[i]; - position += oldpos.dotProduct(dirs[i]) * dirs[i]; + m_sneak_node = new_sneak_node; + m_sneak_node_exists = sneak_node_found; } + + /* + If sneaking, the player's collision box can be in air, so + this has to be set explicitly + */ + if(sneak_node_found && control.sneak) + touching_ground = true; + } + + /* + Set new position + */ + setPosition(position); + /* + Report collisions + */ + if(collision_info) + { + // Report fall collision + if(old_speed.Y < m_speed.Y - 0.1 && !standing_on_unloaded) + { + CollisionInfo info; + info.t = COLLISION_FALL; + info.speed = m_speed.Y - old_speed.Y; + collision_info->push_back(info); + } } - } // if(playerbox.intersectsWithBox(nodebox)) - } // for x - } // for z - } // for y +} - setPosition(position); +void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d) +{ + move(dtime, map, pos_max_d, NULL); } void LocalPlayer::applyControl(float dtime) { + // Clear stuff + 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); @@ -374,17 +632,61 @@ void LocalPlayer::applyControl(float dtime) v3f speed = v3f(0,0,0); - // Superspeed mode - bool superspeed = false; - if(control.superspeed) + bool free_move = g_settings->getBool("free_move"); + bool fast_move = g_settings->getBool("fast_move"); + bool continuous_forward = g_settings->getBool("continuous_forward"); + + if(free_move || is_climbing) { - speed += move_direction; + v3f speed = getSpeed(); + speed.Y = 0; + setSpeed(speed); + } + + // Whether superspeed mode is used or not + bool superspeed = false; + + // If free movement and fast movement, always move fast + if(free_move && fast_move) superspeed = true; + + // Auxiliary button 1 (E) + if(control.aux1) + { + if(free_move) + { + // In free movement mode, aux1 descends + v3f speed = getSpeed(); + if(fast_move) + speed.Y = -20*BS; + else + speed.Y = -walkspeed_max; + setSpeed(speed); + } + else if(is_climbing) + { + v3f speed = getSpeed(); + speed.Y = -3*BS; + setSpeed(speed); + } + else + { + // If not free movement but fast is allowed, aux1 is + // "Turbo button" + if(fast_move) + superspeed = true; + } } + if(continuous_forward) + speed += move_direction; + if(control.up) { - speed += move_direction; + if(continuous_forward) + superspeed = true; + else + speed += move_direction; } if(control.down) { @@ -400,28 +702,60 @@ void LocalPlayer::applyControl(float dtime) } if(control.jump) { - if(touching_ground) + if(free_move) { v3f speed = getSpeed(); - speed.Y = 6.5*BS; + if(fast_move) + speed.Y = 20*BS; + else + speed.Y = walkspeed_max; setSpeed(speed); } + else if(touching_ground) + { + /* + NOTE: The d value in move() affects jump height by + raising the height at which the jump speed is kept + at its starting value + */ + v3f speed = getSpeed(); + if(speed.Y >= -0.5*BS) + { + speed.Y = 6.5*BS; + setSpeed(speed); + } + } + // Use the oscillating value for getting out of water + // (so that the player doesn't fly on the surface) else if(in_water) { v3f speed = getSpeed(); - speed.Y = 2.0*BS; + speed.Y = 1.5*BS; + setSpeed(speed); + swimming_up = true; + } + else if(is_climbing) + { + v3f speed = getSpeed(); + speed.Y = 3*BS; setSpeed(speed); } } // 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; f32 inc = walk_acceleration * BS * dtime; + // Faster acceleration if fast and free movement + if(free_move && fast_move) + inc = walk_acceleration * BS * dtime * 10; + // Accelerate to target speed with maximum increment accelerate(speed, inc); }