Mirrorlandia_minetest/minetest
1
0
Fork 1
mirror of https://github.com/minetest/minetest.git synced 2024-11-23 16:13:46 +01:00
Code Issues Packages Projects Releases Wiki Activity

PlayerSAO/LocalPlayer refactor: (#4612)

Browse Source 
* Create UnitSAO, a common part between PlayerSAO & LuaEntitySAO
* Move breath to PlayerSAO & LocalPlayer
* Migrate m_yaw from (Remote)Player & LuaEntitySAO to UnitSAO
* Migrate m_yaw from Player to LocalPlayer for client
* Move some functions outside of player class to PlayerSAO/RemotePlayer or LocalPlayer depending on which class needs it
* Move pitch to LocalPlayer & PlayerSAO
* Move m_position from Player to LocalPlayer
* Move camera_barely_in_ceiling to LocalPlayer as it's used only there
* use PlayerSAO::m_base_position for Server side positions
* remove a unused variable
* ServerActiveObject::setPos now uses const ref
* use ServerEnv::loadPlayer unconditionnaly as it creates RemotePlayer only if it's not already loaded
* Move hp from Player to LocalPlayer
* Move m_hp from LuaEntitySAO to UnitSAO
* Use m_hp from PlayerSAO/UnitSAO instead of RemotePlayer
This commit is contained in:
Ner'zhul 2016-10-30 14:53:26 +01:00 committed by GitHub
parent d43326021a
commit 9d25242c5c
18 changed files with 353 additions and 335 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/clientiface.cpp
View File

@ -29,7 +29,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "environment.h"
#include "map.h"
#include "emerge.h"
#include "serverobject.h" // TODO this is used for cleanup of only
#include "content_sao.h" // TODO this is used for cleanup of only
#include "log.h"
#include "util/srp.h"
@ -82,6 +82,10 @@ void RemoteClient::GetNextBlocks (
if (player == NULL)
return;
PlayerSAO *sao = player->getPlayerSAO();
if (sao == NULL)
return;
// Won't send anything if already sending
if(m_blocks_sending.size() >= g_settings->getU16
("max_simultaneous_block_sends_per_client"))
@ -90,7 +94,7 @@ void RemoteClient::GetNextBlocks (
return;
}
v3f playerpos = player->getPosition();
v3f playerpos = sao->getBasePosition();
v3f playerspeed = player->getSpeed();
v3f playerspeeddir(0,0,0);
if(playerspeed.getLength() > 1.0*BS)
@ -103,10 +107,10 @@ void RemoteClient::GetNextBlocks (
v3s16 center = getNodeBlockPos(center_nodepos);
// Camera position and direction
v3f camera_pos = player->getEyePosition();
v3f camera_pos = sao->getEyePosition();
v3f camera_dir = v3f(0,0,1);
camera_dir.rotateYZBy(player->getPitch());
camera_dir.rotateXZBy(player->getYaw());
camera_dir.rotateYZBy(sao->getPitch());
camera_dir.rotateXZBy(sao->getYaw());
/*infostream<<"camera_dir=("<<camera_dir.X<<","<<camera_dir.Y<<","
<<camera_dir.Z<<")"<<std::endl;*/

2
src/collision.cpp
View File

@ -367,7 +367,7 @@ collisionMoveResult collisionMoveSimple(Environment *env, IGameDef *gamedef,
#endif
{
ServerEnvironment *s_env = dynamic_cast<ServerEnvironment*>(env);
if (s_env != 0) {
if (s_env != NULL) {
f32 distance = speed_f->getLength();
std::vector<u16> s_objects;
s_env->getObjectsInsideRadius(s_objects, *pos_f, distance * 1.5);

155
src/content_sao.cpp
View File

@ -118,14 +118,12 @@ LuaEntitySAO proto_LuaEntitySAO(NULL, v3f(0,0,0), "_prototype", "");
LuaEntitySAO::LuaEntitySAO(ServerEnvironment *env, v3f pos,
const std::string &name, const std::string &state):
ServerActiveObject(env, pos),
UnitSAO(env, pos),
m_init_name(name),
m_init_state(state),
m_registered(false),
m_hp(-1),
m_velocity(0,0,0),
m_acceleration(0,0,0),
m_yaw(0),
m_properties_sent(true),
m_last_sent_yaw(0),
m_last_sent_position(0,0,0),
@ -664,16 +662,6 @@ v3f LuaEntitySAO::getAcceleration()
return m_acceleration;
}
void LuaEntitySAO::setYaw(float yaw)
{
m_yaw = yaw;
}
float LuaEntitySAO::getYaw()
{
return m_yaw;
}
void LuaEntitySAO::setTextureMod(const std::string &mod)
{
std::string str = gob_cmd_set_texture_mod(mod);
@ -762,10 +750,9 @@ bool LuaEntitySAO::collideWithObjects(){
// No prototype, PlayerSAO does not need to be deserialized
PlayerSAO::PlayerSAO(ServerEnvironment *env_, RemotePlayer *player_, u16 peer_id_,
const std::set<std::string> &privs, bool is_singleplayer):
ServerActiveObject(env_, v3f(0,0,0)),
m_player(player_),
PlayerSAO::PlayerSAO(ServerEnvironment *env_, u16 peer_id_, bool is_singleplayer):
UnitSAO(env_, v3f(0,0,0)),
m_player(NULL),
m_peer_id(peer_id_),
m_inventory(NULL),
m_damage(0),
@ -777,7 +764,6 @@ PlayerSAO::PlayerSAO(ServerEnvironment *env_, RemotePlayer *player_, u16 peer_id
m_position_not_sent(false),
m_armor_groups_sent(false),
m_properties_sent(true),
m_privs(privs),
m_is_singleplayer(is_singleplayer),
m_animation_speed(0),
m_animation_blend(0),
@ -786,6 +772,8 @@ PlayerSAO::PlayerSAO(ServerEnvironment *env_, RemotePlayer *player_, u16 peer_id
m_bone_position_sent(false),
m_attachment_parent_id(0),
m_attachment_sent(false),
m_breath(PLAYER_MAX_BREATH),
m_pitch(0),
// public
m_physics_override_speed(1),
m_physics_override_jump(1),
@ -794,10 +782,7 @@ PlayerSAO::PlayerSAO(ServerEnvironment *env_, RemotePlayer *player_, u16 peer_id
m_physics_override_sneak_glitch(true),
m_physics_override_sent(false)
{
assert(m_player); // pre-condition
assert(m_peer_id != 0); // pre-condition
setBasePosition(m_player->getPosition());
m_inventory = &m_player->inventory;
m_armor_groups["fleshy"] = 100;
m_prop.hp_max = PLAYER_MAX_HP;
@ -816,6 +801,7 @@ PlayerSAO::PlayerSAO(ServerEnvironment *env_, RemotePlayer *player_, u16 peer_id
// end of default appearance
m_prop.is_visible = true;
m_prop.makes_footstep_sound = true;
m_hp = PLAYER_MAX_HP;
}
PlayerSAO::~PlayerSAO()
@ -824,6 +810,14 @@ PlayerSAO::~PlayerSAO()
delete m_inventory;
}
void PlayerSAO::initialize(RemotePlayer *player, const std::set<std::string> &privs)
{
assert(player);
m_player = player;
m_privs = privs;
m_inventory = &m_player->inventory;
}
std::string PlayerSAO::getDescription()
{
return std::string("player ") + m_player->getName();
@ -833,10 +827,10 @@ std::string PlayerSAO::getDescription()
void PlayerSAO::addedToEnvironment(u32 dtime_s)
{
ServerActiveObject::addedToEnvironment(dtime_s);
ServerActiveObject::setBasePosition(m_player->getPosition());
ServerActiveObject::setBasePosition(m_base_position);
m_player->setPlayerSAO(this);
m_player->peer_id = m_peer_id;
m_last_good_position = m_player->getPosition();
m_last_good_position = m_base_position;
}
// Called before removing from environment
@ -844,9 +838,9 @@ void PlayerSAO::removingFromEnvironment()
{
ServerActiveObject::removingFromEnvironment();
if (m_player->getPlayerSAO() == this) {
m_player->setPlayerSAO(NULL);
m_player->peer_id = 0;
m_env->savePlayer(m_player);
m_player->setPlayerSAO(NULL);
m_env->removePlayer(m_player);
for (UNORDERED_SET<u32>::iterator it = m_attached_particle_spawners.begin();
it != m_attached_particle_spawners.end(); ++it) {
@ -870,8 +864,8 @@ std::string PlayerSAO::getClientInitializationData(u16 protocol_version)
os<<serializeString(m_player->getName()); // name
writeU8(os, 1); // is_player
writeS16(os, getId()); //id
writeV3F1000(os, m_player->getPosition() + v3f(0,BS*1,0));
writeF1000(os, m_player->getYaw());
writeV3F1000(os, m_base_position + v3f(0,BS*1,0));
writeF1000(os, m_yaw);
writeS16(os, getHP());
writeU8(os, 6 + m_bone_position.size() + m_attachment_child_ids.size()); // number of messages stuffed in here
@ -900,8 +894,8 @@ std::string PlayerSAO::getClientInitializationData(u16 protocol_version)
writeU8(os, 0); // version
os<<serializeString(m_player->getName()); // name
writeU8(os, 1); // is_player
writeV3F1000(os, m_player->getPosition() + v3f(0,BS*1,0));
writeF1000(os, m_player->getYaw());
writeV3F1000(os, m_base_position + v3f(0,BS*1,0));
writeF1000(os, m_yaw);
writeS16(os, getHP());
writeU8(os, 2); // number of messages stuffed in here
os<<serializeLongString(getPropertyPacket()); // message 1
@ -947,7 +941,7 @@ void PlayerSAO::step(float dtime, bool send_recommended)
m_attachment_bone = "";
m_attachment_position = v3f(0,0,0);
m_attachment_rotation = v3f(0,0,0);
m_player->setPosition(m_last_good_position);
setBasePosition(m_last_good_position);
((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id);
}
@ -969,14 +963,13 @@ void PlayerSAO::step(float dtime, bool send_recommended)
// Each frame, parent position is copied if the object is attached, otherwise it's calculated normally
// If the object gets detached this comes into effect automatically from the last known origin
if(isAttached())
{
if (isAttached()) {
v3f pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition();
m_last_good_position = pos;
m_player->setPosition(pos);
setBasePosition(pos);
}
if(send_recommended == false)
if (!send_recommended)
return;
// If the object is attached client-side, don't waste bandwidth sending its position to clients
@ -988,12 +981,12 @@ void PlayerSAO::step(float dtime, bool send_recommended)
if(isAttached()) // Just in case we ever do send attachment position too
pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition();
else
pos = m_player->getPosition() + v3f(0,BS*1,0);
pos = m_base_position + v3f(0,BS*1,0);
std::string str = gob_cmd_update_position(
pos,
v3f(0,0,0),
v3f(0,0,0),
m_player->getYaw(),
m_yaw,
true,
false,
update_interval
@ -1003,7 +996,7 @@ void PlayerSAO::step(float dtime, bool send_recommended)
m_messages_out.push(aom);
}
if(m_armor_groups_sent == false) {
if (!m_armor_groups_sent) {
m_armor_groups_sent = true;
std::string str = gob_cmd_update_armor_groups(
m_armor_groups);
@ -1012,7 +1005,7 @@ void PlayerSAO::step(float dtime, bool send_recommended)
m_messages_out.push(aom);
}
if(m_physics_override_sent == false){
if (!m_physics_override_sent) {
m_physics_override_sent = true;
std::string str = gob_cmd_update_physics_override(m_physics_override_speed,
m_physics_override_jump, m_physics_override_gravity,
@ -1022,7 +1015,7 @@ void PlayerSAO::step(float dtime, bool send_recommended)
m_messages_out.push(aom);
}
if(m_animation_sent == false){
if (!m_animation_sent) {
m_animation_sent = true;
std::string str = gob_cmd_update_animation(
m_animation_range, m_animation_speed, m_animation_blend, m_animation_loop);
@ -1055,16 +1048,20 @@ void PlayerSAO::step(float dtime, bool send_recommended)
void PlayerSAO::setBasePosition(const v3f &position)
{
if (m_player && position != m_base_position)
m_player->setDirty(true);
// This needs to be ran for attachments too
ServerActiveObject::setBasePosition(position);
m_position_not_sent = true;
}
void PlayerSAO::setPos(v3f pos)
void PlayerSAO::setPos(const v3f &pos)
{
if(isAttached())
return;
m_player->setPosition(pos);
setBasePosition(pos);
// Movement caused by this command is always valid
m_last_good_position = pos;
((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id);
@ -1074,22 +1071,34 @@ void PlayerSAO::moveTo(v3f pos, bool continuous)
{
if(isAttached())
return;
m_player->setPosition(pos);
setBasePosition(pos);
// Movement caused by this command is always valid
m_last_good_position = pos;
((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id);
}
void PlayerSAO::setYaw(float yaw)
void PlayerSAO::setYaw(const float yaw, bool send_data)
{
m_player->setYaw(yaw);
((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id);
if (m_player && yaw != m_yaw)
m_player->setDirty(true);
UnitSAO::setYaw(yaw);
// Datas should not be sent at player initialization
if (send_data)
((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id);
}
void PlayerSAO::setPitch(float pitch)
void PlayerSAO::setPitch(const float pitch, bool send_data)
{
m_player->setPitch(pitch);
((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id);
if (m_player && pitch != m_pitch)
m_player->setDirty(true);
m_pitch = pitch;
if (send_data)
((Server*)m_env->getGameDef())->SendMovePlayer(m_peer_id);
}
int PlayerSAO::punch(v3f dir,
@ -1153,15 +1162,10 @@ int PlayerSAO::punch(v3f dir,
return hitparams.wear;
}
void PlayerSAO::rightClick(ServerActiveObject *clicker)
void PlayerSAO::rightClick(ServerActiveObject *)
{
}
s16 PlayerSAO::getHP() const
{
return m_player->hp;
}
s16 PlayerSAO::readDamage()
{
s16 damage = m_damage;
@ -1169,12 +1173,16 @@ s16 PlayerSAO::readDamage()
return damage;
}
void PlayerSAO::setHP(s16 hp)
void PlayerSAO::setHP(s16 hp, bool direct)
{
s16 oldhp = m_player->hp;
if (direct) {
m_hp = hp;
return;
}
s16 hp_change = m_env->getScriptIface()->on_player_hpchange(this,
hp - oldhp);
s16 oldhp = m_hp;
s16 hp_change = m_env->getScriptIface()->on_player_hpchange(this, hp - oldhp);
if (hp_change == 0)
return;
hp = oldhp + hp_change;
@ -1184,11 +1192,11 @@ void PlayerSAO::setHP(s16 hp)
else if (hp > PLAYER_MAX_HP)
hp = PLAYER_MAX_HP;
if(hp < oldhp && g_settings->getBool("enable_damage") == false) {
if (hp < oldhp && !g_settings->getBool("enable_damage")) {
return;
}
m_player->hp = hp;
m_hp = hp;
if (oldhp > hp)
m_damage += (oldhp - hp);
@ -1198,14 +1206,12 @@ void PlayerSAO::setHP(s16 hp)
m_properties_sent = false;
}
u16 PlayerSAO::getBreath() const
void PlayerSAO::setBreath(const u16 breath)
{
return m_player->getBreath();
}
if (m_player && breath != m_breath)
m_player->setDirty(true);
void PlayerSAO::setBreath(u16 breath)
{
m_player->setBreath(breath);
m_breath = breath;
}
void PlayerSAO::setArmorGroups(const ItemGroupList &armor_groups)
@ -1355,7 +1361,7 @@ bool PlayerSAO::checkMovementCheat()
{
if (isAttached() || m_is_singleplayer ||
g_settings->getBool("disable_anticheat")) {
m_last_good_position = m_player->getPosition();
m_last_good_position = m_base_position;
return false;
}
@ -1382,7 +1388,7 @@ bool PlayerSAO::checkMovementCheat()
// Tolerance. The lag pool does this a bit.
//player_max_speed *= 2.5;
v3f diff = (m_player->getPosition() - m_last_good_position);
v3f diff = (m_base_position - m_last_good_position);
float d_vert = diff.Y;
diff.Y = 0;
float d_horiz = diff.getLength();
@ -1392,27 +1398,26 @@ bool PlayerSAO::checkMovementCheat()
required_time = d_vert / player_max_speed; // Moving upwards
if (m_move_pool.grab(required_time)) {
m_last_good_position = m_player->getPosition();
m_last_good_position = m_base_position;
} else {
actionstream << "Player " << m_player->getName()
<< " moved too fast; resetting position"
<< std::endl;
m_player->setPosition(m_last_good_position);
setBasePosition(m_last_good_position);
cheated = true;
}
return cheated;
}
bool PlayerSAO::getCollisionBox(aabb3f *toset) {
//update collision box
*toset = m_player->getCollisionbox();
bool PlayerSAO::getCollisionBox(aabb3f *toset)
{
*toset = aabb3f(-BS * 0.30, 0.0, -BS * 0.30, BS * 0.30, BS * 1.75, BS * 0.30);
toset->MinEdge += m_base_position;
toset->MaxEdge += m_base_position;
return true;
}
bool PlayerSAO::collideWithObjects(){
bool PlayerSAO::collideWithObjects()
{
return true;
}

62
src/content_sao.h
View File

@ -23,12 +23,35 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "serverobject.h"
#include "itemgroup.h"
#include "object_properties.h"
#include "constants.h"
class UnitSAO: public ServerActiveObject
{
public:
UnitSAO(ServerEnvironment *env, v3f pos):
ServerActiveObject(env, pos),
m_hp(-1), m_yaw(0) {}
virtual ~UnitSAO() {}
virtual void setYaw(const float yaw) { m_yaw = yaw; }
float getYaw() const { return m_yaw; };
f32 getRadYaw() const { return m_yaw * core::DEGTORAD; }
// Deprecated
f32 getRadYawDep() const { return (m_yaw + 90.) * core::DEGTORAD; }
s16 getHP() const { return m_hp; }
// Use a function, if isDead can be defined by other conditions
bool isDead() const { return m_hp == 0; }
protected:
s16 m_hp;
float m_yaw;
};
/*
LuaEntitySAO needs some internals exposed.
*/
class LuaEntitySAO : public ServerActiveObject
class LuaEntitySAO : public UnitSAO
{
public:
LuaEntitySAO(ServerEnvironment *env, v3f pos,
@ -74,8 +97,7 @@ public:
v3f getVelocity();
void setAcceleration(v3f acceleration);
v3f getAcceleration();
void setYaw(float yaw);
float getYaw();
void setTextureMod(const std::string &mod);
void setSprite(v2s16 p, int num_frames, float framelength,
bool select_horiz_by_yawpitch);
@ -91,10 +113,9 @@ private:
bool m_registered;
struct ObjectProperties m_prop;
s16 m_hp;
v3f m_velocity;
v3f m_acceleration;
float m_yaw;
ItemGroupList m_armor_groups;
bool m_properties_sent;
@ -158,11 +179,10 @@ public:
class RemotePlayer;
class PlayerSAO : public ServerActiveObject
class PlayerSAO : public UnitSAO
{
public:
PlayerSAO(ServerEnvironment *env_, RemotePlayer *player_, u16 peer_id_,
const std::set<std::string> &privs, bool is_singleplayer);
PlayerSAO(ServerEnvironment *env_, u16 peer_id_, bool is_singleplayer);
~PlayerSAO();
ActiveObjectType getType() const
{ return ACTIVEOBJECT_TYPE_PLAYER; }
@ -182,10 +202,14 @@ public:
bool isAttached();
void step(float dtime, bool send_recommended);
void setBasePosition(const v3f &position);
void setPos(v3f pos);
void setPos(const v3f &pos);
void moveTo(v3f pos, bool continuous);
void setYaw(float);
void setPitch(float);
void setYaw(const float yaw, bool send_data = true);
void setPitch(const float pitch, bool send_data = true);
f32 getPitch() const { return m_pitch; }
f32 getRadPitch() const { return m_pitch * core::DEGTORAD; }
// Deprecated
f32 getRadPitchDep() const { return -1.0 * m_pitch * core::DEGTORAD; }
/*
Interaction interface
@ -196,11 +220,10 @@ public:
ServerActiveObject *puncher,
float time_from_last_punch);
void rightClick(ServerActiveObject *clicker);
s16 getHP() const;
void setHP(s16 hp);
void setHP(s16 hp, bool direct = false);
s16 readDamage();
u16 getBreath() const;
void setBreath(u16 breath);
u16 getBreath() const { return m_breath; }
void setBreath(const u16 breath);
void setArmorGroups(const ItemGroupList &armor_groups);
ItemGroupList getArmorGroups();
void setAnimation(v2f frame_range, float frame_speed, float frame_blend, bool frame_loop);
@ -283,6 +306,11 @@ public:
bool getCollisionBox(aabb3f *toset);
bool collideWithObjects();
void initialize(RemotePlayer *player, const std::set<std::string> &privs);
v3f getEyePosition() const { return m_base_position + getEyeOffset(); }
v3f getEyeOffset() const { return v3f(0, BS * 1.625f, 0); }
private:
std::string getPropertyPacket();
@ -326,8 +354,8 @@ private:
v3f m_attachment_position;
v3f m_attachment_rotation;
bool m_attachment_sent;
u16 m_breath;
f32 m_pitch;
public:
float m_physics_override_speed;
float m_physics_override_jump;

35
src/environment.cpp
View File

@ -608,9 +608,8 @@ void ServerEnvironment::saveLoadedPlayers()
for (std::vector<RemotePlayer *>::iterator it = m_players.begin();
it != m_players.end();
++it) {
RemotePlayer *player = static_cast<RemotePlayer*>(*it);
if (player->checkModified()) {
player->save(players_path, m_gamedef);
if ((*it)->checkModified()) {
(*it)->save(players_path, m_gamedef);
}
}
}
@ -623,7 +622,7 @@ void ServerEnvironment::savePlayer(RemotePlayer *player)
player->save(players_path, m_gamedef);
}
RemotePlayer *ServerEnvironment::loadPlayer(const std::string &playername)
RemotePlayer *ServerEnvironment::loadPlayer(const std::string &playername, PlayerSAO *sao)
{
bool newplayer = false;
bool found = false;
@ -641,7 +640,8 @@ RemotePlayer *ServerEnvironment::loadPlayer(const std::string &playername)
std::ifstream is(path.c_str(), std::ios_base::binary);
if (!is.good())
continue;
player->deSerialize(is, path);
player->deSerialize(is, path, sao);
is.close();
if (player->getName() == playername) {
@ -657,11 +657,13 @@ RemotePlayer *ServerEnvironment::loadPlayer(const std::string &playername)
<< " not found" << std::endl;
if (newplayer)
delete player;
return NULL;
}
if (newplayer)
if (newplayer) {
addPlayer(player);
}
player->setModified(false);
return player;
}
@ -1271,12 +1273,16 @@ void ServerEnvironment::step(float dtime)
i != m_players.end(); ++i) {
RemotePlayer *player = dynamic_cast<RemotePlayer *>(*i);
assert(player);
// Ignore disconnected players
if (player->peer_id == 0)
continue;
PlayerSAO *playersao = player->getPlayerSAO();
assert(playersao);
v3s16 blockpos = getNodeBlockPos(
floatToInt(player->getPosition(), BS));
floatToInt(playersao->getBasePosition(), BS));
players_blockpos.push_back(blockpos);
}
@ -1584,7 +1590,7 @@ u16 ServerEnvironment::addActiveObject(ServerActiveObject *object)
Finds out what new objects have been added to
inside a radius around a position
*/
void ServerEnvironment::getAddedActiveObjects(RemotePlayer *player, s16 radius,
void ServerEnvironment::getAddedActiveObjects(PlayerSAO *playersao, s16 radius,
s16 player_radius,
std::set<u16> &current_objects,
std::queue<u16> &added_objects)
@ -1594,7 +1600,6 @@ void ServerEnvironment::getAddedActiveObjects(RemotePlayer *player, s16 radius,
if (player_radius_f < 0)
player_radius_f = 0;
/*
Go through the object list,
- discard m_removed objects,
@ -1602,20 +1607,21 @@ void ServerEnvironment::getAddedActiveObjects(RemotePlayer *player, s16 radius,
- discard objects that are found in current_objects.
- add remaining objects to added_objects
*/
for(ActiveObjectMap::iterator i = m_active_objects.begin();
for (ActiveObjectMap::iterator i = m_active_objects.begin();
i != m_active_objects.end(); ++i) {
u16 id = i->first;
// Get object
ServerActiveObject *object = i->second;
if(object == NULL)
if (object == NULL)
continue;
// Discard if removed or deactivating
if(object->m_removed || object->m_pending_deactivation)
continue;
f32 distance_f = object->getBasePosition().getDistanceFrom(player->getPosition());
f32 distance_f = object->getBasePosition().
getDistanceFrom(playersao->getBasePosition());
if (object->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
// Discard if too far
if (distance_f > player_radius_f && player_radius_f != 0)
@ -1637,7 +1643,7 @@ void ServerEnvironment::getAddedActiveObjects(RemotePlayer *player, s16 radius,
Finds out what objects have been removed from
inside a radius around a position
*/
void ServerEnvironment::getRemovedActiveObjects(RemotePlayer *player, s16 radius,
void ServerEnvironment::getRemovedActiveObjects(PlayerSAO *playersao, s16 radius,
s16 player_radius,
std::set<u16> &current_objects,
std::queue<u16> &removed_objects)
@ -1647,7 +1653,6 @@ void ServerEnvironment::getRemovedActiveObjects(RemotePlayer *player, s16 radius
if (player_radius_f < 0)
player_radius_f = 0;
/*
Go through current_objects; object is removed if:
- object is not found in m_active_objects (this is actually an
@ -1675,7 +1680,7 @@ void ServerEnvironment::getRemovedActiveObjects(RemotePlayer *player, s16 radius
continue;
}
f32 distance_f = object->getBasePosition().getDistanceFrom(player->getPosition());
f32 distance_f = object->getBasePosition().getDistanceFrom(playersao->getBasePosition());
if (object->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
if (distance_f <= player_radius_f || player_radius_f == 0)
continue;

7
src/environment.h
View File

@ -54,6 +54,7 @@ class ClientMap;
class GameScripting;
class Player;
class RemotePlayer;
class PlayerSAO;
class Environment
{
@ -315,7 +316,7 @@ public:
// Save players
void saveLoadedPlayers();
void savePlayer(RemotePlayer *player);
RemotePlayer *loadPlayer(const std::string &playername);
RemotePlayer *loadPlayer(const std::string &playername, PlayerSAO *sao);
void addPlayer(RemotePlayer *player);
void removePlayer(RemotePlayer *player);
@ -362,7 +363,7 @@ public:
Find out what new objects have been added to
inside a radius around a position
*/
void getAddedActiveObjects(RemotePlayer *player, s16 radius,
void getAddedActiveObjects(PlayerSAO *playersao, s16 radius,
s16 player_radius,
std::set<u16> &current_objects,
std::queue<u16> &added_objects);
@ -371,7 +372,7 @@ public:
Find out what new objects have been removed from
inside a radius around a position
*/
void getRemovedActiveObjects(RemotePlayer *player, s16 radius,
void getRemovedActiveObjects(PlayerSAO *playersao, s16 radius,
s16 player_radius,
std::set<u16> &current_objects,
std::queue<u16> &removed_objects);

7
src/localplayer.cpp
View File

@ -35,6 +35,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
LocalPlayer::LocalPlayer(Client *gamedef, const char *name):
Player(name, gamedef->idef()),
parent(0),
hp(PLAYER_MAX_HP),
got_teleported(false),
isAttached(false),
touching_ground(false),
@ -62,6 +63,7 @@ LocalPlayer::LocalPlayer(Client *gamedef, const char *name):
light_color(255,255,255,255),
hurt_tilt_timer(0.0f),
hurt_tilt_strength(0.0f),
m_position(0,0,0),
m_sneak_node(32767,32767,32767),
m_sneak_node_exists(false),
m_need_to_get_new_sneak_node(true),
@ -69,6 +71,11 @@ LocalPlayer::LocalPlayer(Client *gamedef, const char *name):
m_old_node_below(32767,32767,32767),
m_old_node_below_type("air"),
m_can_jump(false),
m_breath(PLAYER_MAX_BREATH),
m_yaw(0),
m_pitch(0),
camera_barely_in_ceiling(false),
m_collisionbox(-BS * 0.30, 0.0, -BS * 0.30, BS * 0.30, BS * 1.75, BS * 0.30),
m_cao(NULL),
m_gamedef(gamedef)
{

41
src/localplayer.h
View File

@ -40,6 +40,7 @@ public:
ClientActiveObject *parent;
u16 hp;
bool got_teleported;
bool isAttached;
bool touching_ground;
@ -99,10 +100,45 @@ public:
u32 maxHudId() const { return hud.size(); }
u16 getBreath() const { return m_breath; }
void setBreath(u16 breath) { m_breath = breath; }
v3s16 getLightPosition() const
{
return floatToInt(m_position + v3f(0,BS+BS/2,0), BS);
}
void setYaw(f32 yaw)
{
m_yaw = yaw;
}
f32 getYaw() const { return m_yaw; }
void setPitch(f32 pitch)
{
m_pitch = pitch;
}
f32 getPitch() const { return m_pitch; }
void setPosition(const v3f &position)
{
m_position = position;
}
v3f getPosition() const { return m_position; }
v3f getEyePosition() const { return m_position + getEyeOffset(); }
v3f getEyeOffset() const
{
float eye_height = camera_barely_in_ceiling ? 1.5f : 1.625f;
return v3f(0, BS * eye_height, 0);
}
private:
void accelerateHorizontal(const v3f &target_speed, const f32 max_increase);
void accelerateVertical(const v3f &target_speed, const f32 max_increase);
v3f m_position;
// This is used for determining the sneaking range
v3s16 m_sneak_node;
// Whether the player is allowed to sneak
@ -117,6 +153,11 @@ private:
v3s16 m_old_node_below;
std::string m_old_node_below_type;
bool m_can_jump;
u16 m_breath;
f32 m_yaw;
f32 m_pitch;
bool camera_barely_in_ceiling;
aabb3f m_collisionbox;
GenericCAO* m_cao;
Client *m_gamedef;

1
src/network/clientpackethandler.cpp
View File

@ -634,7 +634,6 @@ void Client::handleCommand_AnnounceMedia(NetworkPacket* pkt)
m_media_downloader->addFile(name, sha1_raw);
}
std::vector<std::string> remote_media;
try {
std::string str;

55
src/network/serverpackethandler.cpp
View File

@ -809,13 +809,6 @@ void Server::handleCommand_PlayerPos(NetworkPacket* pkt)
return;
}
// If player is dead we don't care of this packet
if (player->isDead()) {
verbosestream << "TOSERVER_PLAYERPOS: " << player->getName()
<< " is dead. Ignoring packet";
return;
}
PlayerSAO *playersao = player->getPlayerSAO();
if (playersao == NULL) {
errorstream << "Server::ProcessData(): Canceling: "
@ -825,10 +818,17 @@ void Server::handleCommand_PlayerPos(NetworkPacket* pkt)
return;
}
player->setPosition(position);
// If player is dead we don't care of this packet
if (playersao->isDead()) {
verbosestream << "TOSERVER_PLAYERPOS: " << player->getName()
<< " is dead. Ignoring packet";
return;
}
playersao->setBasePosition(position);
player->setSpeed(speed);
player->setPitch(pitch);
player->setYaw(yaw);
playersao->setPitch(pitch, false);
playersao->setYaw(yaw, false);
player->keyPressed = keyPressed;
player->control.up = (keyPressed & 1);
player->control.down = (keyPressed & 2);
@ -1100,7 +1100,7 @@ void Server::handleCommand_Damage(NetworkPacket* pkt)
if (g_settings->getBool("enable_damage")) {
actionstream << player->getName() << " damaged by "
<< (int)damage << " hp at " << PP(player->getPosition() / BS)
<< (int)damage << " hp at " << PP(playersao->getBasePosition() / BS)
<< std::endl;
playersao->setHP(playersao->getHP() - damage);
@ -1124,16 +1124,6 @@ void Server::handleCommand_Breath(NetworkPacket* pkt)
return;
}
/*
* If player is dead, we don't need to update the breath
* He is dead !
*/
if (player->isDead()) {
verbosestream << "TOSERVER_BREATH: " << player->getName()
<< " is dead. Ignoring packet";
return;
}
PlayerSAO *playersao = player->getPlayerSAO();
if (playersao == NULL) {
@ -1144,6 +1134,16 @@ void Server::handleCommand_Breath(NetworkPacket* pkt)
return;
}
/*
* If player is dead, we don't need to update the breath
* He is dead !
*/
if (playersao->isDead()) {
verbosestream << "TOSERVER_BREATH: " << player->getName()
<< " is dead. Ignoring packet";
return;
}
playersao->setBreath(breath);
SendPlayerBreath(pkt->getPeerId());
}
@ -1264,13 +1264,16 @@ void Server::handleCommand_Respawn(NetworkPacket* pkt)
return;
}
if (!player->isDead())
PlayerSAO *playersao = player->getPlayerSAO();
assert(playersao);
if (!playersao->isDead())
return;
RespawnPlayer(pkt->getPeerId());
actionstream << player->getName() << " respawns at "
<< PP(player->getPosition()/BS) << std::endl;
<< PP(playersao->getBasePosition() / BS) << std::endl;
// ActiveObject is added to environment in AsyncRunStep after
// the previous addition has been successfully removed
@ -1322,9 +1325,9 @@ void Server::handleCommand_Interact(NetworkPacket* pkt)
return;
}
if (player->isDead()) {
if (playersao->isDead()) {
verbosestream << "TOSERVER_INTERACT: " << player->getName()
<< " is dead. Ignoring packet";
<< " is dead. Ignoring packet";
return;
}
@ -1455,7 +1458,7 @@ void Server::handleCommand_Interact(NetworkPacket* pkt)
ToolCapabilities toolcap =
punchitem.getToolCapabilities(m_itemdef);
v3f dir = (pointed_object->getBasePosition() -
(player->getPosition() + player->getEyeOffset())
(playersao->getBasePosition() + playersao->getEyeOffset())
).normalize();
float time_from_last_punch =
playersao->resetTimeFromLastPunch();

14
src/player.cpp
View File

@ -30,18 +30,11 @@ with this program; if not, write to the Free Software Foundation, Inc.,
Player::Player(const char *name, IItemDefManager *idef):
camera_barely_in_ceiling(false),
inventory(idef),
hp(PLAYER_MAX_HP),
peer_id(PEER_ID_INEXISTENT),
keyPressed(0),
// protected
m_breath(PLAYER_MAX_BREATH),
m_pitch(0),
m_yaw(0),
m_speed(0,0,0),
m_position(0,0,0),
m_collisionbox(-BS*0.30,0.0,-BS*0.30,BS*0.30,BS*1.75,BS*0.30)
m_speed(0,0,0)
{
strlcpy(m_name, name, PLAYERNAME_SIZE);
@ -90,11 +83,6 @@ Player::~Player()
clearHud();
}
v3s16 Player::getLightPosition() const
{
return floatToInt(m_position + v3f(0,BS+BS/2,0), BS);
}
u32 Player::addHud(HudElement *toadd)
{
MutexAutoLock lock(m_mutex);

50
src/player.h
View File

@ -129,49 +129,7 @@ public:
m_speed = speed;
}
v3f getPosition()
{
return m_position;
}
v3s16 getLightPosition() const;
v3f getEyeOffset()
{
float eye_height = camera_barely_in_ceiling ? 1.5f : 1.625f;
return v3f(0, BS * eye_height, 0);
}
v3f getEyePosition()
{
return m_position + getEyeOffset();
}
virtual void setPosition(const v3f &position)
{
m_position = position;
}
virtual void setPitch(f32 pitch)
{
m_pitch = pitch;
}
virtual void setYaw(f32 yaw)
{
m_yaw = yaw;
}
f32 getPitch() const { return m_pitch; }
f32 getYaw() const { return m_yaw; }
u16 getBreath() const { return m_breath; }
virtual void setBreath(u16 breath) { m_breath = breath; }
f32 getRadPitch() const { return m_pitch * core::DEGTORAD; }
f32 getRadYaw() const { return m_yaw * core::DEGTORAD; }
const char *getName() const { return m_name; }
aabb3f getCollisionbox() const { return m_collisionbox; }
u32 getFreeHudID()
{
@ -183,7 +141,6 @@ public:
return size;
}
bool camera_barely_in_ceiling;
v3f eye_offset_first;
v3f eye_offset_third;
@ -205,8 +162,6 @@ public:
v2s32 local_animations[4];
float local_animation_speed;
u16 hp;
u16 peer_id;
std::string inventory_formspec;
@ -225,12 +180,7 @@ public:
s32 hud_hotbar_itemcount;
protected:
char m_name[PLAYERNAME_SIZE];
u16 m_breath;
f32 m_pitch;
f32 m_yaw;
v3f m_speed;
v3f m_position;
aabb3f m_collisionbox;
std::vector<HudElement *> hud;
private:

66
src/remoteplayer.cpp
View File

@ -96,7 +96,7 @@ void RemotePlayer::save(std::string savedir, IGameDef *gamedef)
infostream << "Failed to open " << path << std::endl;
return;
}
testplayer.deSerialize(is, path);
testplayer.deSerialize(is, path, NULL);
is.close();
if (strcmp(testplayer.getName(), m_name) == 0) {
// Open file and serialize
@ -115,37 +115,46 @@ void RemotePlayer::save(std::string savedir, IGameDef *gamedef)
return;
}
void RemotePlayer::deSerialize(std::istream &is, const std::string &playername)
void RemotePlayer::deSerialize(std::istream &is, const std::string &playername,
PlayerSAO *sao)
{
Settings args;
if (!args.parseConfigLines(is, "PlayerArgsEnd")) {
throw SerializationError("PlayerArgsEnd of player " +
playername + " not found!");
throw SerializationError("PlayerArgsEnd of player " + playername + " not found!");
}
m_dirty = true;
//args.getS32("version"); // Version field value not used
std::string name = args.get("name");
strlcpy(m_name, name.c_str(), PLAYERNAME_SIZE);
setPitch(args.getFloat("pitch"));
setYaw(args.getFloat("yaw"));
setPosition(args.getV3F("position"));
try {
hp = args.getS32("hp");
} catch(SettingNotFoundException &e) {
hp = PLAYER_MAX_HP;
}
try {
m_breath = args.getS32("breath");
} catch(SettingNotFoundException &e) {
m_breath = PLAYER_MAX_BREATH;
if (sao) {
try {
sao->setHP(args.getS32("hp"), true);
} catch(SettingNotFoundException &e) {
sao->setHP(PLAYER_MAX_HP, true);
}
try {
sao->setBasePosition(args.getV3F("position"));
} catch (SettingNotFoundException &e) {}
try {
sao->setPitch(args.getFloat("pitch"), false);
} catch (SettingNotFoundException &e) {}
try {
sao->setYaw(args.getFloat("yaw"), false);
} catch (SettingNotFoundException &e) {}
try {
sao->setBreath(args.getS32("breath"));
} catch (SettingNotFoundException &e) {}
}
inventory.deSerialize(is);
if(inventory.getList("craftpreview") == NULL) {
if (inventory.getList("craftpreview") == NULL) {
// Convert players without craftpreview
inventory.addList("craftpreview", 1);
@ -167,11 +176,14 @@ void RemotePlayer::serialize(std::ostream &os)
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.setS32("breath", m_breath);
if (m_sao) {
args.setS32("hp", m_sao->getHP());
args.setV3F("position", m_sao->getBasePosition());
args.setFloat("pitch", m_sao->getPitch());
args.setFloat("yaw", m_sao->getYaw());
args.setS32("breath", m_sao->getBreath());
}
args.writeLines(os);
@ -180,16 +192,6 @@ void RemotePlayer::serialize(std::ostream &os)
inventory.serialize(os);
}
void RemotePlayer::setPosition(const v3f &position)
{
if (position != m_position)
m_dirty = true;
Player::setPosition(position);
if(m_sao)
m_sao->setBasePosition(position);
}
const RemotePlayerChatResult RemotePlayer::canSendChatMessage()
{
// Rate limit messages

35
src/remoteplayer.h
View File

@ -40,11 +40,10 @@ public:
virtual ~RemotePlayer() {}
void save(std::string savedir, IGameDef *gamedef);
void deSerialize(std::istream &is, const std::string &playername);
void deSerialize(std::istream &is, const std::string &playername, PlayerSAO *sao);
PlayerSAO *getPlayerSAO() { return m_sao; }
void setPlayerSAO(PlayerSAO *sao) { m_sao = sao; }
void setPosition(const v3f &position);
const RemotePlayerChatResult canSendChatMessage();
@ -67,9 +66,6 @@ public:
*ratio = m_day_night_ratio;
}
// Use a function, if isDead can be defined by other conditions
bool isDead() const { return hp == 0; }
void setHotbarImage(const std::string &name)
{
hud_hotbar_image = name;
@ -90,12 +86,6 @@ public:
return hud_hotbar_selected_image;
}
// Deprecated
f32 getRadPitchDep() const { return -1.0 * m_pitch * core::DEGTORAD; }
// Deprecated
f32 getRadYawDep() const { return (m_yaw + 90.) * core::DEGTORAD; }
void setSky(const video::SColor &bgcolor, const std::string &type,
const std::vector<std::string> &params)
{
@ -121,27 +111,6 @@ public:
inventory.setModified(x);
}
virtual void setBreath(u16 breath)
{
if (breath != m_breath)
m_dirty = true;
Player::setBreath(breath);
}
virtual void setPitch(f32 pitch)
{
if (pitch != m_pitch)
m_dirty = true;
Player::setPitch(pitch);
}
virtual void setYaw(f32 yaw)
{
if (yaw != m_yaw)
m_dirty = true;
Player::setYaw(yaw);
}
void setLocalAnimations(v2s32 frames[4], float frame_speed)
{
for (int i = 0; i < 4; i++)
@ -156,6 +125,8 @@ public:
*frame_speed = local_animation_speed;
}
void setDirty(bool dirty) { m_dirty = true; }
u16 protocol_version;
private:
/*

32
src/script/lua_api/l_object.cpp
View File

@ -1013,11 +1013,11 @@ int ObjectRef::l_get_look_dir(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
ObjectRef *ref = checkobject(L, 1);
RemotePlayer *player = getplayer(ref);
if (player == NULL) return 0;
PlayerSAO* co = getplayersao(ref);
if (co == NULL) return 0;
// Do it
float pitch = player->getRadPitchDep();
float yaw = player->getRadYawDep();
float pitch = co->getRadPitchDep();
float yaw = co->getRadYawDep();
v3f v(cos(pitch)*cos(yaw), sin(pitch), cos(pitch)*sin(yaw));
push_v3f(L, v);
return 1;
@ -1033,10 +1033,10 @@ int ObjectRef::l_get_look_pitch(lua_State *L)
"Deprecated call to get_look_pitch, use get_look_vertical instead");
ObjectRef *ref = checkobject(L, 1);
RemotePlayer *player = getplayer(ref);
if (player == NULL) return 0;
PlayerSAO* co = getplayersao(ref);
if (co == NULL) return 0;
// Do it
lua_pushnumber(L, player->getRadPitchDep());
lua_pushnumber(L, co->getRadPitchDep());
return 1;
}
@ -1050,10 +1050,10 @@ int ObjectRef::l_get_look_yaw(lua_State *L)
"Deprecated call to get_look_yaw, use get_look_horizontal instead");
ObjectRef *ref = checkobject(L, 1);
RemotePlayer *player = getplayer(ref);
if (player == NULL) return 0;
PlayerSAO* co = getplayersao(ref);
if (co == NULL) return 0;
// Do it
lua_pushnumber(L, player->getRadYawDep());
lua_pushnumber(L, co->getRadYawDep());
return 1;
}
@ -1062,10 +1062,10 @@ int ObjectRef::l_get_look_vertical(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
ObjectRef *ref = checkobject(L, 1);
RemotePlayer *player = getplayer(ref);
if (player == NULL) return 0;
PlayerSAO* co = getplayersao(ref);
if (co == NULL) return 0;
// Do it
lua_pushnumber(L, player->getRadPitch());
lua_pushnumber(L, co->getRadPitch());
return 1;
}
@ -1074,10 +1074,10 @@ int ObjectRef::l_get_look_horizontal(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
ObjectRef *ref = checkobject(L, 1);
RemotePlayer *player = getplayer(ref);
if (player == NULL) return 0;
PlayerSAO* co = getplayersao(ref);
if (co == NULL) return 0;
// Do it
lua_pushnumber(L, player->getRadYaw());
lua_pushnumber(L, co->getRadYaw());
return 1;
}

71
src/server.cpp
View File

@ -701,11 +701,15 @@ void Server::AsyncRunStep(bool initial_step)
continue;
}
PlayerSAO *playersao = player->getPlayerSAO();
if (playersao == NULL)
continue;
std::queue<u16> removed_objects;
std::queue<u16> added_objects;
m_env->getRemovedActiveObjects(player, radius, player_radius,
m_env->getRemovedActiveObjects(playersao, radius, player_radius,
client->m_known_objects, removed_objects);
m_env->getAddedActiveObjects(player, radius, player_radius,
m_env->getAddedActiveObjects(playersao, radius, player_radius,
client->m_known_objects, added_objects);
// Ignore if nothing happened
@ -1108,7 +1112,7 @@ PlayerSAO* Server::StageTwoClientInit(u16 peer_id)
SendPlayerBreath(peer_id);
// Show death screen if necessary
if (player->isDead())
if (playersao->isDead())
SendDeathscreen(peer_id, false, v3f(0,0,0));
// Note things in chat if not in simple singleplayer mode
@ -1860,18 +1864,18 @@ void Server::SendMovePlayer(u16 peer_id)
DSTACK(FUNCTION_NAME);
RemotePlayer *player = m_env->getPlayer(peer_id);
assert(player);
PlayerSAO *sao = player->getPlayerSAO();
assert(sao);
NetworkPacket pkt(TOCLIENT_MOVE_PLAYER, sizeof(v3f) + sizeof(f32) * 2, peer_id);
pkt << player->getPosition() << player->getPitch() << player->getYaw();
pkt << sao->getBasePosition() << sao->getPitch() << sao->getYaw();
{
v3f pos = player->getPosition();
f32 pitch = player->getPitch();
f32 yaw = player->getYaw();
v3f pos = sao->getBasePosition();
verbosestream << "Server: Sending TOCLIENT_MOVE_PLAYER"
<< " pos=(" << pos.X << "," << pos.Y << "," << pos.Z << ")"
<< " pitch=" << pitch
<< " yaw=" << yaw
<< " pitch=" << sao->getPitch()
<< " yaw=" << sao->getYaw()
<< std::endl;
}
@ -1984,8 +1988,12 @@ s32 Server::playSound(const SimpleSoundSpec &spec,
if (!player)
continue;
PlayerSAO *sao = player->getPlayerSAO();
if (!sao)
continue;
if (pos_exists) {
if(player->getPosition().getDistanceFrom(pos) >
if(sao->getBasePosition().getDistanceFrom(pos) >
params.max_hear_distance)
continue;
}
@ -2044,14 +2052,17 @@ void Server::sendRemoveNode(v3s16 p, u16 ignore_id,
pkt << p;
std::vector<u16> clients = m_clients.getClientIDs();
for(std::vector<u16>::iterator i = clients.begin();
i != clients.end(); ++i) {
for (std::vector<u16>::iterator i = clients.begin(); i != clients.end(); ++i) {
if (far_players) {
// Get player
if (RemotePlayer *player = m_env->getPlayer(*i)) {
PlayerSAO *sao = player->getPlayerSAO();
if (!sao)
continue;
// If player is far away, only set modified blocks not sent
v3f player_pos = player->getPosition();
if(player_pos.getDistanceFrom(p_f) > maxd) {
v3f player_pos = sao->getBasePosition();
if (player_pos.getDistanceFrom(p_f) > maxd) {
far_players->push_back(*i);
continue;
}
@ -2071,14 +2082,16 @@ void Server::sendAddNode(v3s16 p, MapNode n, u16 ignore_id,
v3f p_f = intToFloat(p, BS);
std::vector<u16> clients = m_clients.getClientIDs();
for(std::vector<u16>::iterator i = clients.begin();
i != clients.end(); ++i) {
if(far_players) {
for(std::vector<u16>::iterator i = clients.begin(); i != clients.end(); ++i) {
if (far_players) {
// Get player
if (RemotePlayer *player = m_env->getPlayer(*i)) {
PlayerSAO *sao = player->getPlayerSAO();
if (!sao)
continue;
// If player is far away, only set modified blocks not sent
v3f player_pos = player->getPosition();
v3f player_pos = sao->getBasePosition();
if(player_pos.getDistanceFrom(p_f) > maxd) {
far_players->push_back(*i);
continue;
@ -3426,10 +3439,9 @@ PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id, u16 proto_version
return NULL;
}
// Load player if it isn't already loaded
if (!player) {
player = m_env->loadPlayer(name);
}
// Create a new player active object
PlayerSAO *playersao = new PlayerSAO(m_env, peer_id, isSingleplayer());
player = m_env->loadPlayer(name, playersao);
// Create player if it doesn't exist
if (!player) {
@ -3438,8 +3450,7 @@ PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id, u16 proto_version
// Set player position
infostream<<"Server: Finding spawn place for player \""
<<name<<"\""<<std::endl;
v3f pos = findSpawnPos();
player->setPosition(pos);
playersao->setBasePosition(findSpawnPos());
// Make sure the player is saved
player->setModified(true);
@ -3450,18 +3461,14 @@ PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id, u16 proto_version
// If the player exists, ensure that they respawn inside legal bounds
// This fixes an assert crash when the player can't be added
// to the environment
if (objectpos_over_limit(player->getPosition())) {
if (objectpos_over_limit(playersao->getBasePosition())) {
actionstream << "Respawn position for player \""
<< name << "\" outside limits, resetting" << std::endl;
v3f pos = findSpawnPos();
player->setPosition(pos);
playersao->setBasePosition(findSpawnPos());
}
}
// Create a new player active object
PlayerSAO *playersao = new PlayerSAO(m_env, player, peer_id,
getPlayerEffectivePrivs(player->getName()),
isSingleplayer());
playersao->initialize(player, getPlayerEffectivePrivs(player->getName()));
player->protocol_version = proto_version;

2
src/serverobject.h
View File

@ -85,7 +85,7 @@ public:
Some more dynamic interface
*/
virtual void setPos(v3f pos)
virtual void setPos(const v3f &pos)
{ setBasePosition(pos); }
// continuous: if true, object does not stop immediately at pos
virtual void moveTo(v3f pos, bool continuous)

39
src/unittest/test_player.cpp
View File

@ -46,11 +46,14 @@ void TestPlayer::runTests(IGameDef *gamedef)
void TestPlayer::testSave(IGameDef *gamedef)
{
RemotePlayer rplayer("testplayer_save", gamedef->idef());
rplayer.setBreath(10);
rplayer.hp = 8;
rplayer.setYaw(0.1f);
rplayer.setPitch(0.6f);
rplayer.setPosition(v3f(450.2f, -15.7f, 68.1f));
PlayerSAO sao(NULL, 1, false);
sao.initialize(&rplayer, std::set<std::string>());
rplayer.setPlayerSAO(&sao);
sao.setBreath(10);
sao.setHP(8, true);
sao.setYaw(0.1f, false);
sao.setPitch(0.6f, false);
sao.setBasePosition(v3f(450.2f, -15.7f, 68.1f));
rplayer.save(".", gamedef);
UASSERT(fs::PathExists("testplayer_save"));
}
@ -58,24 +61,28 @@ void TestPlayer::testSave(IGameDef *gamedef)
void TestPlayer::testLoad(IGameDef *gamedef)
{
RemotePlayer rplayer("testplayer_load", gamedef->idef());
rplayer.setBreath(10);
rplayer.hp = 8;
rplayer.setYaw(0.1f);
rplayer.setPitch(0.6f);
rplayer.setPosition(v3f(450.2f, -15.7f, 68.1f));
PlayerSAO sao(NULL, 1, false);
sao.initialize(&rplayer, std::set<std::string>());
rplayer.setPlayerSAO(&sao);
sao.setBreath(10);
sao.setHP(8, true);
sao.setYaw(0.1f, false);
sao.setPitch(0.6f, false);
sao.setBasePosition(v3f(450.2f, -15.7f, 68.1f));
rplayer.save(".", gamedef);
UASSERT(fs::PathExists("testplayer_load"));
RemotePlayer rplayer_load("testplayer_load", gamedef->idef());
PlayerSAO sao_load(NULL, 2, false);
std::ifstream is("testplayer_load", std::ios_base::binary);
UASSERT(is.good());
rplayer_load.deSerialize(is, "testplayer_load");
rplayer_load.deSerialize(is, "testplayer_load", &sao_load);
is.close();
UASSERT(strcmp(rplayer_load.getName(), "testplayer_load") == 0);
UASSERT(rplayer.getBreath() == 10);
UASSERT(rplayer.hp == 8);
UASSERT(rplayer.getYaw() == 0.1f);
UASSERT(rplayer.getPitch() == 0.6f);
UASSERT(rplayer.getPosition() == v3f(450.2f, -15.7f, 68.1f));
UASSERT(sao_load.getBreath() == 10);
UASSERT(sao_load.getHP() == 8);
UASSERT(sao_load.getYaw() == 0.1f);
UASSERT(sao_load.getPitch() == 0.6f);
UASSERT(sao_load.getBasePosition() == v3f(450.2f, -15.7f, 68.1f));
}