minetest/src/player.cpp

925 lines
22 KiB
C++
Raw Normal View History

/*
Minetest-c55
Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
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
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
2010-11-27 00:02:21 +01:00
#include "player.h"
#include "map.h"
#include "connection.h"
#include "constants.h"
#include "utility.h"
2011-10-12 12:53:38 +02:00
#ifndef SERVER
#include <ITextSceneNode.h>
#endif
#include "settings.h"
2010-11-27 00:02:21 +01:00
Player::Player():
touching_ground(false),
2010-11-30 14:35:03 +01:00
in_water(false),
2011-02-08 00:12:55 +01:00
in_water_stable(false),
is_climbing(false),
2011-02-08 00:12:55 +01:00
swimming_up(false),
inventory_backup(NULL),
craftresult_is_preview(true),
hp(20),
peer_id(PEER_ID_INEXISTENT),
2011-08-10 18:31:44 +02:00
m_selected_item(0),
2011-02-08 00:12:55 +01:00
m_pitch(0),
m_yaw(0),
2010-11-27 00:02:21 +01:00
m_speed(0,0,0),
2011-05-16 18:54:08 +02:00
m_position(0,0,0)
2010-11-27 00:02:21 +01:00
{
updateName("<not set>");
resetInventory();
2010-11-27 00:02:21 +01:00
}
Player::~Player()
{
delete inventory_backup;
2010-11-27 00:02:21 +01:00
}
2011-08-10 18:31:44 +02:00
void Player::wieldItem(u16 item)
{
m_selected_item = item;
}
void Player::resetInventory()
{
inventory.clear();
inventory.addList("main", PLAYER_INVENTORY_SIZE);
inventory.addList("craft", 9);
inventory.addList("craftresult", 1);
}
2010-12-22 02:33:58 +01:00
// 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
2010-12-22 02:33:58 +01:00
if(m_speed.X < target_speed.X - max_increase)
m_speed.X += max_increase;
else if(m_speed.X > target_speed.X + max_increase)
m_speed.X -= max_increase;
else if(m_speed.X < target_speed.X)
m_speed.X = target_speed.X;
else if(m_speed.X > target_speed.X)
m_speed.X = target_speed.X;
if(m_speed.Z < target_speed.Z - max_increase)
m_speed.Z += max_increase;
else if(m_speed.Z > target_speed.Z + max_increase)
m_speed.Z -= max_increase;
else if(m_speed.Z < target_speed.Z)
m_speed.Z = target_speed.Z;
else if(m_speed.Z > target_speed.Z)
m_speed.Z = target_speed.Z;
#endif
2010-12-22 02:33:58 +01:00
}
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";
// 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 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"); // 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{
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;
}
inventory.deSerialize(is);
}
2011-11-12 16:37:14 +01:00
/*
ServerRemotePlayer
*/
/* ServerActiveObject interface */
InventoryItem* ServerRemotePlayer::getWieldedItem()
{
InventoryList *list = inventory.getList("main");
if (list)
return list->getItem(m_selected_item);
return NULL;
}
void ServerRemotePlayer::damageWieldedItem(u16 amount)
{
infostream<<"Damaging "<<getName()<<"'s wielded item for amount="
<<amount<<std::endl;
InventoryList *list = inventory.getList("main");
if(!list)
return;
InventoryItem *item = list->getItem(m_selected_item);
if(item && (std::string)item->getName() == "ToolItem"){
ToolItem *titem = (ToolItem*)item;
bool weared_out = titem->addWear(amount);
if(weared_out)
list->deleteItem(m_selected_item);
}
}
bool ServerRemotePlayer::addToInventory(InventoryItem *item)
{
infostream<<"Adding "<<item->getName()<<" into "<<getName()
<<"'s inventory"<<std::endl;
InventoryList *ilist = inventory.getList("main");
if(ilist == NULL)
return false;
// In creative mode, just delete the item
if(g_settings->getBool("creative_mode")){
return false;
}
// Skip if inventory has no free space
if(ilist->roomForItem(item) == false)
{
infostream<<"Player inventory has no free space"<<std::endl;
return false;
}
// Add to inventory
InventoryItem *leftover = ilist->addItem(item);
assert(!leftover);
return true;
}
void ServerRemotePlayer::setHP(s16 hp_)
{
hp = hp_;
}
s16 ServerRemotePlayer::getHP()
{
return hp;
}
2010-12-22 02:33:58 +01:00
/*
RemotePlayer
*/
#ifndef SERVER
RemotePlayer::RemotePlayer(
scene::ISceneNode* parent,
IrrlichtDevice *device,
s32 id):
scene::ISceneNode(parent, (device==NULL)?NULL:device->getSceneManager(), id),
m_text(NULL)
{
m_box = core::aabbox3d<f32>(-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(getTexturePath("player.png").c_str()));
2010-12-22 02:33:58 +01:00
buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false);
2010-12-22 19:47:17 +01:00
buf->getMaterial().setFlag(video::EMF_FOG_ENABLE, true);
2010-12-22 02:33:58 +01:00
//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(getTexturePath("player_back.png").c_str()));
2010-12-22 02:33:58 +01:00
buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false);
2010-12-22 19:47:17 +01:00
buf->getMaterial().setFlag(video::EMF_FOG_ENABLE, true);
2010-12-22 02:33:58 +01:00
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));
}
}
RemotePlayer::~RemotePlayer()
{
if(SceneManager != NULL)
ISceneNode::remove();
}
void RemotePlayer::updateName(const char *name)
{
Player::updateName(name);
if(m_text != NULL)
{
wchar_t wname[PLAYERNAME_SIZE];
mbstowcs(wname, m_name, strlen(m_name)+1);
m_text->setText(wname);
}
}
2011-02-14 01:54:15 +01:00
void RemotePlayer::move(f32 dtime, Map &map, f32 pos_max_d)
2010-12-22 02:33:58 +01:00
{
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
/*
LocalPlayer
*/
2011-02-14 01:54:15 +01:00
LocalPlayer::LocalPlayer():
2011-02-14 10:43:42 +01:00
m_sneak_node(32767,32767,32767),
m_sneak_node_exists(false)
2010-12-22 02:33:58 +01:00
{
// Initialize hp to 0, so that no hearts will be shown if server
// doesn't support health points
hp = 0;
2010-12-22 02:33:58 +01:00
}
LocalPlayer::~LocalPlayer()
{
}
void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d,
core::list<CollisionInfo> *collision_info)
2010-11-27 00:02:21 +01:00
{
v3f position = getPosition();
v3f oldpos = position;
v3s16 oldpos_i = floatToInt(oldpos, BS);
2010-11-27 00:02:21 +01:00
2011-06-26 14:45:13 +02:00
v3f old_speed = m_speed;
2010-11-27 00:02:21 +01:00
/*std::cout<<"oldpos_i=("<<oldpos_i.X<<","<<oldpos_i.Y<<","
<<oldpos_i.Z<<")"<<std::endl;*/
2011-02-14 01:54:15 +01:00
/*
Calculate new position
*/
position += m_speed * dtime;
2011-02-14 01:54:15 +01:00
// Skip collision detection if a special movement mode is used
2011-10-12 12:53:38 +02:00
bool free_move = g_settings->getBool("free_move");
2011-02-14 01:54:15 +01:00
if(free_move)
2010-11-27 00:02:21 +01:00
{
setPosition(position);
return;
}
/*
Collision detection
*/
2011-02-14 01:54:15 +01:00
// Player position in nodes
v3s16 pos_i = floatToInt(position, BS);
2010-11-27 00:02:21 +01:00
2010-11-30 14:35:03 +01:00
/*
2011-02-08 00:12:55 +01:00
Check if player is in water (the oscillating value)
2010-11-30 14:35:03 +01:00
*/
try{
2011-02-14 01:54:15 +01:00
// If in water, the threshold of coming out is at higher y
2010-11-30 14:35:03 +01:00
if(in_water)
{
v3s16 pp = floatToInt(position + v3f(0,BS*0.1,0), BS);
2011-07-23 15:55:26 +02:00
in_water = content_liquid(map.getNode(pp).getContent());
2010-11-30 14:35:03 +01:00
}
2011-02-14 01:54:15 +01:00
// If not in water, the threshold of going in is at lower y
2010-11-30 14:35:03 +01:00
else
{
v3s16 pp = floatToInt(position + v3f(0,BS*0.5,0), BS);
2011-07-23 15:55:26 +02:00
in_water = content_liquid(map.getNode(pp).getContent());
2010-11-30 14:35:03 +01:00
}
}
catch(InvalidPositionException &e)
{
in_water = false;
}
2011-02-08 00:12:55 +01:00
/*
Check if player is in water (the stable value)
*/
try{
v3s16 pp = floatToInt(position + v3f(0,0,0), BS);
2011-07-23 15:55:26 +02:00
in_water_stable = content_liquid(map.getNode(pp).getContent());
2011-02-08 00:12:55 +01:00
}
catch(InvalidPositionException &e)
{
in_water_stable = false;
}
2011-07-27 23:38:48 +02:00
/*
Check if player is climbing
*/
try {
v3s16 pp = floatToInt(position + v3f(0,0.5*BS,0), BS);
v3s16 pp2 = floatToInt(position + v3f(0,-0.2*BS,0), BS);
2011-07-31 06:53:05 +02:00
is_climbing = ((content_features(map.getNode(pp).getContent()).climbable ||
content_features(map.getNode(pp2).getContent()).climbable) && !free_move);
2011-07-27 23:38:48 +02:00
}
catch(InvalidPositionException &e)
{
is_climbing = false;
}
2011-02-14 01:54:15 +01:00
/*
Collision uncertainty radius
Make it a bit larger than the maximum distance of movement
*/
//f32 d = pos_max_d * 1.1;
2011-02-14 15:11:28 +01:00
// A fairly large value in here makes moving smoother
2011-02-14 01:54:15 +01:00
f32 d = 0.15*BS;
// This should always apply, otherwise there are glitches
assert(d > pos_max_d);
2010-11-27 00:02:21 +01:00
2011-02-14 01:54:15 +01:00
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
*/
2011-02-14 10:43:42 +01:00
if(control.sneak && m_sneak_node_exists)
2011-02-14 01:54:15 +01:00
{
f32 maxd = 0.5*BS + sneak_max;
v3f lwn_f = intToFloat(m_sneak_node, BS);
2011-02-14 01:54:15 +01:00
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;
2011-06-26 14:45:13 +02:00
//v3f old_speed = m_speed;
2011-02-14 01:54:15 +01:00
if(m_speed.Y < 0)
m_speed.Y = 0;
2011-06-26 14:45:13 +02:00
/*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);
}
}*/
2011-02-14 01:54:15 +01:00
}
}
2010-11-27 00:02:21 +01:00
2011-02-14 01:54:15 +01:00
/*
Calculate player collision box (new and old)
*/
2010-11-27 00:02:21 +01:00
core::aabbox3d<f32> playerbox(
2011-02-14 01:54:15 +01:00
position.X - player_radius,
2010-11-27 00:02:21 +01:00
position.Y - 0.0,
2011-02-14 01:54:15 +01:00
position.Z - player_radius,
position.X + player_radius,
position.Y + player_height,
position.Z + player_radius
2010-11-27 00:02:21 +01:00
);
core::aabbox3d<f32> playerbox_old(
2011-02-14 01:54:15 +01:00
oldpos.X - player_radius,
2010-11-27 00:02:21 +01:00
oldpos.Y - 0.0,
2011-02-14 01:54:15 +01:00
oldpos.Z - player_radius,
oldpos.X + player_radius,
oldpos.Y + player_height,
oldpos.Z + player_radius
2010-11-27 00:02:21 +01:00
);
2011-02-14 01:54:15 +01:00
/*
If the player's feet touch the topside of any node, this is
set to true.
2010-11-27 00:02:21 +01:00
2011-02-14 01:54:15 +01:00
Player is allowed to jump when this is true.
*/
2010-11-27 00:02:21 +01:00
touching_ground = false;
2011-07-27 23:38:48 +02:00
2010-11-27 00:02:21 +01:00
/*std::cout<<"Checking collisions for ("
<<oldpos_i.X<<","<<oldpos_i.Y<<","<<oldpos_i.Z
<<") -> ("
<<pos_i.X<<","<<pos_i.Y<<","<<pos_i.Z
<<"):"<<std::endl;*/
2011-02-14 01:54:15 +01:00
bool standing_on_unloaded = false;
2011-02-14 01:54:15 +01:00
/*
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++)
{
bool is_unloaded = false;
2011-02-14 01:54:15 +01:00
try{
2011-02-14 15:11:28 +01:00
// Player collides into walkable nodes
2011-07-23 15:55:26 +02:00
if(content_walkable(map.getNode(v3s16(x,y,z)).getContent()) == false)
2011-02-14 01:54:15 +01:00
continue;
}
catch(InvalidPositionException &e)
{
is_unloaded = true;
// Doing nothing here will block the player from
// walking over map borders
2011-02-14 01:54:15 +01:00
}
2010-11-27 00:02:21 +01:00
2011-02-23 01:49:57 +01:00
core::aabbox3d<f32> nodebox = getNodeBox(v3s16(x,y,z), BS);
2011-02-14 01:54:15 +01:00
/*
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;
2011-02-14 01:54:15 +01:00
}
// 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))
2010-11-27 00:02:21 +01:00
{
2011-02-14 01:54:15 +01:00
other_axes_overlap = false;
break;
2010-11-27 00:02:21 +01:00
}
2011-02-14 01:54:15 +01:00
}
/*
If this is a collision, revert the position in the main
direction.
*/
if(other_axes_overlap && main_axis_collides)
{
2011-06-26 14:45:13 +02:00
//v3f old_speed = m_speed;
2011-02-14 01:54:15 +01:00
m_speed -= m_speed.dotProduct(dirs[i]) * dirs[i];
position -= position.dotProduct(dirs[i]) * dirs[i];
position += oldpos.dotProduct(dirs[i]) * dirs[i];
2011-06-26 14:45:13 +02:00
/*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);
}
2011-06-26 14:45:13 +02:00
}*/
2011-02-14 01:54:15 +01:00
}
}
} // xyz
2010-11-27 00:02:21 +01:00
2011-02-14 01:54:15 +01:00
/*
2011-02-14 15:11:28 +01:00
Check the nodes under the player to see from which node the
player is sneaking from, if any.
2011-02-14 01:54:15 +01:00
*/
{
v3s16 pos_i_bottom = floatToInt(position - v3f(0,BS/2,0), BS);
2011-02-14 01:54:15 +01:00
v2f player_p2df(position.X, position.Z);
2011-02-14 10:43:42 +01:00
f32 min_distance_f = 100000.0*BS;
2011-02-14 15:11:28 +01:00
// If already seeking from some node, compare to it.
/*if(m_sneak_node_exists)
2011-02-14 10:43:42 +01:00
{
v3f sneaknode_pf = intToFloat(m_sneak_node, BS);
2011-02-14 10:43:42 +01:00
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);
2011-02-14 15:11:28 +01:00
// Ignore if player is not on the same level (likely dropped)
2011-02-14 10:43:42 +01:00
if(d_vert_f < 0.15*BS)
min_distance_f = d_horiz_f;
2011-02-14 15:11:28 +01:00
}*/
2011-02-14 10:43:42 +01:00
v3s16 new_sneak_node = m_sneak_node;
2011-02-14 01:54:15 +01:00
for(s16 x=-1; x<=1; x++)
for(s16 z=-1; z<=1; z++)
2010-11-27 00:02:21 +01:00
{
2011-02-14 10:43:42 +01:00
v3s16 p = pos_i_bottom + v3s16(x,0,z);
v3f pf = intToFloat(p, BS);
2011-02-14 01:54:15 +01:00
v2f node_p2df(pf.X, pf.Z);
f32 distance_f = player_p2df.getDistanceFrom(node_p2df);
2011-02-14 10:43:42 +01:00
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 ||
2011-02-14 15:11:28 +01:00
max_axis_distance_f > 0.5*BS + sneak_max + 0.1*BS)
2010-11-27 00:02:21 +01:00
continue;
2011-02-14 10:43:42 +01:00
2011-02-14 01:54:15 +01:00
try{
2011-02-14 15:11:28 +01:00
// The node to be sneaked on has to be walkable
2011-07-23 15:55:26 +02:00
if(content_walkable(map.getNode(p).getContent()) == false)
2011-02-14 01:54:15 +01:00
continue;
2011-02-14 15:11:28 +01:00
// And the node above it has to be nonwalkable
2011-07-23 15:55:26 +02:00
if(content_walkable(map.getNode(p+v3s16(0,1,0)).getContent()) == true)
2011-02-14 15:11:28 +01:00
continue;
2011-02-14 01:54:15 +01:00
}
catch(InvalidPositionException &e)
2010-11-27 00:02:21 +01:00
{
2011-02-14 01:54:15 +01:00
continue;
2010-11-27 00:02:21 +01:00
}
2011-02-14 01:54:15 +01:00
min_distance_f = distance_f;
2011-02-14 10:43:42 +01:00
new_sneak_node = p;
2010-11-27 00:02:21 +01:00
}
2011-02-14 15:11:28 +01:00
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;
2010-11-27 00:02:21 +01:00
}
2011-02-14 01:54:15 +01:00
/*
Set new position
*/
2010-11-27 00:02:21 +01:00
setPosition(position);
2011-06-26 14:45:13 +02:00
/*
Report collisions
*/
if(collision_info)
{
// Report fall collision
if(old_speed.Y < m_speed.Y - 0.1 && !standing_on_unloaded)
2011-06-26 14:45:13 +02:00
{
CollisionInfo info;
info.t = COLLISION_FALL;
info.speed = m_speed.Y - old_speed.Y;
collision_info->push_back(info);
}
}
2010-11-27 00:02:21 +01:00
}
void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d)
{
move(dtime, map, pos_max_d, NULL);
}
2010-11-27 00:02:21 +01:00
void LocalPlayer::applyControl(float dtime)
{
// Clear stuff
swimming_up = false;
2010-11-27 00:02:21 +01:00
// Random constants
2011-02-14 01:54:15 +01:00
f32 walk_acceleration = 4.0 * BS;
f32 walkspeed_max = 4.0 * BS;
2010-11-27 00:02:21 +01:00
setPitch(control.pitch);
setYaw(control.yaw);
v3f move_direction = v3f(0,0,1);
move_direction.rotateXZBy(getYaw());
v3f speed = v3f(0,0,0);
2011-10-12 12:53:38 +02:00
bool free_move = g_settings->getBool("free_move");
bool fast_move = g_settings->getBool("fast_move");
bool continuous_forward = g_settings->getBool("continuous_forward");
2011-02-06 15:35:27 +01:00
2011-07-31 06:53:05 +02:00
if(free_move || is_climbing)
{
v3f speed = getSpeed();
speed.Y = 0;
setSpeed(speed);
}
2011-02-06 15:35:27 +01:00
// Whether superspeed mode is used or not
2010-11-27 00:02:21 +01:00
bool superspeed = false;
2011-02-06 15:35:27 +01:00
// If free movement and fast movement, always move fast
if(free_move && fast_move)
superspeed = true;
// Auxiliary button 1 (E)
if(control.aux1)
2010-11-27 00:02:21 +01:00
{
2011-02-06 15:35:27 +01:00
if(free_move)
{
2011-02-06 15:35:27 +01:00
// In free movement mode, aux1 descends
v3f speed = getSpeed();
2011-02-06 15:35:27 +01:00
if(fast_move)
speed.Y = -20*BS;
else
speed.Y = -walkspeed_max;
setSpeed(speed);
}
2011-07-31 06:53:05 +02:00
else if(is_climbing)
{
v3f speed = getSpeed();
speed.Y = -3*BS;
setSpeed(speed);
}
else
{
2011-02-06 15:35:27 +01:00
// If not free movement but fast is allowed, aux1 is
2011-01-24 15:36:58 +01:00
// "Turbo button"
2011-02-06 15:35:27 +01:00
if(fast_move)
superspeed = true;
}
2010-11-27 00:02:21 +01:00
}
2011-02-06 15:35:27 +01:00
if(continuous_forward)
speed += move_direction;
2010-11-27 00:02:21 +01:00
if(control.up)
{
2011-02-06 15:35:27 +01:00
if(continuous_forward)
superspeed = true;
else
speed += move_direction;
2010-11-27 00:02:21 +01:00
}
if(control.down)
{
speed -= move_direction;
}
if(control.left)
{
speed += move_direction.crossProduct(v3f(0,1,0));
}
if(control.right)
{
speed += move_direction.crossProduct(v3f(0,-1,0));
}
if(control.jump)
{
2011-02-06 15:35:27 +01:00
if(free_move)
{
v3f speed = getSpeed();
2011-02-06 15:35:27 +01:00
if(fast_move)
speed.Y = 20*BS;
else
speed.Y = walkspeed_max;
setSpeed(speed);
}
else if(touching_ground)
2010-11-30 14:35:03 +01:00
{
2010-11-27 00:02:21 +01:00
v3f speed = getSpeed();
2011-02-14 01:54:15 +01:00
/*
NOTE: The d value in move() affects jump height by
raising the height at which the jump speed is kept
at its starting value
*/
2010-11-27 00:02:21 +01:00
speed.Y = 6.5*BS;
setSpeed(speed);
}
2011-02-08 00:12:55 +01:00
// Use the oscillating value for getting out of water
// (so that the player doesn't fly on the surface)
2010-11-30 14:35:03 +01:00
else if(in_water)
{
v3f speed = getSpeed();
2011-02-08 00:12:55 +01:00
speed.Y = 1.5*BS;
2010-11-30 14:35:03 +01:00
setSpeed(speed);
swimming_up = true;
2010-11-30 14:35:03 +01:00
}
2011-07-31 06:53:05 +02:00
else if(is_climbing)
{
v3f speed = getSpeed();
speed.Y = 3*BS;
2011-07-27 23:38:48 +02:00
setSpeed(speed);
}
}
2010-11-27 00:02:21 +01:00
// The speed of the player (Y is ignored)
if(superspeed)
2011-02-14 01:54:15 +01:00
speed = speed.normalize() * walkspeed_max * 5.0;
else if(control.sneak)
speed = speed.normalize() * walkspeed_max / 3.0;
2010-11-27 00:02:21 +01:00
else
speed = speed.normalize() * walkspeed_max;
f32 inc = walk_acceleration * BS * dtime;
2011-02-06 15:35:27 +01:00
// Faster acceleration if fast and free movement
if(free_move && fast_move)
inc = walk_acceleration * BS * dtime * 10;
2011-02-06 15:35:27 +01:00
2010-11-27 00:02:21 +01:00
// Accelerate to target speed with maximum increment
accelerate(speed, inc);
}
#endif
2010-11-27 00:02:21 +01:00