2011-06-26 16:48:56 +04:00
|
|
|
/*
|
2013-02-24 21:40:43 +04:00
|
|
|
Minetest
|
2013-02-24 22:38:45 +04:00
|
|
|
Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
|
2011-06-26 16:48:56 +04:00
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
2012-06-05 18:56:56 +04:00
|
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
2011-06-26 16:48:56 +04:00
|
|
|
(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
|
2012-06-05 18:56:56 +04:00
|
|
|
GNU Lesser General Public License for more details.
|
2011-06-26 16:48:56 +04:00
|
|
|
|
2012-06-05 18:56:56 +04:00
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
2011-06-26 16:48:56 +04:00
|
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "content_sao.h"
|
2014-09-12 02:22:05 +04:00
|
|
|
#include "util/serialize.h"
|
2011-06-26 16:48:56 +04:00
|
|
|
#include "collision.h"
|
|
|
|
#include "environment.h"
|
2012-02-28 21:45:23 +04:00
|
|
|
#include "tool.h" // For ToolCapabilities
|
2012-01-12 09:10:39 +04:00
|
|
|
#include "gamedef.h"
|
2017-01-01 18:13:01 +03:00
|
|
|
#include "nodedef.h"
|
2016-10-08 20:08:23 +03:00
|
|
|
#include "remoteplayer.h"
|
2015-03-04 14:19:26 +03:00
|
|
|
#include "server.h"
|
2013-08-11 06:09:45 +04:00
|
|
|
#include "scripting_game.h"
|
2012-03-29 18:46:21 +04:00
|
|
|
#include "genericobject.h"
|
2011-06-26 16:48:56 +04:00
|
|
|
|
2012-12-20 21:19:49 +04:00
|
|
|
std::map<u16, ServerActiveObject::Factory> ServerActiveObject::m_types;
|
2011-07-16 18:39:03 +04:00
|
|
|
|
2011-10-15 03:28:57 +04:00
|
|
|
/*
|
2012-03-04 23:08:03 +04:00
|
|
|
TestSAO
|
2011-10-15 03:28:57 +04:00
|
|
|
*/
|
|
|
|
|
2012-03-04 23:08:03 +04:00
|
|
|
class TestSAO : public ServerActiveObject
|
2011-10-15 03:28:57 +04:00
|
|
|
{
|
2012-03-04 23:08:03 +04:00
|
|
|
public:
|
|
|
|
TestSAO(ServerEnvironment *env, v3f pos):
|
|
|
|
ServerActiveObject(env, pos),
|
|
|
|
m_timer1(0),
|
|
|
|
m_age(0)
|
|
|
|
{
|
|
|
|
ServerActiveObject::registerType(getType(), create);
|
|
|
|
}
|
2015-02-16 19:42:13 +03:00
|
|
|
ActiveObjectType getType() const
|
2012-03-04 23:08:03 +04:00
|
|
|
{ return ACTIVEOBJECT_TYPE_TEST; }
|
2015-01-19 07:29:19 +03:00
|
|
|
|
2012-03-04 23:08:03 +04:00
|
|
|
static ServerActiveObject* create(ServerEnvironment *env, v3f pos,
|
|
|
|
const std::string &data)
|
|
|
|
{
|
|
|
|
return new TestSAO(env, pos);
|
|
|
|
}
|
2011-10-15 03:28:57 +04:00
|
|
|
|
2012-03-04 23:08:03 +04:00
|
|
|
void step(float dtime, bool send_recommended)
|
|
|
|
{
|
|
|
|
m_age += dtime;
|
|
|
|
if(m_age > 10)
|
|
|
|
{
|
|
|
|
m_removed = true;
|
|
|
|
return;
|
|
|
|
}
|
2011-10-15 03:28:57 +04:00
|
|
|
|
2012-03-04 23:08:03 +04:00
|
|
|
m_base_position.Y += dtime * BS * 2;
|
|
|
|
if(m_base_position.Y > 8*BS)
|
|
|
|
m_base_position.Y = 2*BS;
|
2011-10-15 03:28:57 +04:00
|
|
|
|
2012-03-04 23:08:03 +04:00
|
|
|
if(send_recommended == false)
|
|
|
|
return;
|
2011-10-15 03:28:57 +04:00
|
|
|
|
2012-03-04 23:08:03 +04:00
|
|
|
m_timer1 -= dtime;
|
|
|
|
if(m_timer1 < 0.0)
|
|
|
|
{
|
|
|
|
m_timer1 += 0.125;
|
2011-10-15 03:28:57 +04:00
|
|
|
|
2012-03-04 23:08:03 +04:00
|
|
|
std::string data;
|
2011-10-15 03:28:57 +04:00
|
|
|
|
2012-03-04 23:08:03 +04:00
|
|
|
data += itos(0); // 0 = position
|
|
|
|
data += " ";
|
|
|
|
data += itos(m_base_position.X);
|
|
|
|
data += " ";
|
|
|
|
data += itos(m_base_position.Y);
|
|
|
|
data += " ";
|
|
|
|
data += itos(m_base_position.Z);
|
2011-10-15 03:28:57 +04:00
|
|
|
|
2012-03-04 23:08:03 +04:00
|
|
|
ActiveObjectMessage aom(getId(), false, data);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2012-03-04 23:08:03 +04:00
|
|
|
}
|
2011-10-15 03:28:57 +04:00
|
|
|
}
|
|
|
|
|
2017-01-09 22:39:45 +03:00
|
|
|
bool getCollisionBox(aabb3f *toset) const { return false; }
|
|
|
|
bool collideWithObjects() const { return false; }
|
2013-06-14 16:04:46 +04:00
|
|
|
|
2012-03-04 23:08:03 +04:00
|
|
|
private:
|
|
|
|
float m_timer1;
|
|
|
|
float m_age;
|
|
|
|
};
|
2011-10-15 03:28:57 +04:00
|
|
|
|
2012-03-04 23:08:03 +04:00
|
|
|
// Prototype (registers item for deserialization)
|
|
|
|
TestSAO proto_TestSAO(NULL, v3f(0,0,0));
|
2011-10-15 03:28:57 +04:00
|
|
|
|
2017-01-09 22:39:45 +03:00
|
|
|
/*
|
|
|
|
UnitSAO
|
|
|
|
*/
|
|
|
|
|
|
|
|
UnitSAO::UnitSAO(ServerEnvironment *env, v3f pos):
|
|
|
|
ServerActiveObject(env, pos),
|
|
|
|
m_hp(-1),
|
|
|
|
m_yaw(0),
|
|
|
|
m_properties_sent(true),
|
|
|
|
m_armor_groups_sent(false),
|
|
|
|
m_animation_range(0,0),
|
|
|
|
m_animation_speed(0),
|
|
|
|
m_animation_blend(0),
|
|
|
|
m_animation_loop(true),
|
|
|
|
m_animation_sent(false),
|
|
|
|
m_bone_position_sent(false),
|
|
|
|
m_attachment_parent_id(0),
|
|
|
|
m_attachment_sent(false)
|
|
|
|
{
|
|
|
|
// Initialize something to armor groups
|
|
|
|
m_armor_groups["fleshy"] = 100;
|
|
|
|
}
|
2017-01-11 22:25:25 +03:00
|
|
|
|
|
|
|
bool UnitSAO::isAttached() const
|
|
|
|
{
|
|
|
|
if (!m_attachment_parent_id)
|
|
|
|
return false;
|
|
|
|
// Check if the parent still exists
|
|
|
|
ServerActiveObject *obj = m_env->getActiveObject(m_attachment_parent_id);
|
|
|
|
if (obj)
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void UnitSAO::setArmorGroups(const ItemGroupList &armor_groups)
|
|
|
|
{
|
|
|
|
m_armor_groups = armor_groups;
|
|
|
|
m_armor_groups_sent = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
const ItemGroupList &UnitSAO::getArmorGroups()
|
|
|
|
{
|
|
|
|
return m_armor_groups;
|
|
|
|
}
|
|
|
|
|
|
|
|
void UnitSAO::setAnimation(v2f frame_range, float frame_speed, float frame_blend, bool frame_loop)
|
|
|
|
{
|
|
|
|
// store these so they can be updated to clients
|
|
|
|
m_animation_range = frame_range;
|
|
|
|
m_animation_speed = frame_speed;
|
|
|
|
m_animation_blend = frame_blend;
|
|
|
|
m_animation_loop = frame_loop;
|
|
|
|
m_animation_sent = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void UnitSAO::getAnimation(v2f *frame_range, float *frame_speed, float *frame_blend, bool *frame_loop)
|
|
|
|
{
|
|
|
|
*frame_range = m_animation_range;
|
|
|
|
*frame_speed = m_animation_speed;
|
|
|
|
*frame_blend = m_animation_blend;
|
|
|
|
*frame_loop = m_animation_loop;
|
|
|
|
}
|
|
|
|
|
|
|
|
void UnitSAO::setBonePosition(const std::string &bone, v3f position, v3f rotation)
|
|
|
|
{
|
|
|
|
// store these so they can be updated to clients
|
|
|
|
m_bone_position[bone] = core::vector2d<v3f>(position, rotation);
|
|
|
|
m_bone_position_sent = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void UnitSAO::getBonePosition(const std::string &bone, v3f *position, v3f *rotation)
|
|
|
|
{
|
|
|
|
*position = m_bone_position[bone].X;
|
|
|
|
*rotation = m_bone_position[bone].Y;
|
|
|
|
}
|
|
|
|
|
|
|
|
void UnitSAO::setAttachment(int parent_id, const std::string &bone, v3f position, v3f rotation)
|
|
|
|
{
|
|
|
|
// Attachments need to be handled on both the server and client.
|
|
|
|
// If we just attach on the server, we can only copy the position of the parent. Attachments
|
|
|
|
// are still sent to clients at an interval so players might see them lagging, plus we can't
|
|
|
|
// read and attach to skeletal bones.
|
|
|
|
// If we just attach on the client, the server still sees the child at its original location.
|
|
|
|
// This breaks some things so we also give the server the most accurate representation
|
|
|
|
// even if players only see the client changes.
|
|
|
|
|
|
|
|
m_attachment_parent_id = parent_id;
|
|
|
|
m_attachment_bone = bone;
|
|
|
|
m_attachment_position = position;
|
|
|
|
m_attachment_rotation = rotation;
|
|
|
|
m_attachment_sent = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void UnitSAO::getAttachment(int *parent_id, std::string *bone, v3f *position,
|
|
|
|
v3f *rotation)
|
|
|
|
{
|
|
|
|
*parent_id = m_attachment_parent_id;
|
|
|
|
*bone = m_attachment_bone;
|
|
|
|
*position = m_attachment_position;
|
|
|
|
*rotation = m_attachment_rotation;
|
|
|
|
}
|
|
|
|
|
|
|
|
void UnitSAO::addAttachmentChild(int child_id)
|
|
|
|
{
|
|
|
|
m_attachment_child_ids.insert(child_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
void UnitSAO::removeAttachmentChild(int child_id)
|
|
|
|
{
|
|
|
|
m_attachment_child_ids.erase(child_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
const UNORDERED_SET<int> &UnitSAO::getAttachmentChildIds()
|
|
|
|
{
|
|
|
|
return m_attachment_child_ids;
|
|
|
|
}
|
|
|
|
|
|
|
|
ObjectProperties* UnitSAO::accessObjectProperties()
|
|
|
|
{
|
|
|
|
return &m_prop;
|
|
|
|
}
|
|
|
|
|
|
|
|
void UnitSAO::notifyObjectPropertiesModified()
|
|
|
|
{
|
|
|
|
m_properties_sent = false;
|
|
|
|
}
|
|
|
|
|
2011-11-11 21:33:17 +04:00
|
|
|
/*
|
|
|
|
LuaEntitySAO
|
|
|
|
*/
|
|
|
|
|
2012-03-04 23:08:03 +04:00
|
|
|
// Prototype (registers item for deserialization)
|
2011-11-11 21:33:17 +04:00
|
|
|
LuaEntitySAO proto_LuaEntitySAO(NULL, v3f(0,0,0), "_prototype", "");
|
|
|
|
|
|
|
|
LuaEntitySAO::LuaEntitySAO(ServerEnvironment *env, v3f pos,
|
|
|
|
const std::string &name, const std::string &state):
|
2016-10-30 16:53:26 +03:00
|
|
|
UnitSAO(env, pos),
|
2011-11-11 21:33:17 +04:00
|
|
|
m_init_name(name),
|
|
|
|
m_init_state(state),
|
2011-11-12 05:21:40 +04:00
|
|
|
m_registered(false),
|
2011-11-21 13:15:15 +04:00
|
|
|
m_velocity(0,0,0),
|
|
|
|
m_acceleration(0,0,0),
|
2011-11-12 13:59:56 +04:00
|
|
|
m_last_sent_yaw(0),
|
2011-11-12 14:12:15 +04:00
|
|
|
m_last_sent_position(0,0,0),
|
2011-11-21 16:36:21 +04:00
|
|
|
m_last_sent_velocity(0,0,0),
|
2011-11-12 15:59:56 +04:00
|
|
|
m_last_sent_position_timer(0),
|
2017-01-14 21:32:10 +03:00
|
|
|
m_last_sent_move_precision(0),
|
|
|
|
m_current_texture_modifier("")
|
2011-11-11 21:33:17 +04:00
|
|
|
{
|
2011-11-12 05:21:40 +04:00
|
|
|
// Only register type if no environment supplied
|
2011-11-11 21:33:17 +04:00
|
|
|
if(env == NULL){
|
|
|
|
ServerActiveObject::registerType(getType(), create);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
LuaEntitySAO::~LuaEntitySAO()
|
|
|
|
{
|
|
|
|
if(m_registered){
|
2013-08-11 06:09:45 +04:00
|
|
|
m_env->getScriptIface()->luaentity_Remove(m_id);
|
2011-11-11 21:33:17 +04:00
|
|
|
}
|
2016-08-04 23:09:21 +03:00
|
|
|
|
|
|
|
for (UNORDERED_SET<u32>::iterator it = m_attached_particle_spawners.begin();
|
|
|
|
it != m_attached_particle_spawners.end(); ++it) {
|
|
|
|
m_env->deleteParticleSpawner(*it, false);
|
|
|
|
}
|
2011-11-11 21:33:17 +04:00
|
|
|
}
|
|
|
|
|
2012-09-09 18:12:29 +04:00
|
|
|
void LuaEntitySAO::addedToEnvironment(u32 dtime_s)
|
2011-11-11 21:33:17 +04:00
|
|
|
{
|
2012-09-09 18:12:29 +04:00
|
|
|
ServerActiveObject::addedToEnvironment(dtime_s);
|
2015-01-19 07:29:19 +03:00
|
|
|
|
2012-03-10 03:38:48 +04:00
|
|
|
// Create entity from name
|
2013-08-11 06:09:45 +04:00
|
|
|
m_registered = m_env->getScriptIface()->
|
|
|
|
luaentity_Add(m_id, m_init_name.c_str());
|
2015-01-19 07:29:19 +03:00
|
|
|
|
2011-11-12 20:34:04 +04:00
|
|
|
if(m_registered){
|
|
|
|
// Get properties
|
2013-08-11 06:09:45 +04:00
|
|
|
m_env->getScriptIface()->
|
|
|
|
luaentity_GetProperties(m_id, &m_prop);
|
2012-03-10 03:38:48 +04:00
|
|
|
// Initialize HP from properties
|
2012-03-30 13:51:51 +04:00
|
|
|
m_hp = m_prop.hp_max;
|
2012-04-09 00:13:27 +04:00
|
|
|
// Activate entity, supplying serialized state
|
2013-08-11 06:09:45 +04:00
|
|
|
m_env->getScriptIface()->
|
|
|
|
luaentity_Activate(m_id, m_init_state.c_str(), dtime_s);
|
2016-08-11 01:22:32 +03:00
|
|
|
} else {
|
|
|
|
m_prop.infotext = m_init_name;
|
2011-11-12 20:34:04 +04:00
|
|
|
}
|
2011-11-11 21:33:17 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
ServerActiveObject* LuaEntitySAO::create(ServerEnvironment *env, v3f pos,
|
|
|
|
const std::string &data)
|
|
|
|
{
|
2012-03-04 23:08:03 +04:00
|
|
|
std::string name;
|
|
|
|
std::string state;
|
|
|
|
s16 hp = 1;
|
|
|
|
v3f velocity;
|
|
|
|
float yaw = 0;
|
2012-03-10 03:38:48 +04:00
|
|
|
if(data != ""){
|
|
|
|
std::istringstream is(data, std::ios::binary);
|
|
|
|
// read version
|
|
|
|
u8 version = readU8(is);
|
|
|
|
// check if version is supported
|
|
|
|
if(version == 0){
|
|
|
|
name = deSerializeString(is);
|
|
|
|
state = deSerializeLongString(is);
|
|
|
|
}
|
|
|
|
else if(version == 1){
|
|
|
|
name = deSerializeString(is);
|
|
|
|
state = deSerializeLongString(is);
|
|
|
|
hp = readS16(is);
|
|
|
|
velocity = readV3F1000(is);
|
|
|
|
yaw = readF1000(is);
|
|
|
|
}
|
2012-03-04 23:08:03 +04:00
|
|
|
}
|
2011-11-11 21:33:17 +04:00
|
|
|
// create object
|
|
|
|
infostream<<"LuaEntitySAO::create(name=\""<<name<<"\" state=\""
|
|
|
|
<<state<<"\")"<<std::endl;
|
2012-03-04 23:08:03 +04:00
|
|
|
LuaEntitySAO *sao = new LuaEntitySAO(env, pos, name, state);
|
|
|
|
sao->m_hp = hp;
|
|
|
|
sao->m_velocity = velocity;
|
|
|
|
sao->m_yaw = yaw;
|
|
|
|
return sao;
|
2011-11-11 21:33:17 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void LuaEntitySAO::step(float dtime, bool send_recommended)
|
|
|
|
{
|
2012-03-29 18:46:21 +04:00
|
|
|
if(!m_properties_sent)
|
|
|
|
{
|
|
|
|
m_properties_sent = true;
|
|
|
|
std::string str = getPropertyPacket();
|
|
|
|
// create message and add to list
|
|
|
|
ActiveObjectMessage aom(getId(), true, str);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2012-03-29 18:46:21 +04:00
|
|
|
}
|
|
|
|
|
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly.
Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed)
Fix a bug in falling code where entities get stuck
Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed.
Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need
Create a separate function for detaching, and also update lua api documentation
When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct
Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too)
Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 20:42:38 +04:00
|
|
|
// If attached, check that our parent is still there. If it isn't, detach.
|
|
|
|
if(m_attachment_parent_id && !isAttached())
|
|
|
|
{
|
|
|
|
m_attachment_parent_id = 0;
|
|
|
|
m_attachment_bone = "";
|
|
|
|
m_attachment_position = v3f(0,0,0);
|
|
|
|
m_attachment_rotation = v3f(0,0,0);
|
|
|
|
sendPosition(false, true);
|
|
|
|
}
|
|
|
|
|
2011-11-12 14:12:15 +04:00
|
|
|
m_last_sent_position_timer += dtime;
|
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly.
Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed)
Fix a bug in falling code where entities get stuck
Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed.
Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need
Create a separate function for detaching, and also update lua api documentation
When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct
Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too)
Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 20:42:38 +04:00
|
|
|
|
2012-10-28 19:07:11 +04:00
|
|
|
// 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
|
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly.
Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed)
Fix a bug in falling code where entities get stuck
Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed.
Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need
Create a separate function for detaching, and also update lua api documentation
When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct
Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too)
Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 20:42:38 +04:00
|
|
|
if(isAttached())
|
2012-10-27 16:14:24 +04:00
|
|
|
{
|
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly.
Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed)
Fix a bug in falling code where entities get stuck
Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed.
Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need
Create a separate function for detaching, and also update lua api documentation
When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct
Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too)
Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 20:42:38 +04:00
|
|
|
v3f pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition();
|
2012-10-28 19:07:11 +04:00
|
|
|
m_base_position = pos;
|
2012-10-27 16:14:24 +04:00
|
|
|
m_velocity = v3f(0,0,0);
|
|
|
|
m_acceleration = v3f(0,0,0);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if(m_prop.physical){
|
2016-02-11 17:21:21 +03:00
|
|
|
aabb3f box = m_prop.collisionbox;
|
2012-10-27 16:14:24 +04:00
|
|
|
box.MinEdge *= BS;
|
|
|
|
box.MaxEdge *= BS;
|
|
|
|
collisionMoveResult moveresult;
|
|
|
|
f32 pos_max_d = BS*0.25; // Distance per iteration
|
|
|
|
v3f p_pos = m_base_position;
|
|
|
|
v3f p_velocity = m_velocity;
|
|
|
|
v3f p_acceleration = m_acceleration;
|
2017-01-09 22:39:22 +03:00
|
|
|
moveresult = collisionMoveSimple(m_env, m_env->getGameDef(),
|
2013-07-22 20:54:30 +04:00
|
|
|
pos_max_d, box, m_prop.stepheight, dtime,
|
2016-01-25 02:06:01 +03:00
|
|
|
&p_pos, &p_velocity, p_acceleration,
|
2013-06-14 16:04:46 +04:00
|
|
|
this, m_prop.collideWithObjects);
|
2013-07-22 20:54:30 +04:00
|
|
|
|
2012-10-27 16:14:24 +04:00
|
|
|
// Apply results
|
|
|
|
m_base_position = p_pos;
|
|
|
|
m_velocity = p_velocity;
|
|
|
|
m_acceleration = p_acceleration;
|
|
|
|
} else {
|
|
|
|
m_base_position += dtime * m_velocity + 0.5 * dtime
|
|
|
|
* dtime * m_acceleration;
|
|
|
|
m_velocity += dtime * m_acceleration;
|
|
|
|
}
|
2013-07-31 19:29:25 +04:00
|
|
|
|
2013-08-18 17:49:09 +04:00
|
|
|
if((m_prop.automatic_face_movement_dir) &&
|
2015-12-15 02:03:18 +03:00
|
|
|
(fabs(m_velocity.Z) > 0.001 || fabs(m_velocity.X) > 0.001))
|
|
|
|
{
|
|
|
|
float optimal_yaw = atan2(m_velocity.Z,m_velocity.X) * 180 / M_PI
|
|
|
|
+ m_prop.automatic_face_movement_dir_offset;
|
|
|
|
float max_rotation_delta =
|
|
|
|
dtime * m_prop.automatic_face_movement_max_rotation_per_sec;
|
|
|
|
|
|
|
|
if ((m_prop.automatic_face_movement_max_rotation_per_sec > 0) &&
|
|
|
|
(fabs(m_yaw - optimal_yaw) > max_rotation_delta)) {
|
|
|
|
|
|
|
|
m_yaw = optimal_yaw < m_yaw ? m_yaw - max_rotation_delta : m_yaw + max_rotation_delta;
|
|
|
|
} else {
|
|
|
|
m_yaw = optimal_yaw;
|
|
|
|
}
|
2013-07-31 19:29:25 +04:00
|
|
|
}
|
2011-11-21 16:36:21 +04:00
|
|
|
}
|
2011-11-21 13:15:15 +04:00
|
|
|
|
2011-11-11 21:33:17 +04:00
|
|
|
if(m_registered){
|
2013-08-11 06:09:45 +04:00
|
|
|
m_env->getScriptIface()->luaentity_Step(m_id, dtime);
|
2011-11-11 21:33:17 +04:00
|
|
|
}
|
2011-11-12 13:59:56 +04:00
|
|
|
|
|
|
|
if(send_recommended == false)
|
|
|
|
return;
|
2012-10-28 19:07:11 +04:00
|
|
|
|
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly.
Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed)
Fix a bug in falling code where entities get stuck
Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed.
Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need
Create a separate function for detaching, and also update lua api documentation
When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct
Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too)
Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 20:42:38 +04:00
|
|
|
if(!isAttached())
|
2012-10-28 19:07:11 +04:00
|
|
|
{
|
|
|
|
// TODO: force send when acceleration changes enough?
|
|
|
|
float minchange = 0.2*BS;
|
|
|
|
if(m_last_sent_position_timer > 1.0){
|
|
|
|
minchange = 0.01*BS;
|
|
|
|
} else if(m_last_sent_position_timer > 0.2){
|
|
|
|
minchange = 0.05*BS;
|
|
|
|
}
|
|
|
|
float move_d = m_base_position.getDistanceFrom(m_last_sent_position);
|
|
|
|
move_d += m_last_sent_move_precision;
|
|
|
|
float vel_d = m_velocity.getDistanceFrom(m_last_sent_velocity);
|
|
|
|
if(move_d > minchange || vel_d > minchange ||
|
|
|
|
fabs(m_yaw - m_last_sent_yaw) > 1.0){
|
|
|
|
sendPosition(true, false);
|
|
|
|
}
|
2011-11-12 13:59:56 +04:00
|
|
|
}
|
2012-03-09 22:46:56 +04:00
|
|
|
|
|
|
|
if(m_armor_groups_sent == false){
|
|
|
|
m_armor_groups_sent = true;
|
2012-03-29 18:46:21 +04:00
|
|
|
std::string str = gob_cmd_update_armor_groups(
|
|
|
|
m_armor_groups);
|
2012-03-09 22:46:56 +04:00
|
|
|
// create message and add to list
|
2012-03-29 18:46:21 +04:00
|
|
|
ActiveObjectMessage aom(getId(), true, str);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2012-03-09 22:46:56 +04:00
|
|
|
}
|
2012-11-04 16:33:30 +04:00
|
|
|
|
2012-11-12 18:35:10 +04:00
|
|
|
if(m_animation_sent == false){
|
|
|
|
m_animation_sent = true;
|
2015-02-22 00:38:53 +03:00
|
|
|
std::string str = gob_cmd_update_animation(
|
|
|
|
m_animation_range, m_animation_speed, m_animation_blend, m_animation_loop);
|
2012-11-04 16:33:30 +04:00
|
|
|
// create message and add to list
|
|
|
|
ActiveObjectMessage aom(getId(), true, str);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2012-11-04 16:33:30 +04:00
|
|
|
}
|
|
|
|
|
2012-11-12 18:35:10 +04:00
|
|
|
if(m_bone_position_sent == false){
|
|
|
|
m_bone_position_sent = true;
|
2016-10-06 20:20:12 +03:00
|
|
|
for (UNORDERED_MAP<std::string, core::vector2d<v3f> >::const_iterator
|
|
|
|
ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii){
|
|
|
|
std::string str = gob_cmd_update_bone_position((*ii).first,
|
|
|
|
(*ii).second.X, (*ii).second.Y);
|
2012-11-04 16:33:30 +04:00
|
|
|
// create message and add to list
|
|
|
|
ActiveObjectMessage aom(getId(), true, str);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2012-11-04 16:33:30 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if(m_attachment_sent == false){
|
|
|
|
m_attachment_sent = true;
|
2012-11-05 01:54:50 +04:00
|
|
|
std::string str = gob_cmd_update_attachment(m_attachment_parent_id, m_attachment_bone, m_attachment_position, m_attachment_rotation);
|
2012-11-04 16:33:30 +04:00
|
|
|
// create message and add to list
|
|
|
|
ActiveObjectMessage aom(getId(), true, str);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2012-11-04 16:33:30 +04:00
|
|
|
}
|
2011-11-11 21:33:17 +04:00
|
|
|
}
|
|
|
|
|
2012-11-27 02:47:03 +04:00
|
|
|
std::string LuaEntitySAO::getClientInitializationData(u16 protocol_version)
|
2011-11-11 21:33:17 +04:00
|
|
|
{
|
|
|
|
std::ostringstream os(std::ios::binary);
|
2012-11-05 01:54:50 +04:00
|
|
|
|
2012-11-27 02:47:03 +04:00
|
|
|
if(protocol_version >= 14)
|
|
|
|
{
|
|
|
|
writeU8(os, 1); // version
|
|
|
|
os<<serializeString(""); // name
|
|
|
|
writeU8(os, 0); // is_player
|
|
|
|
writeS16(os, getId()); //id
|
|
|
|
writeV3F1000(os, m_base_position);
|
|
|
|
writeF1000(os, m_yaw);
|
|
|
|
writeS16(os, m_hp);
|
|
|
|
|
2016-11-10 15:42:49 +03:00
|
|
|
std::ostringstream msg_os(std::ios::binary);
|
|
|
|
msg_os << serializeLongString(getPropertyPacket()); // message 1
|
|
|
|
msg_os << serializeLongString(gob_cmd_update_armor_groups(m_armor_groups)); // 2
|
|
|
|
msg_os << serializeLongString(gob_cmd_update_animation(
|
2015-02-22 00:38:53 +03:00
|
|
|
m_animation_range, m_animation_speed, m_animation_blend, m_animation_loop)); // 3
|
2016-10-06 20:20:12 +03:00
|
|
|
for (UNORDERED_MAP<std::string, core::vector2d<v3f> >::const_iterator
|
|
|
|
ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii) {
|
2016-11-10 15:42:49 +03:00
|
|
|
msg_os << serializeLongString(gob_cmd_update_bone_position((*ii).first,
|
2016-10-06 20:20:12 +03:00
|
|
|
(*ii).second.X, (*ii).second.Y)); // m_bone_position.size
|
2012-11-27 02:47:03 +04:00
|
|
|
}
|
2016-11-10 15:42:49 +03:00
|
|
|
msg_os << serializeLongString(gob_cmd_update_attachment(m_attachment_parent_id,
|
|
|
|
m_attachment_bone, m_attachment_position, m_attachment_rotation)); // 4
|
|
|
|
int message_count = 4 + m_bone_position.size();
|
2016-10-08 20:08:23 +03:00
|
|
|
for (UNORDERED_SET<int>::const_iterator ii = m_attachment_child_ids.begin();
|
2016-10-08 15:51:25 +03:00
|
|
|
(ii != m_attachment_child_ids.end()); ++ii) {
|
|
|
|
if (ServerActiveObject *obj = m_env->getActiveObject(*ii)) {
|
2016-11-10 15:42:49 +03:00
|
|
|
message_count++;
|
|
|
|
msg_os << serializeLongString(gob_cmd_update_infant(*ii, obj->getSendType(),
|
|
|
|
obj->getClientInitializationData(protocol_version)));
|
2016-10-08 15:51:25 +03:00
|
|
|
}
|
|
|
|
}
|
2016-11-10 15:42:49 +03:00
|
|
|
|
2017-01-14 21:32:10 +03:00
|
|
|
msg_os << serializeLongString(gob_cmd_set_texture_mod(m_current_texture_modifier));
|
|
|
|
message_count++;
|
|
|
|
|
2016-11-10 15:42:49 +03:00
|
|
|
writeU8(os, message_count);
|
|
|
|
os.write(msg_os.str().c_str(), msg_os.str().size());
|
2012-11-27 02:47:03 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
writeU8(os, 0); // version
|
|
|
|
os<<serializeString(""); // name
|
|
|
|
writeU8(os, 0); // is_player
|
|
|
|
writeV3F1000(os, m_base_position);
|
|
|
|
writeF1000(os, m_yaw);
|
|
|
|
writeS16(os, m_hp);
|
|
|
|
writeU8(os, 2); // number of messages stuffed in here
|
|
|
|
os<<serializeLongString(getPropertyPacket()); // message 1
|
|
|
|
os<<serializeLongString(gob_cmd_update_armor_groups(m_armor_groups)); // 2
|
2012-11-05 01:54:50 +04:00
|
|
|
}
|
|
|
|
|
2011-11-12 12:39:44 +04:00
|
|
|
// return result
|
2011-11-11 21:33:17 +04:00
|
|
|
return os.str();
|
|
|
|
}
|
|
|
|
|
2017-01-12 00:48:14 +03:00
|
|
|
void LuaEntitySAO::getStaticData(std::string *result) const
|
2011-11-11 21:33:17 +04:00
|
|
|
{
|
2015-10-14 09:39:30 +03:00
|
|
|
verbosestream<<FUNCTION_NAME<<std::endl;
|
2011-11-11 21:33:17 +04:00
|
|
|
std::ostringstream os(std::ios::binary);
|
|
|
|
// version
|
2012-03-04 23:08:03 +04:00
|
|
|
writeU8(os, 1);
|
2011-11-11 21:33:17 +04:00
|
|
|
// name
|
|
|
|
os<<serializeString(m_init_name);
|
|
|
|
// state
|
2011-11-11 22:50:09 +04:00
|
|
|
if(m_registered){
|
2013-08-11 06:09:45 +04:00
|
|
|
std::string state = m_env->getScriptIface()->
|
|
|
|
luaentity_GetStaticdata(m_id);
|
2011-11-11 22:50:09 +04:00
|
|
|
os<<serializeLongString(state);
|
|
|
|
} else {
|
|
|
|
os<<serializeLongString(m_init_state);
|
|
|
|
}
|
2012-03-04 23:08:03 +04:00
|
|
|
// hp
|
|
|
|
writeS16(os, m_hp);
|
|
|
|
// velocity
|
|
|
|
writeV3F1000(os, m_velocity);
|
|
|
|
// yaw
|
|
|
|
writeF1000(os, m_yaw);
|
2017-01-12 00:48:14 +03:00
|
|
|
*result = os.str();
|
2011-11-11 21:33:17 +04:00
|
|
|
}
|
|
|
|
|
2012-03-04 23:08:03 +04:00
|
|
|
int LuaEntitySAO::punch(v3f dir,
|
|
|
|
const ToolCapabilities *toolcap,
|
|
|
|
ServerActiveObject *puncher,
|
|
|
|
float time_from_last_punch)
|
2011-11-12 04:25:30 +04:00
|
|
|
{
|
2015-03-11 22:52:47 +03:00
|
|
|
if (!m_registered){
|
2011-12-04 18:25:27 +04:00
|
|
|
// Delete unknown LuaEntities when punched
|
|
|
|
m_removed = true;
|
2012-03-04 23:08:03 +04:00
|
|
|
return 0;
|
2011-12-04 18:25:27 +04:00
|
|
|
}
|
2012-10-27 16:14:24 +04:00
|
|
|
|
2015-01-19 07:29:19 +03:00
|
|
|
// It's best that attachments cannot be punched
|
2015-03-11 22:52:47 +03:00
|
|
|
if (isAttached())
|
2012-10-27 16:14:24 +04:00
|
|
|
return 0;
|
2015-01-19 07:29:19 +03:00
|
|
|
|
2012-03-05 03:30:55 +04:00
|
|
|
ItemStack *punchitem = NULL;
|
|
|
|
ItemStack punchitem_static;
|
2015-03-11 22:52:47 +03:00
|
|
|
if (puncher) {
|
2012-03-05 03:30:55 +04:00
|
|
|
punchitem_static = puncher->getWieldedItem();
|
|
|
|
punchitem = &punchitem_static;
|
|
|
|
}
|
2012-03-04 23:08:03 +04:00
|
|
|
|
2012-03-05 03:30:55 +04:00
|
|
|
PunchDamageResult result = getPunchDamage(
|
|
|
|
m_armor_groups,
|
|
|
|
toolcap,
|
|
|
|
punchitem,
|
2012-03-04 23:08:03 +04:00
|
|
|
time_from_last_punch);
|
2015-01-19 07:29:19 +03:00
|
|
|
|
2015-03-11 22:52:47 +03:00
|
|
|
if (result.did_punch) {
|
2012-03-10 01:53:25 +04:00
|
|
|
setHP(getHP() - result.damage);
|
2015-01-19 07:29:19 +03:00
|
|
|
|
2015-03-11 22:52:47 +03:00
|
|
|
if (result.damage > 0) {
|
|
|
|
std::string punchername = puncher ? puncher->getDescription() : "nil";
|
2013-05-05 03:44:55 +04:00
|
|
|
|
2015-03-11 22:52:47 +03:00
|
|
|
actionstream << getDescription() << " punched by "
|
|
|
|
<< punchername << ", damage " << result.damage
|
|
|
|
<< " hp, health now " << getHP() << " hp" << std::endl;
|
2012-03-05 03:30:55 +04:00
|
|
|
}
|
2012-03-10 03:38:48 +04:00
|
|
|
|
2015-03-11 22:52:47 +03:00
|
|
|
std::string str = gob_cmd_punched(result.damage, getHP());
|
|
|
|
// create message and add to list
|
|
|
|
ActiveObjectMessage aom(getId(), true, str);
|
|
|
|
m_messages_out.push(aom);
|
2012-03-04 23:08:03 +04:00
|
|
|
}
|
|
|
|
|
2015-03-11 22:52:47 +03:00
|
|
|
if (getHP() == 0)
|
|
|
|
m_removed = true;
|
|
|
|
|
2013-08-11 06:09:45 +04:00
|
|
|
m_env->getScriptIface()->luaentity_Punch(m_id, puncher,
|
2012-03-05 03:30:55 +04:00
|
|
|
time_from_last_punch, toolcap, dir);
|
|
|
|
|
|
|
|
return result.wear;
|
2011-11-12 04:25:30 +04:00
|
|
|
}
|
|
|
|
|
2011-11-12 19:37:14 +04:00
|
|
|
void LuaEntitySAO::rightClick(ServerActiveObject *clicker)
|
2011-11-12 04:25:30 +04:00
|
|
|
{
|
2015-03-11 22:52:47 +03:00
|
|
|
if (!m_registered)
|
2011-11-12 04:25:30 +04:00
|
|
|
return;
|
2012-11-09 23:51:45 +04:00
|
|
|
// It's best that attachments cannot be clicked
|
2015-03-11 22:52:47 +03:00
|
|
|
if (isAttached())
|
2012-11-09 23:51:45 +04:00
|
|
|
return;
|
2013-08-11 06:09:45 +04:00
|
|
|
m_env->getScriptIface()->luaentity_Rightclick(m_id, clicker);
|
2011-11-12 04:25:30 +04:00
|
|
|
}
|
2011-11-11 21:33:17 +04:00
|
|
|
|
2016-10-30 18:12:09 +03:00
|
|
|
void LuaEntitySAO::setPos(const v3f &pos)
|
2011-11-12 13:59:56 +04:00
|
|
|
{
|
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly.
Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed)
Fix a bug in falling code where entities get stuck
Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed.
Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need
Create a separate function for detaching, and also update lua api documentation
When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct
Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too)
Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 20:42:38 +04:00
|
|
|
if(isAttached())
|
2012-10-27 16:14:24 +04:00
|
|
|
return;
|
2011-11-12 13:59:56 +04:00
|
|
|
m_base_position = pos;
|
2011-11-12 15:14:44 +04:00
|
|
|
sendPosition(false, true);
|
2011-11-12 13:59:56 +04:00
|
|
|
}
|
|
|
|
|
2011-11-12 15:59:56 +04:00
|
|
|
void LuaEntitySAO::moveTo(v3f pos, bool continuous)
|
2011-11-12 13:59:56 +04:00
|
|
|
{
|
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly.
Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed)
Fix a bug in falling code where entities get stuck
Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed.
Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need
Create a separate function for detaching, and also update lua api documentation
When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct
Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too)
Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 20:42:38 +04:00
|
|
|
if(isAttached())
|
2012-10-27 16:14:24 +04:00
|
|
|
return;
|
2011-11-12 13:59:56 +04:00
|
|
|
m_base_position = pos;
|
2011-11-12 15:59:56 +04:00
|
|
|
if(!continuous)
|
|
|
|
sendPosition(true, true);
|
2011-11-12 13:59:56 +04:00
|
|
|
}
|
|
|
|
|
2011-11-12 17:14:24 +04:00
|
|
|
float LuaEntitySAO::getMinimumSavedMovement()
|
|
|
|
{
|
|
|
|
return 0.1 * BS;
|
|
|
|
}
|
|
|
|
|
2012-03-04 23:08:03 +04:00
|
|
|
std::string LuaEntitySAO::getDescription()
|
|
|
|
{
|
|
|
|
std::ostringstream os(std::ios::binary);
|
|
|
|
os<<"LuaEntitySAO at (";
|
|
|
|
os<<(m_base_position.X/BS)<<",";
|
|
|
|
os<<(m_base_position.Y/BS)<<",";
|
|
|
|
os<<(m_base_position.Z/BS);
|
|
|
|
os<<")";
|
2012-03-11 06:15:45 +04:00
|
|
|
return os.str();
|
2012-03-04 23:08:03 +04:00
|
|
|
}
|
|
|
|
|
2012-03-29 17:10:11 +04:00
|
|
|
void LuaEntitySAO::setHP(s16 hp)
|
|
|
|
{
|
|
|
|
if(hp < 0) hp = 0;
|
|
|
|
m_hp = hp;
|
|
|
|
}
|
|
|
|
|
|
|
|
s16 LuaEntitySAO::getHP() const
|
|
|
|
{
|
|
|
|
return m_hp;
|
|
|
|
}
|
|
|
|
|
2011-11-21 13:15:15 +04:00
|
|
|
void LuaEntitySAO::setVelocity(v3f velocity)
|
|
|
|
{
|
|
|
|
m_velocity = velocity;
|
|
|
|
}
|
|
|
|
|
2012-01-02 18:19:52 +04:00
|
|
|
v3f LuaEntitySAO::getVelocity()
|
|
|
|
{
|
|
|
|
return m_velocity;
|
|
|
|
}
|
|
|
|
|
2011-11-21 13:15:15 +04:00
|
|
|
void LuaEntitySAO::setAcceleration(v3f acceleration)
|
|
|
|
{
|
|
|
|
m_acceleration = acceleration;
|
|
|
|
}
|
|
|
|
|
2011-11-27 06:31:05 +04:00
|
|
|
v3f LuaEntitySAO::getAcceleration()
|
|
|
|
{
|
|
|
|
return m_acceleration;
|
|
|
|
}
|
|
|
|
|
2011-11-26 14:35:30 +04:00
|
|
|
void LuaEntitySAO::setTextureMod(const std::string &mod)
|
|
|
|
{
|
2012-03-29 18:46:21 +04:00
|
|
|
std::string str = gob_cmd_set_texture_mod(mod);
|
2017-01-14 21:32:10 +03:00
|
|
|
m_current_texture_modifier = mod;
|
2011-11-26 14:35:30 +04:00
|
|
|
// create message and add to list
|
2012-03-29 18:46:21 +04:00
|
|
|
ActiveObjectMessage aom(getId(), true, str);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2011-11-27 06:31:05 +04:00
|
|
|
}
|
|
|
|
|
2017-01-14 21:32:10 +03:00
|
|
|
std::string LuaEntitySAO::getTextureMod() const
|
|
|
|
{
|
|
|
|
return m_current_texture_modifier;
|
|
|
|
}
|
|
|
|
|
2011-11-27 06:31:05 +04:00
|
|
|
void LuaEntitySAO::setSprite(v2s16 p, int num_frames, float framelength,
|
|
|
|
bool select_horiz_by_yawpitch)
|
|
|
|
{
|
2012-03-29 18:46:21 +04:00
|
|
|
std::string str = gob_cmd_set_sprite(
|
|
|
|
p,
|
|
|
|
num_frames,
|
|
|
|
framelength,
|
|
|
|
select_horiz_by_yawpitch
|
|
|
|
);
|
2011-11-27 06:31:05 +04:00
|
|
|
// create message and add to list
|
2012-03-29 18:46:21 +04:00
|
|
|
ActiveObjectMessage aom(getId(), true, str);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2011-11-26 14:35:30 +04:00
|
|
|
}
|
|
|
|
|
2012-01-02 15:12:56 +04:00
|
|
|
std::string LuaEntitySAO::getName()
|
|
|
|
{
|
|
|
|
return m_init_name;
|
|
|
|
}
|
|
|
|
|
2012-03-29 18:46:21 +04:00
|
|
|
std::string LuaEntitySAO::getPropertyPacket()
|
|
|
|
{
|
2012-03-30 13:51:51 +04:00
|
|
|
return gob_cmd_set_properties(m_prop);
|
2012-03-29 18:46:21 +04:00
|
|
|
}
|
|
|
|
|
2011-11-12 15:14:44 +04:00
|
|
|
void LuaEntitySAO::sendPosition(bool do_interpolate, bool is_movement_end)
|
2011-11-12 13:59:56 +04:00
|
|
|
{
|
2012-10-28 19:07:11 +04:00
|
|
|
// If the object is attached client-side, don't waste bandwidth sending its position to clients
|
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly.
Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed)
Fix a bug in falling code where entities get stuck
Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed.
Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need
Create a separate function for detaching, and also update lua api documentation
When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct
Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too)
Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 20:42:38 +04:00
|
|
|
if(isAttached())
|
2012-10-27 16:14:24 +04:00
|
|
|
return;
|
2015-01-19 07:29:19 +03:00
|
|
|
|
2011-11-12 15:59:56 +04:00
|
|
|
m_last_sent_move_precision = m_base_position.getDistanceFrom(
|
|
|
|
m_last_sent_position);
|
|
|
|
m_last_sent_position_timer = 0;
|
2011-11-12 13:59:56 +04:00
|
|
|
m_last_sent_yaw = m_yaw;
|
|
|
|
m_last_sent_position = m_base_position;
|
2011-11-21 16:36:21 +04:00
|
|
|
m_last_sent_velocity = m_velocity;
|
2011-11-21 13:15:15 +04:00
|
|
|
//m_last_sent_acceleration = m_acceleration;
|
2011-11-12 15:59:56 +04:00
|
|
|
|
|
|
|
float update_interval = m_env->getSendRecommendedInterval();
|
2011-11-12 13:59:56 +04:00
|
|
|
|
2012-03-29 18:46:21 +04:00
|
|
|
std::string str = gob_cmd_update_position(
|
|
|
|
m_base_position,
|
|
|
|
m_velocity,
|
|
|
|
m_acceleration,
|
|
|
|
m_yaw,
|
|
|
|
do_interpolate,
|
|
|
|
is_movement_end,
|
|
|
|
update_interval
|
|
|
|
);
|
2011-11-12 13:59:56 +04:00
|
|
|
// create message and add to list
|
2012-03-29 18:46:21 +04:00
|
|
|
ActiveObjectMessage aom(getId(), false, str);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2011-11-12 13:59:56 +04:00
|
|
|
}
|
|
|
|
|
2017-01-09 22:39:45 +03:00
|
|
|
bool LuaEntitySAO::getCollisionBox(aabb3f *toset) const
|
|
|
|
{
|
2013-01-12 21:59:19 +04:00
|
|
|
if (m_prop.physical)
|
|
|
|
{
|
|
|
|
//update collision box
|
|
|
|
toset->MinEdge = m_prop.collisionbox.MinEdge * BS;
|
|
|
|
toset->MaxEdge = m_prop.collisionbox.MaxEdge * BS;
|
|
|
|
|
|
|
|
toset->MinEdge += m_base_position;
|
|
|
|
toset->MaxEdge += m_base_position;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-01-09 22:39:45 +03:00
|
|
|
bool LuaEntitySAO::collideWithObjects() const
|
|
|
|
{
|
2013-06-14 16:04:46 +04:00
|
|
|
return m_prop.collideWithObjects;
|
|
|
|
}
|
|
|
|
|
2012-03-19 06:04:16 +04:00
|
|
|
/*
|
|
|
|
PlayerSAO
|
|
|
|
*/
|
|
|
|
|
|
|
|
// No prototype, PlayerSAO does not need to be deserialized
|
|
|
|
|
2016-10-30 16:53:26 +03:00
|
|
|
PlayerSAO::PlayerSAO(ServerEnvironment *env_, u16 peer_id_, bool is_singleplayer):
|
|
|
|
UnitSAO(env_, v3f(0,0,0)),
|
|
|
|
m_player(NULL),
|
2012-03-19 06:04:16 +04:00
|
|
|
m_peer_id(peer_id_),
|
|
|
|
m_inventory(NULL),
|
2013-08-14 01:06:39 +04:00
|
|
|
m_damage(0),
|
2012-03-19 06:04:16 +04:00
|
|
|
m_last_good_position(0,0,0),
|
|
|
|
m_time_from_last_punch(0),
|
2012-07-21 15:38:49 +04:00
|
|
|
m_nocheat_dig_pos(32767, 32767, 32767),
|
|
|
|
m_nocheat_dig_time(0),
|
2012-03-19 06:04:16 +04:00
|
|
|
m_wield_index(0),
|
|
|
|
m_position_not_sent(false),
|
2012-04-01 14:19:50 +04:00
|
|
|
m_is_singleplayer(is_singleplayer),
|
2016-10-30 16:53:26 +03:00
|
|
|
m_breath(PLAYER_MAX_BREATH),
|
|
|
|
m_pitch(0),
|
2016-11-30 11:13:14 +03:00
|
|
|
m_fov(0),
|
|
|
|
m_wanted_range(0),
|
2017-01-27 10:59:30 +03:00
|
|
|
m_extended_attributes_modified(false),
|
2012-03-31 18:08:39 +04:00
|
|
|
// public
|
2013-04-05 15:03:28 +04:00
|
|
|
m_physics_override_speed(1),
|
|
|
|
m_physics_override_jump(1),
|
|
|
|
m_physics_override_gravity(1),
|
2013-12-03 21:51:15 +04:00
|
|
|
m_physics_override_sneak(true),
|
|
|
|
m_physics_override_sneak_glitch(true),
|
2013-04-05 15:03:28 +04:00
|
|
|
m_physics_override_sent(false)
|
2012-03-19 06:04:16 +04:00
|
|
|
{
|
2015-03-06 13:21:51 +03:00
|
|
|
assert(m_peer_id != 0); // pre-condition
|
2012-03-30 13:51:51 +04:00
|
|
|
|
|
|
|
m_prop.hp_max = PLAYER_MAX_HP;
|
|
|
|
m_prop.physical = false;
|
|
|
|
m_prop.weight = 75;
|
2016-02-11 17:21:21 +03:00
|
|
|
m_prop.collisionbox = aabb3f(-1/3.,-1.0,-1/3., 1/3.,1.0,1/3.);
|
2012-10-23 01:03:14 +04:00
|
|
|
// start of default appearance, this should be overwritten by LUA
|
2012-10-23 21:03:06 +04:00
|
|
|
m_prop.visual = "upright_sprite";
|
2012-03-30 13:51:51 +04:00
|
|
|
m_prop.visual_size = v2f(1, 2);
|
|
|
|
m_prop.textures.clear();
|
|
|
|
m_prop.textures.push_back("player.png");
|
|
|
|
m_prop.textures.push_back("player_back.png");
|
2012-10-27 02:49:01 +04:00
|
|
|
m_prop.colors.clear();
|
|
|
|
m_prop.colors.push_back(video::SColor(255, 255, 255, 255));
|
2012-03-30 13:51:51 +04:00
|
|
|
m_prop.spritediv = v2s16(1,1);
|
2012-10-23 01:03:14 +04:00
|
|
|
// end of default appearance
|
2012-11-12 18:35:10 +04:00
|
|
|
m_prop.is_visible = true;
|
2012-03-30 13:51:51 +04:00
|
|
|
m_prop.makes_footstep_sound = true;
|
2016-10-30 16:53:26 +03:00
|
|
|
m_hp = PLAYER_MAX_HP;
|
2012-03-19 06:04:16 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
PlayerSAO::~PlayerSAO()
|
|
|
|
{
|
|
|
|
if(m_inventory != &m_player->inventory)
|
|
|
|
delete m_inventory;
|
|
|
|
}
|
|
|
|
|
2016-10-30 16:53:26 +03:00
|
|
|
void PlayerSAO::initialize(RemotePlayer *player, const std::set<std::string> &privs)
|
|
|
|
{
|
|
|
|
assert(player);
|
|
|
|
m_player = player;
|
|
|
|
m_privs = privs;
|
|
|
|
m_inventory = &m_player->inventory;
|
|
|
|
}
|
|
|
|
|
2017-01-09 22:39:45 +03:00
|
|
|
v3f PlayerSAO::getEyeOffset() const
|
|
|
|
{
|
|
|
|
return v3f(0, BS * 1.625f, 0);
|
|
|
|
}
|
|
|
|
|
2012-03-19 06:04:16 +04:00
|
|
|
std::string PlayerSAO::getDescription()
|
|
|
|
{
|
|
|
|
return std::string("player ") + m_player->getName();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Called after id has been set and has been inserted in environment
|
2012-09-09 18:12:29 +04:00
|
|
|
void PlayerSAO::addedToEnvironment(u32 dtime_s)
|
2012-03-19 06:04:16 +04:00
|
|
|
{
|
2012-09-09 18:12:29 +04:00
|
|
|
ServerActiveObject::addedToEnvironment(dtime_s);
|
2016-10-30 16:53:26 +03:00
|
|
|
ServerActiveObject::setBasePosition(m_base_position);
|
2012-03-19 06:04:16 +04:00
|
|
|
m_player->setPlayerSAO(this);
|
|
|
|
m_player->peer_id = m_peer_id;
|
2016-10-30 16:53:26 +03:00
|
|
|
m_last_good_position = m_base_position;
|
2012-03-19 06:04:16 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Called before removing from environment
|
|
|
|
void PlayerSAO::removingFromEnvironment()
|
|
|
|
{
|
|
|
|
ServerActiveObject::removingFromEnvironment();
|
2016-10-08 11:38:04 +03:00
|
|
|
if (m_player->getPlayerSAO() == this) {
|
2016-11-05 12:25:30 +03:00
|
|
|
unlinkPlayerSessionAndSave();
|
2016-08-04 23:09:21 +03:00
|
|
|
for (UNORDERED_SET<u32>::iterator it = m_attached_particle_spawners.begin();
|
|
|
|
it != m_attached_particle_spawners.end(); ++it) {
|
|
|
|
m_env->deleteParticleSpawner(*it, false);
|
|
|
|
}
|
2012-03-19 06:04:16 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-11-27 02:47:03 +04:00
|
|
|
std::string PlayerSAO::getClientInitializationData(u16 protocol_version)
|
2012-03-19 06:04:16 +04:00
|
|
|
{
|
|
|
|
std::ostringstream os(std::ios::binary);
|
2012-11-27 02:47:03 +04:00
|
|
|
|
|
|
|
if(protocol_version >= 15)
|
|
|
|
{
|
|
|
|
writeU8(os, 1); // version
|
|
|
|
os<<serializeString(m_player->getName()); // name
|
|
|
|
writeU8(os, 1); // is_player
|
|
|
|
writeS16(os, getId()); //id
|
2016-10-30 16:53:26 +03:00
|
|
|
writeV3F1000(os, m_base_position + v3f(0,BS*1,0));
|
|
|
|
writeF1000(os, m_yaw);
|
2012-11-27 02:47:03 +04:00
|
|
|
writeS16(os, getHP());
|
|
|
|
|
2016-11-10 15:42:49 +03:00
|
|
|
std::ostringstream msg_os(std::ios::binary);
|
|
|
|
msg_os << serializeLongString(getPropertyPacket()); // message 1
|
|
|
|
msg_os << serializeLongString(gob_cmd_update_armor_groups(m_armor_groups)); // 2
|
|
|
|
msg_os << serializeLongString(gob_cmd_update_animation(
|
2015-02-22 00:38:53 +03:00
|
|
|
m_animation_range, m_animation_speed, m_animation_blend, m_animation_loop)); // 3
|
2016-10-06 20:20:12 +03:00
|
|
|
for (UNORDERED_MAP<std::string, core::vector2d<v3f> >::const_iterator
|
|
|
|
ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii) {
|
2016-11-10 15:42:49 +03:00
|
|
|
msg_os << serializeLongString(gob_cmd_update_bone_position((*ii).first,
|
|
|
|
(*ii).second.X, (*ii).second.Y)); // m_bone_position.size
|
2012-11-27 02:47:03 +04:00
|
|
|
}
|
2016-11-10 15:42:49 +03:00
|
|
|
msg_os << serializeLongString(gob_cmd_update_attachment(m_attachment_parent_id,
|
|
|
|
m_attachment_bone, m_attachment_position, m_attachment_rotation)); // 4
|
|
|
|
msg_os << serializeLongString(gob_cmd_update_physics_override(m_physics_override_speed,
|
2013-12-03 21:51:15 +04:00
|
|
|
m_physics_override_jump, m_physics_override_gravity, m_physics_override_sneak,
|
|
|
|
m_physics_override_sneak_glitch)); // 5
|
2016-11-10 15:42:49 +03:00
|
|
|
// (GENERIC_CMD_UPDATE_NAMETAG_ATTRIBUTES) : Deprecated, for backwards compatibility only.
|
|
|
|
msg_os << serializeLongString(gob_cmd_update_nametag_attributes(m_prop.nametag_color)); // 6
|
|
|
|
int message_count = 6 + m_bone_position.size();
|
2016-10-08 20:08:23 +03:00
|
|
|
for (UNORDERED_SET<int>::const_iterator ii = m_attachment_child_ids.begin();
|
2016-10-08 15:51:25 +03:00
|
|
|
ii != m_attachment_child_ids.end(); ++ii) {
|
|
|
|
if (ServerActiveObject *obj = m_env->getActiveObject(*ii)) {
|
2016-11-10 15:42:49 +03:00
|
|
|
message_count++;
|
|
|
|
msg_os << serializeLongString(gob_cmd_update_infant(*ii, obj->getSendType(),
|
|
|
|
obj->getClientInitializationData(protocol_version)));
|
2016-10-08 15:51:25 +03:00
|
|
|
}
|
|
|
|
}
|
2016-11-10 15:42:49 +03:00
|
|
|
|
|
|
|
writeU8(os, message_count);
|
|
|
|
os.write(msg_os.str().c_str(), msg_os.str().size());
|
2012-11-27 02:47:03 +04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
writeU8(os, 0); // version
|
|
|
|
os<<serializeString(m_player->getName()); // name
|
|
|
|
writeU8(os, 1); // is_player
|
2016-10-30 16:53:26 +03:00
|
|
|
writeV3F1000(os, m_base_position + v3f(0,BS*1,0));
|
|
|
|
writeF1000(os, m_yaw);
|
2012-11-27 02:47:03 +04:00
|
|
|
writeS16(os, getHP());
|
|
|
|
writeU8(os, 2); // number of messages stuffed in here
|
|
|
|
os<<serializeLongString(getPropertyPacket()); // message 1
|
|
|
|
os<<serializeLongString(gob_cmd_update_armor_groups(m_armor_groups)); // 2
|
|
|
|
}
|
2012-11-05 01:54:50 +04:00
|
|
|
|
|
|
|
// return result
|
2012-03-19 06:04:16 +04:00
|
|
|
return os.str();
|
|
|
|
}
|
|
|
|
|
2017-01-12 00:48:14 +03:00
|
|
|
void PlayerSAO::getStaticData(std::string *result) const
|
2012-03-19 06:04:16 +04:00
|
|
|
{
|
2017-01-12 00:48:14 +03:00
|
|
|
FATAL_ERROR("Deprecated function");
|
2012-03-19 06:04:16 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void PlayerSAO::step(float dtime, bool send_recommended)
|
2012-10-28 19:07:11 +04:00
|
|
|
{
|
2017-01-01 18:13:01 +03:00
|
|
|
if (m_drowning_interval.step(dtime, 2.0)) {
|
|
|
|
// get head position
|
|
|
|
v3s16 p = floatToInt(m_base_position + v3f(0, BS * 1.6, 0), BS);
|
|
|
|
MapNode n = m_env->getMap().getNodeNoEx(p);
|
2017-01-09 22:39:22 +03:00
|
|
|
const ContentFeatures &c = m_env->getGameDef()->ndef()->get(n);
|
2017-01-01 18:13:01 +03:00
|
|
|
// If node generates drown
|
|
|
|
if (c.drowning > 0) {
|
|
|
|
if (m_hp > 0 && m_breath > 0)
|
|
|
|
setBreath(m_breath - 1);
|
|
|
|
|
|
|
|
// No more breath, damage player
|
|
|
|
if (m_breath == 0) {
|
|
|
|
setHP(m_hp - c.drowning);
|
2017-01-09 22:39:22 +03:00
|
|
|
m_env->getGameDef()->SendPlayerHPOrDie(this);
|
2017-01-01 18:13:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (m_breathing_interval.step(dtime, 0.5)) {
|
|
|
|
// get head position
|
|
|
|
v3s16 p = floatToInt(m_base_position + v3f(0, BS * 1.6, 0), BS);
|
|
|
|
MapNode n = m_env->getMap().getNodeNoEx(p);
|
2017-01-09 22:39:22 +03:00
|
|
|
const ContentFeatures &c = m_env->getGameDef()->ndef()->get(n);
|
2017-01-01 18:13:01 +03:00
|
|
|
// If player is alive & no drowning, breath
|
|
|
|
if (m_hp > 0 && c.drowning == 0)
|
|
|
|
setBreath(m_breath + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!m_properties_sent) {
|
2012-03-29 18:46:21 +04:00
|
|
|
m_properties_sent = true;
|
|
|
|
std::string str = getPropertyPacket();
|
|
|
|
// create message and add to list
|
|
|
|
ActiveObjectMessage aom(getId(), true, str);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2012-03-29 18:46:21 +04:00
|
|
|
}
|
|
|
|
|
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly.
Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed)
Fix a bug in falling code where entities get stuck
Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed.
Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need
Create a separate function for detaching, and also update lua api documentation
When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct
Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too)
Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 20:42:38 +04:00
|
|
|
// If attached, check that our parent is still there. If it isn't, detach.
|
|
|
|
if(m_attachment_parent_id && !isAttached())
|
|
|
|
{
|
|
|
|
m_attachment_parent_id = 0;
|
|
|
|
m_attachment_bone = "";
|
|
|
|
m_attachment_position = v3f(0,0,0);
|
|
|
|
m_attachment_rotation = v3f(0,0,0);
|
2016-10-30 16:53:26 +03:00
|
|
|
setBasePosition(m_last_good_position);
|
2017-01-09 22:39:22 +03:00
|
|
|
m_env->getGameDef()->SendMovePlayer(m_peer_id);
|
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly.
Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed)
Fix a bug in falling code where entities get stuck
Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed.
Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need
Create a separate function for detaching, and also update lua api documentation
When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct
Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too)
Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 20:42:38 +04:00
|
|
|
}
|
|
|
|
|
2013-08-04 00:16:37 +04:00
|
|
|
//dstream<<"PlayerSAO::step: dtime: "<<dtime<<std::endl;
|
|
|
|
|
|
|
|
// Set lag pool maximums based on estimated lag
|
|
|
|
const float LAG_POOL_MIN = 5.0;
|
|
|
|
float lag_pool_max = m_env->getMaxLagEstimate() * 2.0;
|
|
|
|
if(lag_pool_max < LAG_POOL_MIN)
|
|
|
|
lag_pool_max = LAG_POOL_MIN;
|
|
|
|
m_dig_pool.setMax(lag_pool_max);
|
|
|
|
m_move_pool.setMax(lag_pool_max);
|
|
|
|
|
|
|
|
// Increment cheat prevention timers
|
|
|
|
m_dig_pool.add(dtime);
|
|
|
|
m_move_pool.add(dtime);
|
2012-03-19 06:04:16 +04:00
|
|
|
m_time_from_last_punch += dtime;
|
2012-07-21 15:38:49 +04:00
|
|
|
m_nocheat_dig_time += dtime;
|
2012-10-27 16:14:24 +04:00
|
|
|
|
2012-10-28 19:07:11 +04:00
|
|
|
// 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
|
2016-10-30 16:53:26 +03:00
|
|
|
if (isAttached()) {
|
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly.
Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed)
Fix a bug in falling code where entities get stuck
Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed.
Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need
Create a separate function for detaching, and also update lua api documentation
When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct
Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too)
Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 20:42:38 +04:00
|
|
|
v3f pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition();
|
2012-10-28 19:07:11 +04:00
|
|
|
m_last_good_position = pos;
|
2016-10-30 16:53:26 +03:00
|
|
|
setBasePosition(pos);
|
2012-10-28 19:07:11 +04:00
|
|
|
}
|
2012-03-19 06:04:16 +04:00
|
|
|
|
2016-10-30 16:53:26 +03:00
|
|
|
if (!send_recommended)
|
2012-03-19 06:04:16 +04:00
|
|
|
return;
|
|
|
|
|
2012-10-28 19:07:11 +04:00
|
|
|
// If the object is attached client-side, don't waste bandwidth sending its position to clients
|
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly.
Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed)
Fix a bug in falling code where entities get stuck
Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed.
Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need
Create a separate function for detaching, and also update lua api documentation
When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct
Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too)
Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 20:42:38 +04:00
|
|
|
if(m_position_not_sent && !isAttached())
|
2012-03-19 06:04:16 +04:00
|
|
|
{
|
|
|
|
m_position_not_sent = false;
|
2012-03-29 18:46:21 +04:00
|
|
|
float update_interval = m_env->getSendRecommendedInterval();
|
2012-10-27 16:14:24 +04:00
|
|
|
v3f pos;
|
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly.
Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed)
Fix a bug in falling code where entities get stuck
Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed.
Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need
Create a separate function for detaching, and also update lua api documentation
When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct
Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too)
Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 20:42:38 +04:00
|
|
|
if(isAttached()) // Just in case we ever do send attachment position too
|
|
|
|
pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition();
|
2012-10-27 16:14:24 +04:00
|
|
|
else
|
2016-10-30 16:53:26 +03:00
|
|
|
pos = m_base_position + v3f(0,BS*1,0);
|
2012-03-29 18:46:21 +04:00
|
|
|
std::string str = gob_cmd_update_position(
|
2012-10-27 16:14:24 +04:00
|
|
|
pos,
|
2012-03-29 18:46:21 +04:00
|
|
|
v3f(0,0,0),
|
|
|
|
v3f(0,0,0),
|
2016-10-30 16:53:26 +03:00
|
|
|
m_yaw,
|
2012-03-29 18:46:21 +04:00
|
|
|
true,
|
|
|
|
false,
|
|
|
|
update_interval
|
|
|
|
);
|
2012-03-19 06:04:16 +04:00
|
|
|
// create message and add to list
|
2012-03-29 18:46:21 +04:00
|
|
|
ActiveObjectMessage aom(getId(), false, str);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2012-03-19 06:04:16 +04:00
|
|
|
}
|
|
|
|
|
2016-10-30 16:53:26 +03:00
|
|
|
if (!m_armor_groups_sent) {
|
2012-03-29 18:46:21 +04:00
|
|
|
m_armor_groups_sent = true;
|
|
|
|
std::string str = gob_cmd_update_armor_groups(
|
|
|
|
m_armor_groups);
|
2012-03-19 06:04:16 +04:00
|
|
|
// create message and add to list
|
2012-03-29 18:46:21 +04:00
|
|
|
ActiveObjectMessage aom(getId(), true, str);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2012-03-19 06:04:16 +04:00
|
|
|
}
|
2012-11-04 16:33:30 +04:00
|
|
|
|
2016-10-30 16:53:26 +03:00
|
|
|
if (!m_physics_override_sent) {
|
2013-04-05 15:03:28 +04:00
|
|
|
m_physics_override_sent = true;
|
2013-12-03 21:51:15 +04:00
|
|
|
std::string str = gob_cmd_update_physics_override(m_physics_override_speed,
|
|
|
|
m_physics_override_jump, m_physics_override_gravity,
|
|
|
|
m_physics_override_sneak, m_physics_override_sneak_glitch);
|
2013-04-05 15:03:28 +04:00
|
|
|
// create message and add to list
|
|
|
|
ActiveObjectMessage aom(getId(), true, str);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2013-04-05 15:03:28 +04:00
|
|
|
}
|
|
|
|
|
2016-10-30 16:53:26 +03:00
|
|
|
if (!m_animation_sent) {
|
2012-11-12 18:35:10 +04:00
|
|
|
m_animation_sent = true;
|
2015-02-22 00:38:53 +03:00
|
|
|
std::string str = gob_cmd_update_animation(
|
|
|
|
m_animation_range, m_animation_speed, m_animation_blend, m_animation_loop);
|
2012-11-04 16:33:30 +04:00
|
|
|
// create message and add to list
|
|
|
|
ActiveObjectMessage aom(getId(), true, str);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2012-11-04 16:33:30 +04:00
|
|
|
}
|
|
|
|
|
2016-10-06 20:20:12 +03:00
|
|
|
if (!m_bone_position_sent) {
|
2012-11-12 18:35:10 +04:00
|
|
|
m_bone_position_sent = true;
|
2016-10-06 20:20:12 +03:00
|
|
|
for (UNORDERED_MAP<std::string, core::vector2d<v3f> >::const_iterator
|
|
|
|
ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii) {
|
|
|
|
std::string str = gob_cmd_update_bone_position((*ii).first,
|
|
|
|
(*ii).second.X, (*ii).second.Y);
|
2012-11-04 16:33:30 +04:00
|
|
|
// create message and add to list
|
|
|
|
ActiveObjectMessage aom(getId(), true, str);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2012-11-04 16:33:30 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-06 20:20:12 +03:00
|
|
|
if (!m_attachment_sent){
|
2012-11-04 16:33:30 +04:00
|
|
|
m_attachment_sent = true;
|
2016-10-06 20:20:12 +03:00
|
|
|
std::string str = gob_cmd_update_attachment(m_attachment_parent_id,
|
|
|
|
m_attachment_bone, m_attachment_position, m_attachment_rotation);
|
2012-11-04 16:33:30 +04:00
|
|
|
// create message and add to list
|
|
|
|
ActiveObjectMessage aom(getId(), true, str);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2012-11-04 16:33:30 +04:00
|
|
|
}
|
2012-03-19 06:04:16 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void PlayerSAO::setBasePosition(const v3f &position)
|
|
|
|
{
|
2016-10-30 16:53:26 +03:00
|
|
|
if (m_player && position != m_base_position)
|
|
|
|
m_player->setDirty(true);
|
|
|
|
|
2012-10-28 19:07:11 +04:00
|
|
|
// This needs to be ran for attachments too
|
2012-03-19 06:04:16 +04:00
|
|
|
ServerActiveObject::setBasePosition(position);
|
|
|
|
m_position_not_sent = true;
|
|
|
|
}
|
|
|
|
|
2016-10-30 16:53:26 +03:00
|
|
|
void PlayerSAO::setPos(const v3f &pos)
|
2012-03-19 06:04:16 +04:00
|
|
|
{
|
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly.
Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed)
Fix a bug in falling code where entities get stuck
Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed.
Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need
Create a separate function for detaching, and also update lua api documentation
When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct
Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too)
Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 20:42:38 +04:00
|
|
|
if(isAttached())
|
2012-10-27 16:14:24 +04:00
|
|
|
return;
|
2016-10-30 16:53:26 +03:00
|
|
|
|
|
|
|
setBasePosition(pos);
|
2012-03-19 06:04:16 +04:00
|
|
|
// Movement caused by this command is always valid
|
|
|
|
m_last_good_position = pos;
|
2017-01-09 22:39:22 +03:00
|
|
|
m_env->getGameDef()->SendMovePlayer(m_peer_id);
|
2012-03-19 06:04:16 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void PlayerSAO::moveTo(v3f pos, bool continuous)
|
|
|
|
{
|
Update attachments at the ending of the addToScene function for parents. And with this... *drum roll* Client-side attachments are at last functional and stick visibly.
Fix the last segmentation fault (apparently). So far attachments seem to be fully functional, although removing the parent causes children to go to origin 0,0,0 and possibly still cause such a fault (though this should already be addressed)
Fix a bug in falling code where entities get stuck
Also check if the parent has been removed server-side, and detach the child if so. Fixes children going to origin 0,0,0 when their parent is removed.
Unset all attachment properties when permanently detaching (on both the client and server). Also store less data we don't need
Create a separate function for detaching, and also update lua api documentation
When a child is detached, update its position from the server to clients. This WILL cause it to get positioned slightly differently client side, as the server attachment system only copies parent origin and knows not about mesh / bone transformation. This prevents different clients seeing the object detached in different spots which is most correct
Update the position of attached players to clients. An attached player will see himself move, but this is currently VERY ugly and laggy as it is done by the server (it probably must stay this way too)
Use a different approach for locally attached players. This allows for smooth positio transitions to work, as well at the player turning around freely. Still buggy however
2012-11-07 20:42:38 +04:00
|
|
|
if(isAttached())
|
2012-10-27 16:14:24 +04:00
|
|
|
return;
|
2016-10-30 16:53:26 +03:00
|
|
|
|
|
|
|
setBasePosition(pos);
|
2012-03-19 06:04:16 +04:00
|
|
|
// Movement caused by this command is always valid
|
|
|
|
m_last_good_position = pos;
|
2017-01-09 22:39:22 +03:00
|
|
|
m_env->getGameDef()->SendMovePlayer(m_peer_id);
|
2012-03-19 06:04:16 +04:00
|
|
|
}
|
|
|
|
|
2016-10-30 18:12:09 +03:00
|
|
|
void PlayerSAO::setYaw(const float yaw)
|
2013-03-17 15:16:57 +04:00
|
|
|
{
|
2016-10-30 16:53:26 +03:00
|
|
|
if (m_player && yaw != m_yaw)
|
|
|
|
m_player->setDirty(true);
|
|
|
|
|
|
|
|
UnitSAO::setYaw(yaw);
|
2016-10-30 18:12:09 +03:00
|
|
|
}
|
2016-10-30 16:53:26 +03:00
|
|
|
|
2016-11-30 11:13:14 +03:00
|
|
|
void PlayerSAO::setFov(const float fov)
|
|
|
|
{
|
|
|
|
if (m_player && fov != m_fov)
|
|
|
|
m_player->setDirty(true);
|
|
|
|
|
|
|
|
m_fov = fov;
|
|
|
|
}
|
|
|
|
|
|
|
|
void PlayerSAO::setWantedRange(const s16 range)
|
|
|
|
{
|
|
|
|
if (m_player && range != m_wanted_range)
|
|
|
|
m_player->setDirty(true);
|
|
|
|
|
|
|
|
m_wanted_range = range;
|
|
|
|
}
|
|
|
|
|
2016-10-30 18:12:09 +03:00
|
|
|
void PlayerSAO::setYawAndSend(const float yaw)
|
|
|
|
{
|
|
|
|
setYaw(yaw);
|
2017-01-09 22:39:22 +03:00
|
|
|
m_env->getGameDef()->SendMovePlayer(m_peer_id);
|
2013-03-17 15:16:57 +04:00
|
|
|
}
|
|
|
|
|
2016-10-30 18:12:09 +03:00
|
|
|
void PlayerSAO::setPitch(const float pitch)
|
2013-03-17 15:16:57 +04:00
|
|
|
{
|
2016-10-30 16:53:26 +03:00
|
|
|
if (m_player && pitch != m_pitch)
|
|
|
|
m_player->setDirty(true);
|
|
|
|
|
|
|
|
m_pitch = pitch;
|
2016-10-30 18:12:09 +03:00
|
|
|
}
|
2016-10-30 16:53:26 +03:00
|
|
|
|
2016-10-30 18:12:09 +03:00
|
|
|
void PlayerSAO::setPitchAndSend(const float pitch)
|
|
|
|
{
|
|
|
|
setPitch(pitch);
|
2017-01-09 22:39:22 +03:00
|
|
|
m_env->getGameDef()->SendMovePlayer(m_peer_id);
|
2013-03-17 15:16:57 +04:00
|
|
|
}
|
|
|
|
|
2012-03-19 06:04:16 +04:00
|
|
|
int PlayerSAO::punch(v3f dir,
|
|
|
|
const ToolCapabilities *toolcap,
|
|
|
|
ServerActiveObject *puncher,
|
|
|
|
float time_from_last_punch)
|
|
|
|
{
|
2015-01-19 07:29:19 +03:00
|
|
|
// It's best that attachments cannot be punched
|
2014-05-17 08:47:12 +04:00
|
|
|
if (isAttached())
|
2012-10-27 16:14:24 +04:00
|
|
|
return 0;
|
|
|
|
|
2014-05-17 08:47:12 +04:00
|
|
|
if (!toolcap)
|
2012-03-19 06:04:16 +04:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
// No effect if PvP disabled
|
2014-05-17 08:47:12 +04:00
|
|
|
if (g_settings->getBool("enable_pvp") == false) {
|
|
|
|
if (puncher->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
|
2012-03-29 18:46:21 +04:00
|
|
|
std::string str = gob_cmd_punched(0, getHP());
|
|
|
|
// create message and add to list
|
|
|
|
ActiveObjectMessage aom(getId(), true, str);
|
2015-03-04 19:48:07 +03:00
|
|
|
m_messages_out.push(aom);
|
2012-03-19 06:04:16 +04:00
|
|
|
return 0;
|
2012-03-29 18:46:21 +04:00
|
|
|
}
|
2012-03-19 06:04:16 +04:00
|
|
|
}
|
|
|
|
|
2012-03-29 17:10:11 +04:00
|
|
|
HitParams hitparams = getHitParams(m_armor_groups, toolcap,
|
|
|
|
time_from_last_punch);
|
2012-03-19 06:04:16 +04:00
|
|
|
|
2013-05-05 03:44:55 +04:00
|
|
|
std::string punchername = "nil";
|
|
|
|
|
2014-05-17 08:47:12 +04:00
|
|
|
if (puncher != 0)
|
2013-05-05 03:44:55 +04:00
|
|
|
punchername = puncher->getDescription();
|
|
|
|
|
2014-05-17 08:47:12 +04:00
|
|
|
PlayerSAO *playersao = m_player->getPlayerSAO();
|
|
|
|
|
|
|
|
bool damage_handled = m_env->getScriptIface()->on_punchplayer(playersao,
|
|
|
|
puncher, time_from_last_punch, toolcap, dir,
|
|
|
|
hitparams.hp);
|
|
|
|
|
|
|
|
if (!damage_handled) {
|
|
|
|
setHP(getHP() - hitparams.hp);
|
|
|
|
} else { // override client prediction
|
|
|
|
if (puncher->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
|
|
|
|
std::string str = gob_cmd_punched(0, getHP());
|
|
|
|
// create message and add to list
|
|
|
|
ActiveObjectMessage aom(getId(), true, str);
|
|
|
|
m_messages_out.push(aom);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-19 06:04:16 +04:00
|
|
|
|
2014-05-17 08:47:12 +04:00
|
|
|
actionstream << "Player " << m_player->getName() << " punched by "
|
|
|
|
<< punchername;
|
|
|
|
if (!damage_handled) {
|
|
|
|
actionstream << ", damage " << hitparams.hp << " HP";
|
|
|
|
} else {
|
|
|
|
actionstream << ", damage handled by lua";
|
|
|
|
}
|
|
|
|
actionstream << std::endl;
|
2012-03-19 06:04:16 +04:00
|
|
|
|
|
|
|
return hitparams.wear;
|
|
|
|
}
|
|
|
|
|
2013-08-14 01:06:39 +04:00
|
|
|
s16 PlayerSAO::readDamage()
|
|
|
|
{
|
|
|
|
s16 damage = m_damage;
|
|
|
|
m_damage = 0;
|
|
|
|
return damage;
|
|
|
|
}
|
|
|
|
|
2016-10-30 18:12:09 +03:00
|
|
|
void PlayerSAO::setHP(s16 hp)
|
2012-03-19 06:04:16 +04:00
|
|
|
{
|
2016-10-30 16:53:26 +03:00
|
|
|
s16 oldhp = m_hp;
|
2012-03-19 06:04:16 +04:00
|
|
|
|
2016-10-30 16:53:26 +03:00
|
|
|
s16 hp_change = m_env->getScriptIface()->on_player_hpchange(this, hp - oldhp);
|
2015-05-30 17:56:42 +03:00
|
|
|
if (hp_change == 0)
|
|
|
|
return;
|
|
|
|
hp = oldhp + hp_change;
|
|
|
|
|
2015-03-02 19:31:31 +03:00
|
|
|
if (hp < 0)
|
2012-03-19 06:04:16 +04:00
|
|
|
hp = 0;
|
2015-03-02 19:31:31 +03:00
|
|
|
else if (hp > PLAYER_MAX_HP)
|
2012-03-19 06:04:16 +04:00
|
|
|
hp = PLAYER_MAX_HP;
|
|
|
|
|
2016-10-30 16:53:26 +03:00
|
|
|
if (hp < oldhp && !g_settings->getBool("enable_damage")) {
|
2015-03-18 21:41:25 +03:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-10-30 16:53:26 +03:00
|
|
|
m_hp = hp;
|
2012-03-19 06:04:16 +04:00
|
|
|
|
2015-03-02 19:31:31 +03:00
|
|
|
if (oldhp > hp)
|
|
|
|
m_damage += (oldhp - hp);
|
2012-03-19 06:04:16 +04:00
|
|
|
|
2013-08-14 01:06:39 +04:00
|
|
|
// Update properties on death
|
2015-03-02 19:31:31 +03:00
|
|
|
if ((hp == 0) != (oldhp == 0))
|
2012-03-29 18:46:21 +04:00
|
|
|
m_properties_sent = false;
|
2012-03-19 06:04:16 +04:00
|
|
|
}
|
|
|
|
|
2017-01-01 18:13:01 +03:00
|
|
|
void PlayerSAO::setBreath(const u16 breath, bool send)
|
2013-07-19 21:50:33 +04:00
|
|
|
{
|
2016-10-30 16:53:26 +03:00
|
|
|
if (m_player && breath != m_breath)
|
|
|
|
m_player->setDirty(true);
|
2013-07-19 21:50:33 +04:00
|
|
|
|
2017-01-01 18:13:01 +03:00
|
|
|
m_breath = MYMIN(breath, PLAYER_MAX_BREATH);
|
|
|
|
|
|
|
|
if (send)
|
2017-01-09 22:39:22 +03:00
|
|
|
m_env->getGameDef()->SendPlayerBreath(this);
|
2013-07-19 21:50:33 +04:00
|
|
|
}
|
|
|
|
|
2012-03-19 06:04:16 +04:00
|
|
|
Inventory* PlayerSAO::getInventory()
|
|
|
|
{
|
|
|
|
return m_inventory;
|
|
|
|
}
|
|
|
|
const Inventory* PlayerSAO::getInventory() const
|
|
|
|
{
|
|
|
|
return m_inventory;
|
|
|
|
}
|
|
|
|
|
|
|
|
InventoryLocation PlayerSAO::getInventoryLocation() const
|
|
|
|
{
|
|
|
|
InventoryLocation loc;
|
|
|
|
loc.setPlayer(m_player->getName());
|
|
|
|
return loc;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string PlayerSAO::getWieldList() const
|
|
|
|
{
|
|
|
|
return "main";
|
|
|
|
}
|
|
|
|
|
2015-06-25 14:06:49 +03:00
|
|
|
ItemStack PlayerSAO::getWieldedItem() const
|
|
|
|
{
|
|
|
|
const Inventory *inv = getInventory();
|
|
|
|
ItemStack ret;
|
|
|
|
const InventoryList *mlist = inv->getList(getWieldList());
|
|
|
|
if (mlist && getWieldIndex() < (s32)mlist->getSize())
|
|
|
|
ret = mlist->getItem(getWieldIndex());
|
|
|
|
if (ret.name.empty()) {
|
|
|
|
const InventoryList *hlist = inv->getList("hand");
|
|
|
|
if (hlist)
|
|
|
|
ret = hlist->getItem(0);
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool PlayerSAO::setWieldedItem(const ItemStack &item)
|
|
|
|
{
|
|
|
|
Inventory *inv = getInventory();
|
|
|
|
if (inv) {
|
|
|
|
InventoryList *mlist = inv->getList(getWieldList());
|
|
|
|
if (mlist) {
|
|
|
|
ItemStack olditem = mlist->getItem(getWieldIndex());
|
|
|
|
if (olditem.name.empty()) {
|
|
|
|
InventoryList *hlist = inv->getList("hand");
|
|
|
|
if (hlist) {
|
|
|
|
hlist->changeItem(0, item);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mlist->changeItem(getWieldIndex(), item);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-03-19 06:04:16 +04:00
|
|
|
int PlayerSAO::getWieldIndex() const
|
|
|
|
{
|
|
|
|
return m_wield_index;
|
|
|
|
}
|
|
|
|
|
|
|
|
void PlayerSAO::setWieldIndex(int i)
|
|
|
|
{
|
2015-03-03 19:36:54 +03:00
|
|
|
if(i != m_wield_index) {
|
2012-03-19 06:04:16 +04:00
|
|
|
m_wield_index = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-05 12:25:30 +03:00
|
|
|
// Erase the peer id and make the object for removal
|
2012-03-19 06:04:16 +04:00
|
|
|
void PlayerSAO::disconnected()
|
|
|
|
{
|
|
|
|
m_peer_id = 0;
|
|
|
|
m_removed = true;
|
2016-11-05 12:25:30 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void PlayerSAO::unlinkPlayerSessionAndSave()
|
|
|
|
{
|
|
|
|
assert(m_player->getPlayerSAO() == this);
|
|
|
|
m_player->peer_id = 0;
|
|
|
|
m_env->savePlayer(m_player);
|
|
|
|
m_player->setPlayerSAO(NULL);
|
|
|
|
m_env->removePlayer(m_player);
|
2012-03-19 06:04:16 +04:00
|
|
|
}
|
|
|
|
|
2012-03-29 18:46:21 +04:00
|
|
|
std::string PlayerSAO::getPropertyPacket()
|
|
|
|
{
|
2012-11-12 18:35:10 +04:00
|
|
|
m_prop.is_visible = (true);
|
2012-03-30 13:51:51 +04:00
|
|
|
return gob_cmd_set_properties(m_prop);
|
2012-03-29 18:46:21 +04:00
|
|
|
}
|
|
|
|
|
2013-08-04 01:45:49 +04:00
|
|
|
bool PlayerSAO::checkMovementCheat()
|
2013-08-04 00:16:37 +04:00
|
|
|
{
|
2016-09-09 08:03:36 +03:00
|
|
|
if (isAttached() || m_is_singleplayer ||
|
|
|
|
g_settings->getBool("disable_anticheat")) {
|
2016-10-30 16:53:26 +03:00
|
|
|
m_last_good_position = m_base_position;
|
2016-09-09 08:03:36 +03:00
|
|
|
return false;
|
2013-08-04 00:16:37 +04:00
|
|
|
}
|
2016-09-09 08:03:36 +03:00
|
|
|
|
|
|
|
bool cheated = false;
|
|
|
|
/*
|
|
|
|
Check player movements
|
|
|
|
|
|
|
|
NOTE: Actually the server should handle player physics like the
|
|
|
|
client does and compare player's position to what is calculated
|
|
|
|
on our side. This is required when eg. players fly due to an
|
|
|
|
explosion. Altough a node-based alternative might be possible
|
|
|
|
too, and much more lightweight.
|
|
|
|
*/
|
|
|
|
|
|
|
|
float player_max_speed = 0;
|
|
|
|
|
|
|
|
if (m_privs.count("fast") != 0) {
|
|
|
|
// Fast speed
|
|
|
|
player_max_speed = m_player->movement_speed_fast * m_physics_override_speed;
|
|
|
|
} else {
|
|
|
|
// Normal speed
|
|
|
|
player_max_speed = m_player->movement_speed_walk * m_physics_override_speed;
|
|
|
|
}
|
|
|
|
// Tolerance. The lag pool does this a bit.
|
|
|
|
//player_max_speed *= 2.5;
|
|
|
|
|
2016-10-30 16:53:26 +03:00
|
|
|
v3f diff = (m_base_position - m_last_good_position);
|
2016-09-09 08:03:36 +03:00
|
|
|
float d_vert = diff.Y;
|
|
|
|
diff.Y = 0;
|
|
|
|
float d_horiz = diff.getLength();
|
|
|
|
float required_time = d_horiz / player_max_speed;
|
|
|
|
|
|
|
|
if (d_vert > 0 && d_vert / player_max_speed > required_time)
|
|
|
|
required_time = d_vert / player_max_speed; // Moving upwards
|
|
|
|
|
|
|
|
if (m_move_pool.grab(required_time)) {
|
2016-10-30 16:53:26 +03:00
|
|
|
m_last_good_position = m_base_position;
|
2016-09-09 08:03:36 +03:00
|
|
|
} else {
|
|
|
|
actionstream << "Player " << m_player->getName()
|
|
|
|
<< " moved too fast; resetting position"
|
|
|
|
<< std::endl;
|
2016-10-30 16:53:26 +03:00
|
|
|
setBasePosition(m_last_good_position);
|
2016-09-09 08:03:36 +03:00
|
|
|
cheated = true;
|
2013-08-04 00:16:37 +04:00
|
|
|
}
|
2013-08-04 01:45:49 +04:00
|
|
|
return cheated;
|
2013-08-04 00:16:37 +04:00
|
|
|
}
|
|
|
|
|
2017-01-09 22:39:45 +03:00
|
|
|
bool PlayerSAO::getCollisionBox(aabb3f *toset) const
|
2016-10-30 16:53:26 +03:00
|
|
|
{
|
|
|
|
*toset = aabb3f(-BS * 0.30, 0.0, -BS * 0.30, BS * 0.30, BS * 1.75, BS * 0.30);
|
2013-04-17 02:15:53 +04:00
|
|
|
toset->MinEdge += m_base_position;
|
|
|
|
toset->MaxEdge += m_base_position;
|
|
|
|
return true;
|
2013-01-12 21:59:19 +04:00
|
|
|
}
|