X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fplayer.cpp;h=198eca95706c4a3d8c2f9149af7922cb93a959d3;hb=7d0395ba36a09be95b4ad6e0216e4d74986d80a0;hp=2c04f1f7637a7b2fe80b7c166f4fa6d471b940c9;hpb=ab7477c4c3e2a3647dc4fb65c71567946d33b0e3;p=dragonfireclient.git diff --git a/src/player.cpp b/src/player.cpp index 2c04f1f76..198eca957 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,194 +17,59 @@ 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" +#include "utility.h" + Player::Player(): touching_ground(false), in_water(false), - inventory(PLAYER_INVENTORY_SIZE), - peer_id(PEER_ID_NEW), + in_water_stable(false), + swimming_up(false), + craftresult_is_preview(true), + hp(20), + peer_id(PEER_ID_INEXISTENT), + m_pitch(0), + m_yaw(0), m_speed(0,0,0), m_position(0,0,0) { updateName(""); + resetInventory(); } Player::~Player() { } -void Player::move(f32 dtime, Map &map) +void Player::resetInventory() { - v3f position = getPosition(); - v3f oldpos = position; - v3s16 oldpos_i = floatToInt(oldpos); - - /*std::cout<<"oldpos_i=("< playerbox( - position.X - PLAYER_RADIUS, - position.Y - 0.0, - 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.Y - 0.0, - oldpos.Z - PLAYER_RADIUS, - oldpos.X + PLAYER_RADIUS, - oldpos.Y + PLAYER_HEIGHT, - oldpos.Z + PLAYER_RADIUS - ); - - //hilightboxes.push_back(playerbox); - - touching_ground = false; - - /*std::cout<<"Checking collisions for (" - < (" - < 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++) - { - 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) - 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) - { - 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)) - } // for x - } // for z - } // for y - - setPosition(position); + inventory.clear(); + inventory.addList("main", PLAYER_INVENTORY_SIZE); + inventory.addList("craft", 9); + 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) @@ -222,6 +87,82 @@ 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 +} + +void Player::serialize(std::ostream &os) +{ + // 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.setBool("craftresult_is_preview", craftresult_is_preview); + args.setS32("hp", hp); + + args.writeLines(os); + + os<<"PlayerArgsEnd\n"; + + inventory.serialize(os); +} + +void Player::deSerialize(std::istream &is) +{ + Settings args; + + for(;;) + { + 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); + } + + //args.getS32("version"); + std::string name = args.get("name"); + updateName(name.c_str()); + /*std::string password = ""; + if(args.exists("password")) + password = args.get("password"); + updatePassword(password.c_str());*/ + m_pitch = args.getFloat("pitch"); + m_yaw = args.getFloat("yaw"); + m_position = args.getV3F("position"); + try{ + craftresult_is_preview = args.getBool("craftresult_is_preview"); + }catch(SettingNotFoundException &e){ + craftresult_is_preview = true; + } + try{ + hp = args.getS32("hp"); + }catch(SettingNotFoundException &e){ + hp = 20; + } + /*try{ + std::string sprivs = args.get("privs"); + if(sprivs == "all") + { + privs = PRIV_ALL; + } + else + { + std::istringstream ss(sprivs); + ss>>privs; + } + }catch(SettingNotFoundException &e){ + privs = PRIV_DEFAULT; + }*/ + + inventory.deSerialize(is); } /* @@ -269,8 +210,9 @@ RemotePlayer::RemotePlayer( // 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().setTexture(0, driver->getTexture(getTexturePath("player.png").c_str())); 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 @@ -292,16 +234,17 @@ RemotePlayer::RemotePlayer( // 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().setTexture(0, driver->getTexture(getTexturePath("player_back.png").c_str())); 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(); } - scene::IMeshSceneNode *node = mgr->addMeshSceneNode(mesh, this); + m_node = mgr->addMeshSceneNode(mesh, this); mesh->drop(); - node->setPosition(v3f(0,0,0)); + m_node->setPosition(v3f(0,0,0)); } } @@ -322,6 +265,23 @@ void RemotePlayer::updateName(const char *name) } } +void RemotePlayer::move(f32 dtime, Map &map, f32 pos_max_d) +{ + 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); +} + #endif #ifndef SERVER @@ -329,21 +289,388 @@ void RemotePlayer::updateName(const char *name) LocalPlayer */ -LocalPlayer::LocalPlayer() +LocalPlayer::LocalPlayer(): + 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, f32 pos_max_d, + core::list *collision_info) +{ + v3f position = getPosition(); + v3f oldpos = position; + v3s16 oldpos_i = floatToInt(oldpos, BS); + + /*std::cout<<"oldpos_i=("< 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 && 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; + if(m_speed.Y < 0) + m_speed.Y = 0; + } + } + + /* + Calculate player collision box (new and old) + */ + core::aabbox3d playerbox( + position.X - player_radius, + position.Y - 0.0, + 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.Y - 0.0, + oldpos.Z - player_radius, + oldpos.X + player_radius, + oldpos.Y + player_height, + oldpos.Z + player_radius + ); + + /* + 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 (" + < (" + < 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 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) + { + v3f old_speed = m_speed; + + m_speed -= m_speed.dotProduct(dirs[i]) * dirs[i]; + position -= position.dotProduct(dirs[i]) * dirs[i]; + position += oldpos.dotProduct(dirs[i]) * dirs[i]; + + 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); + } + } + } + + } + } // xyz + + /* + Check the nodes under the player to see from which node the + player is sneaking from, if any. + */ + { + 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++) + { + 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; + + try{ + // The node to be sneaked on has to be walkable + if(content_walkable(map.getNode(p).d) == false) + continue; + // And the node above it has to be nonwalkable + if(content_walkable(map.getNode(p+v3s16(0,1,0)).d) == true) + continue; + } + catch(InvalidPositionException &e) + { + continue; + } + + min_distance_f = distance_f; + new_sneak_node = p; + } + + 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_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); +} + +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); @@ -353,17 +680,55 @@ 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) { - 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 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) { @@ -379,28 +744,51 @@ void LocalPlayer::applyControl(float dtime) } if(control.jump) { - if(touching_ground) + if(free_move) + { + v3f speed = getSpeed(); + if(fast_move) + speed.Y = 20*BS; + else + speed.Y = walkspeed_max; + setSpeed(speed); + } + 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); } + // 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; } } // 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); }