/*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+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
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+GNU Lesser General Public License for more details.
-You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "content_sao.h"
+#include "util/serialize.h"
#include "collision.h"
#include "environment.h"
-#include "settings.h"
-#include "main.h" // For g_profiler
-#include "profiler.h"
-#include "serialization.h" // For compressZlib
#include "tool.h" // For ToolCapabilities
#include "gamedef.h"
+#include "nodedef.h"
+#include "remoteplayer.h"
+#include "server.h"
+#include "scripting_server.h"
+#include "genericobject.h"
+#include "settings.h"
+#include <algorithm>
+#include <cmath>
-core::map<u16, ServerActiveObject::Factory> ServerActiveObject::m_types;
-
-/* Some helper functions */
-
-// Y is copied, X and Z change is limited
-void accelerate_xz(v3f &speed, v3f target_speed, f32 max_increase)
-{
- v3f d_wanted = target_speed - speed;
- d_wanted.Y = 0;
- f32 dl_wanted = d_wanted.getLength();
- f32 dl = dl_wanted;
- if(dl > max_increase)
- dl = max_increase;
-
- v3f d = d_wanted.normalize() * dl;
-
- speed.X += d.X;
- speed.Z += d.Z;
- speed.Y = target_speed.Y;
-}
+std::map<u16, ServerActiveObject::Factory> ServerActiveObject::m_types;
/*
TestSAO
*/
-// Prototype
-TestSAO proto_TestSAO(NULL, v3f(0,0,0));
-
-TestSAO::TestSAO(ServerEnvironment *env, v3f pos):
- ServerActiveObject(env, pos),
- m_timer1(0),
- m_age(0)
+class TestSAO : public ServerActiveObject
{
- ServerActiveObject::registerType(getType(), create);
-}
-
-ServerActiveObject* TestSAO::create(ServerEnvironment *env, v3f pos,
- const std::string &data)
-{
- return new TestSAO(env, pos);
-}
+public:
+ TestSAO(ServerEnvironment *env, v3f pos):
+ ServerActiveObject(env, pos),
+ m_timer1(0),
+ m_age(0)
+ {
+ ServerActiveObject::registerType(getType(), create);
+ }
+ ActiveObjectType getType() const
+ { return ACTIVEOBJECT_TYPE_TEST; }
-void TestSAO::step(float dtime, bool send_recommended)
-{
- m_age += dtime;
- if(m_age > 10)
+ static ServerActiveObject* create(ServerEnvironment *env, v3f pos,
+ const std::string &data)
{
- m_removed = true;
- return;
+ return new TestSAO(env, pos);
}
- m_base_position.Y += dtime * BS * 2;
- if(m_base_position.Y > 8*BS)
- m_base_position.Y = 2*BS;
+ void step(float dtime, bool send_recommended)
+ {
+ m_age += dtime;
+ if(m_age > 10)
+ {
+ m_pending_removal = true;
+ return;
+ }
- if(send_recommended == false)
- return;
+ m_base_position.Y += dtime * BS * 2;
+ if(m_base_position.Y > 8*BS)
+ m_base_position.Y = 2*BS;
- m_timer1 -= dtime;
- if(m_timer1 < 0.0)
- {
- m_timer1 += 0.125;
+ if (!send_recommended)
+ return;
- std::string data;
+ m_timer1 -= dtime;
+ if(m_timer1 < 0.0)
+ {
+ m_timer1 += 0.125;
+
+ std::string data;
- 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);
+ 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);
- ActiveObjectMessage aom(getId(), false, data);
- m_messages_out.push_back(aom);
+ ActiveObjectMessage aom(getId(), false, data);
+ m_messages_out.push(aom);
+ }
}
-}
+ bool getCollisionBox(aabb3f *toset) const { return false; }
-/*
- ItemSAO
-*/
+ virtual bool getSelectionBox(aabb3f *toset) const { return false; }
+
+ bool collideWithObjects() const { return false; }
+
+private:
+ float m_timer1;
+ float m_age;
+};
-// Prototype
-ItemSAO proto_ItemSAO(NULL, v3f(0,0,0), "");
+// Prototype (registers item for deserialization)
+TestSAO proto_TestSAO(NULL, v3f(0,0,0));
+
+/*
+ UnitSAO
+ */
-ItemSAO::ItemSAO(ServerEnvironment *env, v3f pos,
- const std::string itemstring):
- ServerActiveObject(env, pos),
- m_itemstring(itemstring),
- m_itemstring_changed(false),
- m_speed_f(0,0,0),
- m_last_sent_position(0,0,0)
+UnitSAO::UnitSAO(ServerEnvironment *env, v3f pos):
+ ServerActiveObject(env, pos)
{
- ServerActiveObject::registerType(getType(), create);
+ // Initialize something to armor groups
+ m_armor_groups["fleshy"] = 100;
}
-ServerActiveObject* ItemSAO::create(ServerEnvironment *env, v3f pos,
- const std::string &data)
+ServerActiveObject *UnitSAO::getParent() const
{
- std::istringstream is(data, std::ios::binary);
- char buf[1];
- // read version
- is.read(buf, 1);
- u8 version = buf[0];
- // check if version is supported
- if(version != 0)
- return NULL;
- std::string itemstring = deSerializeString(is);
- infostream<<"ItemSAO::create(): Creating item \""
- <<itemstring<<"\""<<std::endl;
- return new ItemSAO(env, pos, itemstring);
+ if (!m_attachment_parent_id)
+ return nullptr;
+ // Check if the parent still exists
+ ServerActiveObject *obj = m_env->getActiveObject(m_attachment_parent_id);
+
+ return obj;
}
-void ItemSAO::step(float dtime, bool send_recommended)
+void UnitSAO::setArmorGroups(const ItemGroupList &armor_groups)
{
- ScopeProfiler sp2(g_profiler, "ItemSAO::step avg", SPT_AVG);
-
- assert(m_env);
+ m_armor_groups = armor_groups;
+ m_armor_groups_sent = false;
+}
- const float interval = 0.2;
- if(m_move_interval.step(dtime, interval)==false)
- return;
- dtime = interval;
-
- core::aabbox3d<f32> box(-BS/3.,0.0,-BS/3., BS/3.,BS*2./3.,BS/3.);
- collisionMoveResult moveresult;
- // Apply gravity
- m_speed_f += v3f(0, -dtime*9.81*BS, 0);
- // Maximum movement without glitches
- f32 pos_max_d = BS*0.25;
- // Limit speed
- if(m_speed_f.getLength()*dtime > pos_max_d)
- m_speed_f *= pos_max_d / (m_speed_f.getLength()*dtime);
- v3f pos_f = getBasePosition();
- v3f pos_f_old = pos_f;
- IGameDef *gamedef = m_env->getGameDef();
- moveresult = collisionMoveSimple(&m_env->getMap(), gamedef,
- pos_max_d, box, dtime, pos_f, m_speed_f);
-
- if(send_recommended == false)
- return;
+const ItemGroupList &UnitSAO::getArmorGroups()
+{
+ return m_armor_groups;
+}
- if(pos_f.getDistanceFrom(m_last_sent_position) > 0.05*BS)
- {
- setBasePosition(pos_f);
- m_last_sent_position = pos_f;
-
- std::ostringstream os(std::ios::binary);
- // command (0 = update position)
- writeU8(os, 0);
- // pos
- writeV3F1000(os, m_base_position);
- // create message and add to list
- ActiveObjectMessage aom(getId(), false, os.str());
- m_messages_out.push_back(aom);
- }
- if(m_itemstring_changed)
- {
- m_itemstring_changed = false;
+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;
+}
- std::ostringstream os(std::ios::binary);
- // command (1 = update itemstring)
- writeU8(os, 1);
- // itemstring
- os<<serializeString(m_itemstring);
- // create message and add to list
- ActiveObjectMessage aom(getId(), false, os.str());
- m_messages_out.push_back(aom);
- }
+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;
}
-std::string ItemSAO::getClientInitializationData()
+void UnitSAO::setAnimationSpeed(float frame_speed)
{
- std::ostringstream os(std::ios::binary);
- // version
- writeU8(os, 0);
- // pos
- writeV3F1000(os, m_base_position);
- // itemstring
- os<<serializeString(m_itemstring);
- return os.str();
+ m_animation_speed = frame_speed;
+ m_animation_speed_sent = false;
}
-std::string ItemSAO::getStaticData()
+void UnitSAO::setBonePosition(const std::string &bone, v3f position, v3f rotation)
{
- infostream<<__FUNCTION_NAME<<std::endl;
- std::ostringstream os(std::ios::binary);
- // version
- writeU8(os, 0);
- // itemstring
- os<<serializeString(m_itemstring);
- return os.str();
+ // store these so they can be updated to clients
+ m_bone_position[bone] = core::vector2d<v3f>(position, rotation);
+ m_bone_position_sent = false;
}
-ItemStack ItemSAO::createItemStack()
+void UnitSAO::getBonePosition(const std::string &bone, v3f *position, v3f *rotation)
{
- try{
- IItemDefManager *idef = m_env->getGameDef()->idef();
- ItemStack item;
- item.deSerialize(m_itemstring, idef);
- infostream<<__FUNCTION_NAME<<": m_itemstring=\""<<m_itemstring
- <<"\" -> item=\""<<item.getItemString()<<"\""
- <<std::endl;
- return item;
- }
- catch(SerializationError &e)
- {
- infostream<<__FUNCTION_NAME<<": serialization error: "
- <<"m_itemstring=\""<<m_itemstring<<"\""<<std::endl;
- return ItemStack();
- }
+ *position = m_bone_position[bone].X;
+ *rotation = m_bone_position[bone].Y;
}
-void ItemSAO::punch(ServerActiveObject *puncher, float time_from_last_punch)
+void UnitSAO::setAttachment(int parent_id, const std::string &bone, v3f position, v3f rotation)
{
- // Allow removing items in creative mode
- if(g_settings->getBool("creative_mode") == true)
- {
- m_removed = true;
- return;
- }
+ // 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.
- ItemStack item = createItemStack();
- Inventory *inv = puncher->getInventory();
- if(inv != NULL)
- {
- std::string wieldlist = puncher->getWieldList();
- ItemStack leftover = inv->addItem(wieldlist, item);
- puncher->setInventoryModified();
- if(leftover.empty())
- {
- m_removed = true;
- }
- else
- {
- m_itemstring = leftover.getItemString();
- m_itemstring_changed = true;
- }
+ int old_parent = m_attachment_parent_id;
+ m_attachment_parent_id = parent_id;
+ m_attachment_bone = bone;
+ m_attachment_position = position;
+ m_attachment_rotation = rotation;
+ m_attachment_sent = false;
+
+ if (parent_id != old_parent) {
+ onDetach(old_parent);
+ onAttach(parent_id);
}
}
-/*
- RatSAO
-*/
-
-// Prototype
-RatSAO proto_RatSAO(NULL, v3f(0,0,0));
-
-RatSAO::RatSAO(ServerEnvironment *env, v3f pos):
- ServerActiveObject(env, pos),
- m_is_active(false),
- m_speed_f(0,0,0)
+void UnitSAO::getAttachment(int *parent_id, std::string *bone, v3f *position,
+ v3f *rotation) const
{
- ServerActiveObject::registerType(getType(), create);
-
- m_oldpos = v3f(0,0,0);
- m_last_sent_position = v3f(0,0,0);
- m_yaw = myrand_range(0,PI*2);
- m_counter1 = 0;
- m_counter2 = 0;
- m_age = 0;
- m_touching_ground = false;
+ *parent_id = m_attachment_parent_id;
+ *bone = m_attachment_bone;
+ *position = m_attachment_position;
+ *rotation = m_attachment_rotation;
}
-ServerActiveObject* RatSAO::create(ServerEnvironment *env, v3f pos,
- const std::string &data)
+void UnitSAO::clearChildAttachments()
{
- std::istringstream is(data, std::ios::binary);
- char buf[1];
- // read version
- is.read(buf, 1);
- u8 version = buf[0];
- // check if version is supported
- if(version != 0)
- return NULL;
- return new RatSAO(env, pos);
+ for (int child_id : m_attachment_child_ids) {
+ // Child can be NULL if it was deleted earlier
+ if (ServerActiveObject *child = m_env->getActiveObject(child_id))
+ child->setAttachment(0, "", v3f(0, 0, 0), v3f(0, 0, 0));
+ }
+ m_attachment_child_ids.clear();
}
-void RatSAO::step(float dtime, bool send_recommended)
+void UnitSAO::clearParentAttachment()
{
- ScopeProfiler sp2(g_profiler, "RatSAO::step avg", SPT_AVG);
+ ServerActiveObject *parent = nullptr;
+ if (m_attachment_parent_id) {
+ parent = m_env->getActiveObject(m_attachment_parent_id);
+ setAttachment(0, "", m_attachment_position, m_attachment_rotation);
+ } else {
+ setAttachment(0, "", v3f(0, 0, 0), v3f(0, 0, 0));
+ }
+ // Do it
+ if (parent)
+ parent->removeAttachmentChild(m_id);
+}
- assert(m_env);
+void UnitSAO::addAttachmentChild(int child_id)
+{
+ m_attachment_child_ids.insert(child_id);
+}
- if(m_is_active == false)
- {
- if(m_inactive_interval.step(dtime, 0.5)==false)
- return;
- }
+void UnitSAO::removeAttachmentChild(int child_id)
+{
+ m_attachment_child_ids.erase(child_id);
+}
- /*
- The AI
- */
+const std::unordered_set<int> &UnitSAO::getAttachmentChildIds() const
+{
+ return m_attachment_child_ids;
+}
- /*m_age += dtime;
- if(m_age > 60)
- {
- // Die
- m_removed = true;
+void UnitSAO::onAttach(int parent_id)
+{
+ if (!parent_id)
return;
- }*/
- // Apply gravity
- m_speed_f.Y -= dtime*9.81*BS;
+ ServerActiveObject *parent = m_env->getActiveObject(parent_id);
- /*
- Move around if some player is close
- */
- bool player_is_close = false;
- // Check connected players
- core::list<Player*> players = m_env->getPlayers(true);
- core::list<Player*>::Iterator i;
- for(i = players.begin();
- i != players.end(); i++)
- {
- Player *player = *i;
- v3f playerpos = player->getPosition();
- if(m_base_position.getDistanceFrom(playerpos) < BS*10.0)
- {
- player_is_close = true;
- break;
- }
- }
+ if (!parent || parent->isGone())
+ return; // Do not try to notify soon gone parent
- m_is_active = player_is_close;
-
- if(player_is_close == false)
- {
- m_speed_f.X = 0;
- m_speed_f.Z = 0;
+ if (parent->getType() == ACTIVEOBJECT_TYPE_LUAENTITY) {
+ // Call parent's on_attach field
+ m_env->getScriptIface()->luaentity_on_attach_child(parent_id, this);
}
- else
- {
- // Move around
- v3f dir(cos(m_yaw/180*PI),0,sin(m_yaw/180*PI));
- f32 speed = 2*BS;
- m_speed_f.X = speed * dir.X;
- m_speed_f.Z = speed * dir.Z;
-
- if(m_touching_ground && (m_oldpos - m_base_position).getLength()
- < dtime*speed/2)
- {
- m_counter1 -= dtime;
- if(m_counter1 < 0.0)
- {
- m_counter1 += 1.0;
- m_speed_f.Y = 5.0*BS;
- }
- }
+}
- {
- m_counter2 -= dtime;
- if(m_counter2 < 0.0)
- {
- m_counter2 += (float)(myrand()%100)/100*3.0;
- m_yaw += ((float)(myrand()%200)-100)/100*180;
- m_yaw = wrapDegrees(m_yaw);
- }
- }
- }
-
- m_oldpos = m_base_position;
+void UnitSAO::onDetach(int parent_id)
+{
+ if (!parent_id)
+ return;
- /*
- Move it, with collision detection
- */
+ ServerActiveObject *parent = m_env->getActiveObject(parent_id);
+ if (getType() == ACTIVEOBJECT_TYPE_LUAENTITY)
+ m_env->getScriptIface()->luaentity_on_detach(m_id, parent);
- core::aabbox3d<f32> box(-BS/3.,0.0,-BS/3., BS/3.,BS*2./3.,BS/3.);
- collisionMoveResult moveresult;
- // Maximum movement without glitches
- f32 pos_max_d = BS*0.25;
- // Limit speed
- if(m_speed_f.getLength()*dtime > pos_max_d)
- m_speed_f *= pos_max_d / (m_speed_f.getLength()*dtime);
- v3f pos_f = getBasePosition();
- v3f pos_f_old = pos_f;
- IGameDef *gamedef = m_env->getGameDef();
- moveresult = collisionMoveSimple(&m_env->getMap(), gamedef,
- pos_max_d, box, dtime, pos_f, m_speed_f);
- m_touching_ground = moveresult.touching_ground;
-
- setBasePosition(pos_f);
-
- if(send_recommended == false)
- return;
+ if (!parent || parent->isGone())
+ return; // Do not try to notify soon gone parent
- if(pos_f.getDistanceFrom(m_last_sent_position) > 0.05*BS)
- {
- m_last_sent_position = pos_f;
-
- std::ostringstream os(std::ios::binary);
- // command (0 = update position)
- writeU8(os, 0);
- // pos
- writeV3F1000(os, m_base_position);
- // yaw
- writeF1000(os, m_yaw);
- // create message and add to list
- ActiveObjectMessage aom(getId(), false, os.str());
- m_messages_out.push_back(aom);
- }
+ if (parent->getType() == ACTIVEOBJECT_TYPE_LUAENTITY)
+ m_env->getScriptIface()->luaentity_on_detach_child(parent_id, this);
}
-std::string RatSAO::getClientInitializationData()
+ObjectProperties* UnitSAO::accessObjectProperties()
{
- std::ostringstream os(std::ios::binary);
- // version
- writeU8(os, 0);
- // pos
- writeV3F1000(os, m_base_position);
- return os.str();
+ return &m_prop;
}
-std::string RatSAO::getStaticData()
+void UnitSAO::notifyObjectPropertiesModified()
{
- //infostream<<__FUNCTION_NAME<<std::endl;
- std::ostringstream os(std::ios::binary);
- // version
- writeU8(os, 0);
- return os.str();
+ m_properties_sent = false;
}
-void RatSAO::punch(ServerActiveObject *puncher, float time_from_last_punch)
+/*
+ LuaEntitySAO
+*/
+
+// Prototype (registers item for deserialization)
+LuaEntitySAO proto_LuaEntitySAO(NULL, v3f(0,0,0), "_prototype", "");
+
+LuaEntitySAO::LuaEntitySAO(ServerEnvironment *env, v3f pos,
+ const std::string &name, const std::string &state):
+ UnitSAO(env, pos),
+ m_init_name(name),
+ m_init_state(state)
{
- // Allow removing rats in creative mode
- if(g_settings->getBool("creative_mode") == true)
- {
- m_removed = true;
+ // Only register type if no environment supplied
+ if(env == NULL){
+ ServerActiveObject::registerType(getType(), create);
return;
}
-
- IItemDefManager *idef = m_env->getGameDef()->idef();
- ItemStack item("rat", 1, 0, "", idef);
- Inventory *inv = puncher->getInventory();
- if(inv != NULL)
- {
- std::string wieldlist = puncher->getWieldList();
- ItemStack leftover = inv->addItem(wieldlist, item);
- puncher->setInventoryModified();
- if(leftover.empty())
- m_removed = true;
- }
}
-/*
- Oerkki1SAO
-*/
+LuaEntitySAO::~LuaEntitySAO()
+{
+ if(m_registered){
+ m_env->getScriptIface()->luaentity_Remove(m_id);
+ }
-// Prototype
-Oerkki1SAO proto_Oerkki1SAO(NULL, v3f(0,0,0));
+ for (u32 attached_particle_spawner : m_attached_particle_spawners) {
+ m_env->deleteParticleSpawner(attached_particle_spawner, false);
+ }
+}
-Oerkki1SAO::Oerkki1SAO(ServerEnvironment *env, v3f pos):
- ServerActiveObject(env, pos),
- m_is_active(false),
- m_speed_f(0,0,0)
+void LuaEntitySAO::addedToEnvironment(u32 dtime_s)
{
- ServerActiveObject::registerType(getType(), create);
+ ServerActiveObject::addedToEnvironment(dtime_s);
+
+ // Create entity from name
+ m_registered = m_env->getScriptIface()->
+ luaentity_Add(m_id, m_init_name.c_str());
- m_oldpos = v3f(0,0,0);
- m_last_sent_position = v3f(0,0,0);
- m_yaw = 0;
- m_counter1 = 0;
- m_counter2 = 0;
- m_age = 0;
- m_touching_ground = false;
- m_hp = 20;
- m_after_jump_timer = 0;
+ if(m_registered){
+ // Get properties
+ m_env->getScriptIface()->
+ luaentity_GetProperties(m_id, &m_prop);
+ // Initialize HP from properties
+ m_hp = m_prop.hp_max;
+ // Activate entity, supplying serialized state
+ m_env->getScriptIface()->
+ luaentity_Activate(m_id, m_init_state, dtime_s);
+ } else {
+ m_prop.infotext = m_init_name;
+ }
}
-ServerActiveObject* Oerkki1SAO::create(ServerEnvironment *env, v3f pos,
+ServerActiveObject* LuaEntitySAO::create(ServerEnvironment *env, v3f pos,
const std::string &data)
{
- std::istringstream is(data, std::ios::binary);
- // read version
- u8 version = readU8(is);
- // read hp
- u8 hp = readU8(is);
- // check if version is supported
- if(version != 0)
- return NULL;
- Oerkki1SAO *o = new Oerkki1SAO(env, pos);
- o->m_hp = hp;
- return o;
-}
+ std::string name;
+ std::string state;
+ u16 hp = 1;
+ v3f velocity;
+ v3f rotation;
-void Oerkki1SAO::step(float dtime, bool send_recommended)
-{
- ScopeProfiler sp2(g_profiler, "Oerkki1SAO::step avg", SPT_AVG);
+ while (!data.empty()) { // breakable, run for one iteration
+ std::istringstream is(data, std::ios::binary);
+ // 'version' does not allow to incrementally extend the parameter list thus
+ // we need another variable to build on top of 'version=1'. Ugly hack but works™
+ u8 version2 = 0;
+ u8 version = readU8(is);
- assert(m_env);
+ name = deSerializeString(is);
+ state = deSerializeLongString(is);
- if(m_is_active == false)
- {
- if(m_inactive_interval.step(dtime, 0.5)==false)
- return;
- }
+ if (version < 1)
+ break;
- /*
- The AI
- */
+ hp = readU16(is);
+ velocity = readV3F1000(is);
+ // yaw must be yaw to be backwards-compatible
+ rotation.Y = readF1000(is);
- m_age += dtime;
- if(m_age > 120)
- {
- // Die
- m_removed = true;
- return;
- }
+ if (is.good()) // EOF for old formats
+ version2 = readU8(is);
- m_after_jump_timer -= dtime;
+ if (version2 < 1) // PROTOCOL_VERSION < 37
+ break;
- v3f old_speed = m_speed_f;
+ // version2 >= 1
+ rotation.X = readF1000(is);
+ rotation.Z = readF1000(is);
- // Apply gravity
- m_speed_f.Y -= dtime*9.81*BS;
+ // if (version2 < 2)
+ // break;
+ // <read new values>
+ break;
+ }
+ // create object
+ infostream << "LuaEntitySAO::create(name=\"" << name << "\" state=\""
+ << state << "\")" << std::endl;
+ LuaEntitySAO *sao = new LuaEntitySAO(env, pos, name, state);
+ sao->m_hp = hp;
+ sao->m_velocity = velocity;
+ sao->m_rotation = rotation;
+ return sao;
+}
- /*
- Move around if some player is close
- */
- bool player_is_close = false;
- bool player_is_too_close = false;
- v3f near_player_pos;
- // Check connected players
- core::list<Player*> players = m_env->getPlayers(true);
- core::list<Player*>::Iterator i;
- for(i = players.begin();
- i != players.end(); i++)
+void LuaEntitySAO::step(float dtime, bool send_recommended)
+{
+ if(!m_properties_sent)
{
- Player *player = *i;
- v3f playerpos = player->getPosition();
- f32 dist = m_base_position.getDistanceFrom(playerpos);
- if(dist < BS*0.6)
- {
- m_removed = true;
- return;
- player_is_too_close = true;
- near_player_pos = playerpos;
- }
- else if(dist < BS*15.0 && !player_is_too_close)
- {
- player_is_close = true;
- near_player_pos = playerpos;
- }
+ m_properties_sent = true;
+ std::string str = getPropertyPacket();
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
}
- m_is_active = player_is_close;
+ // 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);
+ }
- v3f target_speed = m_speed_f;
+ m_last_sent_position_timer += dtime;
- if(!player_is_close)
+ // 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())
{
- target_speed = v3f(0,0,0);
+ v3f pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition();
+ m_base_position = pos;
+ m_velocity = v3f(0,0,0);
+ m_acceleration = v3f(0,0,0);
}
else
{
- // Move around
-
- v3f ndir = near_player_pos - m_base_position;
- ndir.Y = 0;
- ndir.normalize();
-
- f32 nyaw = 180./PI*atan2(ndir.Z,ndir.X);
- if(nyaw < m_yaw - 180)
- nyaw += 360;
- else if(nyaw > m_yaw + 180)
- nyaw -= 360;
- m_yaw = 0.95*m_yaw + 0.05*nyaw;
- m_yaw = wrapDegrees(m_yaw);
-
- f32 speed = 2*BS;
-
- if((m_touching_ground || m_after_jump_timer > 0.0)
- && !player_is_too_close)
- {
- v3f dir(cos(m_yaw/180*PI),0,sin(m_yaw/180*PI));
- target_speed.X = speed * dir.X;
- target_speed.Z = speed * dir.Z;
+ if(m_prop.physical){
+ aabb3f box = m_prop.collisionbox;
+ 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;
+ moveresult = collisionMoveSimple(m_env, m_env->getGameDef(),
+ pos_max_d, box, m_prop.stepheight, dtime,
+ &p_pos, &p_velocity, p_acceleration,
+ this, m_prop.collideWithObjects);
+
+ // 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;
}
- if(m_touching_ground && (m_oldpos - m_base_position).getLength()
- < dtime*speed/2)
- {
- m_counter1 -= dtime;
- if(m_counter1 < 0.0)
- {
- m_counter1 += 0.2;
- // Jump
- target_speed.Y = 5.0*BS;
- m_after_jump_timer = 1.0;
+ if (m_prop.automatic_face_movement_dir &&
+ (fabs(m_velocity.Z) > 0.001 || fabs(m_velocity.X) > 0.001)) {
+ float target_yaw = atan2(m_velocity.Z, m_velocity.X) * 180 / M_PI
+ + m_prop.automatic_face_movement_dir_offset;
+ float max_rotation_per_sec =
+ m_prop.automatic_face_movement_max_rotation_per_sec;
+
+ if (max_rotation_per_sec > 0) {
+ m_rotation.Y = wrapDegrees_0_360(m_rotation.Y);
+ wrappedApproachShortest(m_rotation.Y, target_yaw,
+ dtime * max_rotation_per_sec, 360.f);
+ } else {
+ // Negative values of max_rotation_per_sec mean disabled.
+ m_rotation.Y = target_yaw;
}
}
+ }
- {
- m_counter2 -= dtime;
- if(m_counter2 < 0.0)
- {
- m_counter2 += (float)(myrand()%100)/100*3.0;
- //m_yaw += ((float)(myrand()%200)-100)/100*180;
- m_yaw += ((float)(myrand()%200)-100)/100*90;
- m_yaw = wrapDegrees(m_yaw);
- }
- }
+ if(m_registered){
+ m_env->getScriptIface()->luaentity_Step(m_id, dtime);
}
-
- if((m_speed_f - target_speed).getLength() > BS*4 || player_is_too_close)
- accelerate_xz(m_speed_f, target_speed, dtime*BS*8);
- else
- accelerate_xz(m_speed_f, target_speed, dtime*BS*4);
-
- m_oldpos = m_base_position;
- /*
- Move it, with collision detection
- */
+ if (!send_recommended)
+ return;
- core::aabbox3d<f32> box(-BS/3.,0.0,-BS/3., BS/3.,BS*5./3.,BS/3.);
- collisionMoveResult moveresult;
- // Maximum movement without glitches
- f32 pos_max_d = BS*0.25;
- /*// Limit speed
- if(m_speed_f.getLength()*dtime > pos_max_d)
- m_speed_f *= pos_max_d / (m_speed_f.getLength()*dtime);*/
- v3f pos_f = getBasePosition();
- v3f pos_f_old = pos_f;
- IGameDef *gamedef = m_env->getGameDef();
- moveresult = collisionMovePrecise(&m_env->getMap(), gamedef,
- pos_max_d, box, dtime, pos_f, m_speed_f);
- m_touching_ground = moveresult.touching_ground;
-
- // Do collision damage
- float tolerance = BS*30;
- float factor = BS*0.5;
- v3f speed_diff = old_speed - m_speed_f;
- // Increase effect in X and Z
- speed_diff.X *= 2;
- speed_diff.Z *= 2;
- float vel = speed_diff.getLength();
- if(vel > tolerance)
+ if(!isAttached())
{
- f32 damage_f = (vel - tolerance)/BS*factor;
- u16 damage = (u16)(damage_f+0.5);
- doDamage(damage);
+ // 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 ||
+ std::fabs(m_rotation.X - m_last_sent_rotation.X) > 1.0f ||
+ std::fabs(m_rotation.Y - m_last_sent_rotation.Y) > 1.0f ||
+ std::fabs(m_rotation.Z - m_last_sent_rotation.Z) > 1.0f) {
+
+ sendPosition(true, false);
+ }
}
- setBasePosition(pos_f);
+ if (!m_armor_groups_sent) {
+ m_armor_groups_sent = true;
+ std::string str = gob_cmd_update_armor_groups(
+ m_armor_groups);
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
+ }
- if(send_recommended == false && m_speed_f.getLength() < 3.0*BS)
- return;
+ 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);
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
+ }
- if(pos_f.getDistanceFrom(m_last_sent_position) > 0.05*BS)
- {
- m_last_sent_position = pos_f;
-
- std::ostringstream os(std::ios::binary);
- // command (0 = update position)
- writeU8(os, 0);
- // pos
- writeV3F1000(os, m_base_position);
- // yaw
- writeF1000(os, m_yaw);
+ if (!m_animation_speed_sent) {
+ m_animation_speed_sent = true;
+ std::string str = gob_cmd_update_animation_speed(m_animation_speed);
// create message and add to list
- ActiveObjectMessage aom(getId(), false, os.str());
- m_messages_out.push_back(aom);
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
+ }
+
+ if (!m_bone_position_sent) {
+ m_bone_position_sent = true;
+ for (std::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);
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
+ }
+ }
+
+ if (!m_attachment_sent) {
+ m_attachment_sent = true;
+ std::string str = gob_cmd_update_attachment(m_attachment_parent_id, m_attachment_bone, m_attachment_position, m_attachment_rotation);
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
}
}
-std::string Oerkki1SAO::getClientInitializationData()
+std::string LuaEntitySAO::getClientInitializationData(u16 protocol_version)
{
std::ostringstream os(std::ios::binary);
- // version
- writeU8(os, 0);
- // pos
- writeV3F1000(os, m_base_position);
+
+ // PROTOCOL_VERSION >= 37
+ writeU8(os, 1); // version
+ os << serializeString(""); // name
+ writeU8(os, 0); // is_player
+ writeU16(os, getId()); //id
+ writeV3F32(os, m_base_position);
+ writeV3F32(os, m_rotation);
+ writeU16(os, m_hp);
+
+ 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(
+ m_animation_range, m_animation_speed, m_animation_blend, m_animation_loop)); // 3
+ for (std::unordered_map<std::string, core::vector2d<v3f>>::const_iterator
+ ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii) {
+ msg_os << serializeLongString(gob_cmd_update_bone_position((*ii).first,
+ (*ii).second.X, (*ii).second.Y)); // m_bone_position.size
+ }
+ 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();
+ for (std::unordered_set<int>::const_iterator ii = m_attachment_child_ids.begin();
+ (ii != m_attachment_child_ids.end()); ++ii) {
+ if (ServerActiveObject *obj = m_env->getActiveObject(*ii)) {
+ message_count++;
+ // TODO after a protocol bump: only send the object initialization data
+ // to older clients (superfluous since this message exists)
+ msg_os << serializeLongString(gob_cmd_update_infant(*ii, obj->getSendType(),
+ obj->getClientInitializationData(protocol_version)));
+ }
+ }
+
+ msg_os << serializeLongString(gob_cmd_set_texture_mod(m_current_texture_modifier));
+ message_count++;
+
+ writeU8(os, message_count);
+ os.write(msg_os.str().c_str(), msg_os.str().size());
+
+ // return result
return os.str();
}
-std::string Oerkki1SAO::getStaticData()
+void LuaEntitySAO::getStaticData(std::string *result) const
{
- //infostream<<__FUNCTION_NAME<<std::endl;
+ verbosestream<<FUNCTION_NAME<<std::endl;
std::ostringstream os(std::ios::binary);
- // version
- writeU8(os, 0);
- // hp
- writeU8(os, m_hp);
- return os.str();
+ // version must be 1 to keep backwards-compatibility. See version2
+ writeU8(os, 1);
+ // name
+ os<<serializeString(m_init_name);
+ // state
+ if(m_registered){
+ std::string state = m_env->getScriptIface()->
+ luaentity_GetStaticdata(m_id);
+ os<<serializeLongString(state);
+ } else {
+ os<<serializeLongString(m_init_state);
+ }
+ writeU16(os, m_hp);
+ writeV3F1000(os, m_velocity);
+ // yaw
+ writeF1000(os, m_rotation.Y);
+
+ // version2. Increase this variable for new values
+ writeU8(os, 1); // PROTOCOL_VERSION >= 37
+
+ writeF1000(os, m_rotation.X);
+ writeF1000(os, m_rotation.Z);
+
+ // <write new values>
+
+ *result = os.str();
}
-void Oerkki1SAO::punch(ServerActiveObject *puncher, float time_from_last_punch)
+int LuaEntitySAO::punch(v3f dir,
+ const ToolCapabilities *toolcap,
+ ServerActiveObject *puncher,
+ float time_from_last_punch)
{
- if(!puncher)
- return;
-
- v3f dir = (getBasePosition() - puncher->getBasePosition()).normalize();
- m_speed_f += dir*12*BS;
+ if (!m_registered) {
+ // Delete unknown LuaEntities when punched
+ m_pending_removal = true;
+ return 0;
+ }
- // "Material" groups of the object
- std::map<std::string, int> groups;
- groups["snappy"] = 1;
- groups["choppy"] = 1;
- groups["fleshy"] = 3;
+ FATAL_ERROR_IF(!puncher, "Punch action called without SAO");
- IItemDefManager *idef = m_env->getGameDef()->idef();
- ItemStack punchitem = puncher->getWieldedItem();
- ToolCapabilities tp = punchitem.getToolCapabilities(idef);
+ s32 old_hp = getHP();
+ const ItemStack &punchitem = puncher->getWieldedItem();
- HitParams hit_params = getHitParams(groups, &tp,
+ PunchDamageResult result = getPunchDamage(
+ m_armor_groups,
+ toolcap,
+ &punchitem,
time_from_last_punch);
- doDamage(hit_params.hp);
- if(g_settings->getBool("creative_mode") == false)
- {
- punchitem.addWear(hit_params.wear, idef);
- puncher->setWieldedItem(punchitem);
+ bool damage_handled = m_env->getScriptIface()->luaentity_Punch(m_id, puncher,
+ time_from_last_punch, toolcap, dir, result.did_punch ? result.damage : 0);
+
+ if (!damage_handled) {
+ if (result.did_punch) {
+ setHP((s32)getHP() - result.damage,
+ PlayerHPChangeReason(PlayerHPChangeReason::SET_HP));
+
+ std::string str = gob_cmd_punched(getHP());
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
+ }
+ }
+
+ if (getHP() == 0 && !isGone()) {
+ m_pending_removal = true;
+ clearParentAttachment();
+ clearChildAttachments();
+ m_env->getScriptIface()->luaentity_on_death(m_id, puncher);
}
+
+ actionstream << puncher->getDescription() << " (id=" << puncher->getId() <<
+ ", hp=" << puncher->getHP() << ") punched " <<
+ getDescription() << " (id=" << m_id << ", hp=" << m_hp <<
+ "), damage=" << (old_hp - (s32)getHP()) <<
+ (damage_handled ? " (handled by Lua)" : "") << std::endl;
+
+ return result.wear;
}
-void Oerkki1SAO::doDamage(u16 d)
+void LuaEntitySAO::rightClick(ServerActiveObject *clicker)
{
- infostream<<"oerkki damage: "<<d<<std::endl;
-
- if(d < m_hp)
- {
- m_hp -= d;
- }
- else
- {
- // Die
- m_hp = 0;
- m_removed = true;
- }
+ if (!m_registered)
+ return;
- {
- std::ostringstream os(std::ios::binary);
- // command (1 = damage)
- writeU8(os, 1);
- // amount
- writeU8(os, d);
- // create message and add to list
- ActiveObjectMessage aom(getId(), false, os.str());
- m_messages_out.push_back(aom);
- }
+ m_env->getScriptIface()->luaentity_Rightclick(m_id, clicker);
}
-/*
- FireflySAO
-*/
+void LuaEntitySAO::setPos(const v3f &pos)
+{
+ if(isAttached())
+ return;
+ m_base_position = pos;
+ sendPosition(false, true);
+}
-// Prototype
-FireflySAO proto_FireflySAO(NULL, v3f(0,0,0));
+void LuaEntitySAO::moveTo(v3f pos, bool continuous)
+{
+ if(isAttached())
+ return;
+ m_base_position = pos;
+ if(!continuous)
+ sendPosition(true, true);
+}
+
+float LuaEntitySAO::getMinimumSavedMovement()
+{
+ return 0.1 * BS;
+}
-FireflySAO::FireflySAO(ServerEnvironment *env, v3f pos):
- ServerActiveObject(env, pos),
- m_is_active(false),
- m_speed_f(0,0,0)
+std::string LuaEntitySAO::getDescription()
{
- ServerActiveObject::registerType(getType(), create);
+ 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<<")";
+ return os.str();
+}
- m_oldpos = v3f(0,0,0);
- m_last_sent_position = v3f(0,0,0);
- m_yaw = 0;
- m_counter1 = 0;
- m_counter2 = 0;
- m_age = 0;
- m_touching_ground = false;
+void LuaEntitySAO::setHP(s32 hp, const PlayerHPChangeReason &reason)
+{
+ m_hp = rangelim(hp, 0, U16_MAX);
}
-ServerActiveObject* FireflySAO::create(ServerEnvironment *env, v3f pos,
- const std::string &data)
+u16 LuaEntitySAO::getHP() const
{
- std::istringstream is(data, std::ios::binary);
- char buf[1];
- // read version
- is.read(buf, 1);
- u8 version = buf[0];
- // check if version is supported
- if(version != 0)
- return NULL;
- return new FireflySAO(env, pos);
+ return m_hp;
}
-void FireflySAO::step(float dtime, bool send_recommended)
+void LuaEntitySAO::setVelocity(v3f velocity)
{
- ScopeProfiler sp2(g_profiler, "FireflySAO::step avg", SPT_AVG);
+ m_velocity = velocity;
+}
- assert(m_env);
+v3f LuaEntitySAO::getVelocity()
+{
+ return m_velocity;
+}
- if(m_is_active == false)
- {
- if(m_inactive_interval.step(dtime, 0.5)==false)
- return;
- }
+void LuaEntitySAO::setAcceleration(v3f acceleration)
+{
+ m_acceleration = acceleration;
+}
- /*
- The AI
- */
+v3f LuaEntitySAO::getAcceleration()
+{
+ return m_acceleration;
+}
- // Apply (less) gravity
- m_speed_f.Y -= dtime*3*BS;
+void LuaEntitySAO::setTextureMod(const std::string &mod)
+{
+ std::string str = gob_cmd_set_texture_mod(mod);
+ m_current_texture_modifier = mod;
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
+}
- /*
- Move around if some player is close
- */
- bool player_is_close = false;
- // Check connected players
- core::list<Player*> players = m_env->getPlayers(true);
- core::list<Player*>::Iterator i;
- for(i = players.begin();
- i != players.end(); i++)
- {
- Player *player = *i;
- v3f playerpos = player->getPosition();
- if(m_base_position.getDistanceFrom(playerpos) < BS*10.0)
- {
- player_is_close = true;
- break;
- }
- }
+std::string LuaEntitySAO::getTextureMod() const
+{
+ return m_current_texture_modifier;
+}
- m_is_active = player_is_close;
-
- if(player_is_close == false)
- {
- m_speed_f.X = 0;
- m_speed_f.Z = 0;
- }
- else
- {
- // Move around
- v3f dir(cos(m_yaw/180*PI),0,sin(m_yaw/180*PI));
- f32 speed = BS/2;
- m_speed_f.X = speed * dir.X;
- m_speed_f.Z = speed * dir.Z;
-
- if(m_touching_ground && (m_oldpos - m_base_position).getLength()
- < dtime*speed/2)
- {
- m_counter1 -= dtime;
- if(m_counter1 < 0.0)
- {
- m_counter1 += 1.0;
- m_speed_f.Y = 5.0*BS;
- }
- }
+void LuaEntitySAO::setSprite(v2s16 p, int num_frames, float framelength,
+ bool select_horiz_by_yawpitch)
+{
+ std::string str = gob_cmd_set_sprite(
+ p,
+ num_frames,
+ framelength,
+ select_horiz_by_yawpitch
+ );
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
+}
- {
- m_counter2 -= dtime;
- if(m_counter2 < 0.0)
- {
- m_counter2 += (float)(myrand()%100)/100*3.0;
- m_yaw += ((float)(myrand()%200)-100)/100*180;
- m_yaw = wrapDegrees(m_yaw);
- }
- }
- }
-
- m_oldpos = m_base_position;
+std::string LuaEntitySAO::getName()
+{
+ return m_init_name;
+}
- /*
- Move it, with collision detection
- */
+std::string LuaEntitySAO::getPropertyPacket()
+{
+ return gob_cmd_set_properties(m_prop);
+}
- core::aabbox3d<f32> box(-BS/3.,-BS*2/3.0,-BS/3., BS/3.,BS*4./3.,BS/3.);
- collisionMoveResult moveresult;
- // Maximum movement without glitches
- f32 pos_max_d = BS*0.25;
- // Limit speed
- if(m_speed_f.getLength()*dtime > pos_max_d)
- m_speed_f *= pos_max_d / (m_speed_f.getLength()*dtime);
- v3f pos_f = getBasePosition();
- v3f pos_f_old = pos_f;
- IGameDef *gamedef = m_env->getGameDef();
- moveresult = collisionMoveSimple(&m_env->getMap(), gamedef,
- pos_max_d, box, dtime, pos_f, m_speed_f);
- m_touching_ground = moveresult.touching_ground;
-
- setBasePosition(pos_f);
-
- if(send_recommended == false)
+void LuaEntitySAO::sendPosition(bool do_interpolate, bool is_movement_end)
+{
+ // If the object is attached client-side, don't waste bandwidth sending its position to clients
+ if(isAttached())
return;
- if(pos_f.getDistanceFrom(m_last_sent_position) > 0.05*BS)
+ m_last_sent_move_precision = m_base_position.getDistanceFrom(
+ m_last_sent_position);
+ m_last_sent_position_timer = 0;
+ m_last_sent_position = m_base_position;
+ m_last_sent_velocity = m_velocity;
+ //m_last_sent_acceleration = m_acceleration;
+ m_last_sent_rotation = m_rotation;
+
+ float update_interval = m_env->getSendRecommendedInterval();
+
+ std::string str = gob_cmd_update_position(
+ m_base_position,
+ m_velocity,
+ m_acceleration,
+ m_rotation,
+ do_interpolate,
+ is_movement_end,
+ update_interval
+ );
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), false, str);
+ m_messages_out.push(aom);
+}
+
+bool LuaEntitySAO::getCollisionBox(aabb3f *toset) const
+{
+ if (m_prop.physical)
{
- m_last_sent_position = pos_f;
-
- std::ostringstream os(std::ios::binary);
- // command (0 = update position)
- writeU8(os, 0);
- // pos
- writeV3F1000(os, m_base_position);
- // yaw
- writeF1000(os, m_yaw);
- // create message and add to list
- ActiveObjectMessage aom(getId(), false, os.str());
- m_messages_out.push_back(aom);
+ //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;
+}
+
+bool LuaEntitySAO::getSelectionBox(aabb3f *toset) const
+{
+ if (!m_prop.is_visible || !m_prop.pointable) {
+ return false;
}
-}
-std::string FireflySAO::getClientInitializationData()
-{
- std::ostringstream os(std::ios::binary);
- // version
- writeU8(os, 0);
- // pos
- writeV3F1000(os, m_base_position);
- return os.str();
+ toset->MinEdge = m_prop.selectionbox.MinEdge * BS;
+ toset->MaxEdge = m_prop.selectionbox.MaxEdge * BS;
+
+ return true;
}
-std::string FireflySAO::getStaticData()
+bool LuaEntitySAO::collideWithObjects() const
{
- //infostream<<__FUNCTION_NAME<<std::endl;
- std::ostringstream os(std::ios::binary);
- // version
- writeU8(os, 0);
- return os.str();
+ return m_prop.collideWithObjects;
}
/*
- MobV2SAO
+ PlayerSAO
*/
-// Prototype
-MobV2SAO proto_MobV2SAO(NULL, v3f(0,0,0), NULL);
-
-MobV2SAO::MobV2SAO(ServerEnvironment *env, v3f pos,
- Settings *init_properties):
- ServerActiveObject(env, pos),
- m_move_type("ground_nodes"),
- m_speed(0,0,0),
- m_last_sent_position(0,0,0),
- m_oldpos(0,0,0),
- m_yaw(0),
- m_counter1(0),
- m_counter2(0),
- m_age(0),
- m_touching_ground(false),
- m_hp(10),
- m_walk_around(false),
- m_walk_around_timer(0),
- m_next_pos_exists(false),
- m_shoot_reload_timer(0),
- m_shooting(false),
- m_shooting_timer(0),
- m_falling(false),
- m_disturb_timer(100000),
- m_random_disturb_timer(0),
- m_shoot_y(0)
-{
- ServerActiveObject::registerType(getType(), create);
-
- m_properties = new Settings();
- if(init_properties)
- m_properties->update(*init_properties);
-
- m_properties->setV3F("pos", pos);
-
- setPropertyDefaults();
- readProperties();
-}
-
-MobV2SAO::~MobV2SAO()
-{
- delete m_properties;
-}
-
-ServerActiveObject* MobV2SAO::create(ServerEnvironment *env, v3f pos,
- const std::string &data)
-{
- std::istringstream is(data, std::ios::binary);
- Settings properties;
- properties.parseConfigLines(is, "MobArgsEnd");
- MobV2SAO *o = new MobV2SAO(env, pos, &properties);
- return o;
-}
+// No prototype, PlayerSAO does not need to be deserialized
-std::string MobV2SAO::getStaticData()
+PlayerSAO::PlayerSAO(ServerEnvironment *env_, RemotePlayer *player_, session_t peer_id_,
+ bool is_singleplayer):
+ UnitSAO(env_, v3f(0,0,0)),
+ m_player(player_),
+ m_peer_id(peer_id_),
+ m_is_singleplayer(is_singleplayer)
{
- updateProperties();
+ assert(m_peer_id != 0); // pre-condition
- std::ostringstream os(std::ios::binary);
- m_properties->writeLines(os);
- return os.str();
+ m_prop.hp_max = PLAYER_MAX_HP_DEFAULT;
+ m_prop.breath_max = PLAYER_MAX_BREATH_DEFAULT;
+ m_prop.physical = false;
+ m_prop.weight = 75;
+ m_prop.collisionbox = aabb3f(-0.3f, 0.0f, -0.3f, 0.3f, 1.77f, 0.3f);
+ m_prop.selectionbox = aabb3f(-0.3f, 0.0f, -0.3f, 0.3f, 1.77f, 0.3f);
+ m_prop.pointable = true;
+ // Start of default appearance, this should be overwritten by Lua
+ m_prop.visual = "upright_sprite";
+ m_prop.visual_size = v3f(1, 2, 1);
+ m_prop.textures.clear();
+ m_prop.textures.emplace_back("player.png");
+ m_prop.textures.emplace_back("player_back.png");
+ m_prop.colors.clear();
+ m_prop.colors.emplace_back(255, 255, 255, 255);
+ m_prop.spritediv = v2s16(1,1);
+ m_prop.eye_height = 1.625f;
+ // End of default appearance
+ m_prop.is_visible = true;
+ m_prop.backface_culling = false;
+ m_prop.makes_footstep_sound = true;
+ m_prop.stepheight = PLAYER_DEFAULT_STEPHEIGHT * BS;
+ m_hp = m_prop.hp_max;
+ m_breath = m_prop.breath_max;
+ // Disable zoom in survival mode using a value of 0
+ m_prop.zoom_fov = g_settings->getBool("creative_mode") ? 15.0f : 0.0f;
+
+ if (!g_settings->getBool("enable_damage"))
+ m_armor_groups["immortal"] = 1;
}
-std::string MobV2SAO::getClientInitializationData()
+PlayerSAO::~PlayerSAO()
{
- //infostream<<__FUNCTION_NAME<<std::endl;
-
- updateProperties();
-
- std::ostringstream os(std::ios::binary);
-
- // version
- writeU8(os, 0);
-
- Settings client_properties;
-
- /*client_properties.set("version", "0");
- client_properties.updateValue(*m_properties, "pos");
- client_properties.updateValue(*m_properties, "yaw");
- client_properties.updateValue(*m_properties, "hp");*/
-
- // Just send everything for simplicity
- client_properties.update(*m_properties);
-
- std::ostringstream os2(std::ios::binary);
- client_properties.writeLines(os2);
- compressZlib(os2.str(), os);
-
- return os.str();
+ if(m_inventory != &m_player->inventory)
+ delete m_inventory;
}
-bool checkFreePosition(Map *map, v3s16 p0, v3s16 size)
+void PlayerSAO::finalize(RemotePlayer *player, const std::set<std::string> &privs)
{
- for(int dx=0; dx<size.X; dx++)
- for(int dy=0; dy<size.Y; dy++)
- for(int dz=0; dz<size.Z; dz++){
- v3s16 dp(dx, dy, dz);
- v3s16 p = p0 + dp;
- MapNode n = map->getNodeNoEx(p);
- if(n.getContent() != CONTENT_AIR)
- return false;
- }
- return true;
+ assert(player);
+ m_player = player;
+ m_privs = privs;
+ m_inventory = &m_player->inventory;
}
-bool checkWalkablePosition(Map *map, v3s16 p0)
+v3f PlayerSAO::getEyeOffset() const
{
- v3s16 p = p0 + v3s16(0,-1,0);
- MapNode n = map->getNodeNoEx(p);
- if(n.getContent() != CONTENT_AIR)
- return true;
- return false;
+ return v3f(0, BS * m_prop.eye_height, 0);
}
-bool checkFreeAndWalkablePosition(Map *map, v3s16 p0, v3s16 size)
+std::string PlayerSAO::getDescription()
{
- if(!checkFreePosition(map, p0, size))
- return false;
- if(!checkWalkablePosition(map, p0))
- return false;
- return true;
+ return std::string("player ") + m_player->getName();
}
-static void get_random_u32_array(u32 a[], u32 len)
+// Called after id has been set and has been inserted in environment
+void PlayerSAO::addedToEnvironment(u32 dtime_s)
{
- u32 i, n;
- for(i=0; i<len; i++)
- a[i] = i;
- n = len;
- while(n > 1){
- u32 k = myrand() % n;
- n--;
- u32 temp = a[n];
- a[n] = a[k];
- a[k] = temp;
- }
+ ServerActiveObject::addedToEnvironment(dtime_s);
+ ServerActiveObject::setBasePosition(m_base_position);
+ m_player->setPlayerSAO(this);
+ m_player->setPeerId(m_peer_id);
+ m_last_good_position = m_base_position;
}
-#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
-
-static void explodeSquare(Map *map, v3s16 p0, v3s16 size)
+// Called before removing from environment
+void PlayerSAO::removingFromEnvironment()
{
- core::map<v3s16, MapBlock*> modified_blocks;
-
- for(int dx=0; dx<size.X; dx++)
- for(int dy=0; dy<size.Y; dy++)
- for(int dz=0; dz<size.Z; dz++){
- v3s16 dp(dx - size.X/2, dy - size.Y/2, dz - size.Z/2);
- v3s16 p = p0 + dp;
- MapNode n = map->getNodeNoEx(p);
- if(n.getContent() == CONTENT_IGNORE)
- continue;
- //map->removeNodeWithEvent(p);
- map->removeNodeAndUpdate(p, modified_blocks);
- }
-
- // Send a MEET_OTHER event
- MapEditEvent event;
- event.type = MEET_OTHER;
- for(core::map<v3s16, MapBlock*>::Iterator
- i = modified_blocks.getIterator();
- i.atEnd() == false; i++)
- {
- v3s16 p = i.getNode()->getKey();
- event.modified_blocks.insert(p, true);
+ ServerActiveObject::removingFromEnvironment();
+ if (m_player->getPlayerSAO() == this) {
+ unlinkPlayerSessionAndSave();
+ for (u32 attached_particle_spawner : m_attached_particle_spawners) {
+ m_env->deleteParticleSpawner(attached_particle_spawner, false);
+ }
}
- map->dispatchEvent(&event);
}
-void MobV2SAO::step(float dtime, bool send_recommended)
+std::string PlayerSAO::getClientInitializationData(u16 protocol_version)
{
- ScopeProfiler sp2(g_profiler, "MobV2SAO::step avg", SPT_AVG);
-
- assert(m_env);
- Map *map = &m_env->getMap();
-
- m_age += dtime;
+ std::ostringstream os(std::ios::binary);
- if(m_die_age >= 0.0 && m_age >= m_die_age){
- m_removed = true;
- return;
+ // Protocol >= 15
+ writeU8(os, 1); // version
+ os << serializeString(m_player->getName()); // name
+ writeU8(os, 1); // is_player
+ writeS16(os, getId()); // id
+ writeV3F32(os, m_base_position);
+ writeV3F32(os, m_rotation);
+ writeU16(os, getHP());
+
+ 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(
+ m_animation_range, m_animation_speed, m_animation_blend, m_animation_loop)); // 3
+ for (std::unordered_map<std::string, core::vector2d<v3f>>::const_iterator
+ ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii) {
+ msg_os << serializeLongString(gob_cmd_update_bone_position((*ii).first,
+ (*ii).second.X, (*ii).second.Y)); // m_bone_position.size
}
-
- m_random_disturb_timer += dtime;
- if(m_random_disturb_timer >= 5.0)
- {
- m_random_disturb_timer = 0;
- // Check connected players
- core::list<Player*> players = m_env->getPlayers(true);
- core::list<Player*>::Iterator i;
- for(i = players.begin();
- i != players.end(); i++)
- {
- Player *player = *i;
- v3f playerpos = player->getPosition();
- f32 dist = m_base_position.getDistanceFrom(playerpos);
- if(dist < BS*16)
- {
- if(myrand_range(0,3) == 0){
- actionstream<<"Mob id="<<m_id<<" at "
- <<PP(m_base_position/BS)
- <<" got randomly disturbed by "
- <<player->getName()<<std::endl;
- m_disturbing_player = player->getName();
- m_disturb_timer = 0;
- break;
- }
- }
+ 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,
+ m_physics_override_jump, m_physics_override_gravity, m_physics_override_sneak,
+ m_physics_override_sneak_glitch, m_physics_override_new_move)); // 5
+ // (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();
+ for (std::unordered_set<int>::const_iterator ii = m_attachment_child_ids.begin();
+ ii != m_attachment_child_ids.end(); ++ii) {
+ if (ServerActiveObject *obj = m_env->getActiveObject(*ii)) {
+ message_count++;
+ msg_os << serializeLongString(gob_cmd_update_infant(*ii, obj->getSendType(),
+ obj->getClientInitializationData(protocol_version)));
}
}
- Player *disturbing_player =
- m_env->getPlayer(m_disturbing_player.c_str());
- v3f disturbing_player_off = v3f(0,1,0);
- v3f disturbing_player_norm = v3f(0,1,0);
- float disturbing_player_distance = 1000000;
- float disturbing_player_dir = 0;
- if(disturbing_player){
- disturbing_player_off =
- disturbing_player->getPosition() - m_base_position;
- disturbing_player_distance = disturbing_player_off.getLength();
- disturbing_player_norm = disturbing_player_off;
- disturbing_player_norm.normalize();
- disturbing_player_dir = 180./PI*atan2(disturbing_player_norm.Z,
- disturbing_player_norm.X);
- }
-
- m_disturb_timer += dtime;
-
- if(!m_falling)
- {
- m_shooting_timer -= dtime;
- if(m_shooting_timer <= 0.0 && m_shooting){
- m_shooting = false;
-
- std::string shoot_type = m_properties->get("shoot_type");
- v3f shoot_pos(0,0,0);
- shoot_pos.Y += m_properties->getFloat("shoot_y") * BS;
- if(shoot_type == "fireball"){
- v3f dir(cos(m_yaw/180*PI),0,sin(m_yaw/180*PI));
- dir.Y = m_shoot_y;
- dir.normalize();
- v3f speed = dir * BS * 10.0;
- v3f pos = m_base_position + shoot_pos;
- infostream<<__FUNCTION_NAME<<": Mob id="<<m_id
- <<" shooting fireball from "<<PP(pos)
- <<" at speed "<<PP(speed)<<std::endl;
- Settings properties;
- properties.set("looks", "fireball");
- properties.setV3F("speed", speed);
- properties.setFloat("die_age", 5.0);
- properties.set("move_type", "constant_speed");
- properties.setFloat("hp", 1000);
- properties.set("lock_full_brightness", "true");
- properties.set("player_hit_damage", "9");
- properties.set("player_hit_distance", "2");
- properties.set("player_hit_interval", "1");
- ServerActiveObject *obj = new MobV2SAO(m_env,
- pos, &properties);
- //m_env->addActiveObjectAsStatic(obj);
- m_env->addActiveObject(obj);
- } else {
- infostream<<__FUNCTION_NAME<<": Mob id="<<m_id
- <<": Unknown shoot_type="<<shoot_type
- <<std::endl;
- }
- }
+ writeU8(os, message_count);
+ os.write(msg_os.str().c_str(), msg_os.str().size());
- m_shoot_reload_timer += dtime;
+ // return result
+ return os.str();
+}
- float reload_time = 15.0;
- if(m_disturb_timer <= 15.0)
- reload_time = 3.0;
+void PlayerSAO::getStaticData(std::string * result) const
+{
+ FATAL_ERROR("Deprecated function");
+}
- bool shoot_without_player = false;
- if(m_properties->getBool("mindless_rage"))
- shoot_without_player = true;
+void PlayerSAO::step(float dtime, bool send_recommended)
+{
+ if (!isImmortal() && m_drowning_interval.step(dtime, 2.0f)) {
+ // Get nose/mouth position, approximate with eye position
+ v3s16 p = floatToInt(getEyePosition(), BS);
+ MapNode n = m_env->getMap().getNodeNoEx(p);
+ const ContentFeatures &c = m_env->getGameDef()->ndef()->get(n);
+ // If node generates drown
+ if (c.drowning > 0 && m_hp > 0) {
+ if (m_breath > 0)
+ setBreath(m_breath - 1);
- if(!m_shooting && m_shoot_reload_timer >= reload_time &&
- !m_next_pos_exists &&
- (m_disturb_timer <= 60.0 || shoot_without_player))
- {
- m_shoot_y = 0;
- if(m_disturb_timer < 60.0 && disturbing_player &&
- disturbing_player_distance < 16*BS &&
- fabs(disturbing_player_norm.Y) < 0.8){
- m_yaw = disturbing_player_dir;
- sendPosition();
- m_shoot_y += disturbing_player_norm.Y;
- } else {
- m_shoot_y = 0.01 * myrand_range(-30,10);
- }
- m_shoot_reload_timer = 0.0;
- m_shooting = true;
- m_shooting_timer = 1.5;
- {
- std::ostringstream os(std::ios::binary);
- // command (2 = shooting)
- writeU8(os, 2);
- // time
- writeF1000(os, m_shooting_timer + 0.1);
- // bright?
- writeU8(os, true);
- // create message and add to list
- ActiveObjectMessage aom(getId(), false, os.str());
- m_messages_out.push_back(aom);
+ // No more breath, damage player
+ if (m_breath == 0) {
+ PlayerHPChangeReason reason(PlayerHPChangeReason::DROWNING);
+ setHP(m_hp - c.drowning, reason);
+ m_env->getGameDef()->SendPlayerHPOrDie(this, reason);
}
}
}
-
- if(m_move_type == "ground_nodes")
- {
- if(!m_shooting){
- m_walk_around_timer -= dtime;
- if(m_walk_around_timer <= 0.0){
- m_walk_around = !m_walk_around;
- if(m_walk_around)
- m_walk_around_timer = 0.1*myrand_range(10,50);
- else
- m_walk_around_timer = 0.1*myrand_range(30,70);
- }
- }
- /* Move */
- if(m_next_pos_exists){
- v3f pos_f = m_base_position;
- v3f next_pos_f = intToFloat(m_next_pos_i, BS);
-
- v3f v = next_pos_f - pos_f;
- m_yaw = atan2(v.Z, v.X) / PI * 180;
-
- v3f diff = next_pos_f - pos_f;
- v3f dir = diff;
- dir.normalize();
- float speed = BS * 0.5;
- if(m_falling)
- speed = BS * 3.0;
- dir *= dtime * speed;
- bool arrived = false;
- if(dir.getLength() > diff.getLength()){
- dir = diff;
- arrived = true;
- }
- pos_f += dir;
- m_base_position = pos_f;
+ if (m_breathing_interval.step(dtime, 0.5f)) {
+ // Get nose/mouth position, approximate with eye position
+ v3s16 p = floatToInt(getEyePosition(), BS);
+ MapNode n = m_env->getMap().getNodeNoEx(p);
+ const ContentFeatures &c = m_env->getGameDef()->ndef()->get(n);
+ // If player is alive & no drowning & not in ignore, breathe
+ if (m_breath < m_prop.breath_max &&
+ c.drowning == 0 && n.getContent() != CONTENT_IGNORE && m_hp > 0)
+ setBreath(m_breath + 1);
+ }
- if((pos_f - next_pos_f).getLength() < 0.1 || arrived){
- m_next_pos_exists = false;
+ if (!isImmortal() && m_node_hurt_interval.step(dtime, 1.0f)) {
+ u32 damage_per_second = 0;
+ std::string nodename;
+ // Lowest and highest damage points are 0.1 within collisionbox
+ float dam_top = m_prop.collisionbox.MaxEdge.Y - 0.1f;
+
+ // Sequence of damage points, starting 0.1 above feet and progressing
+ // upwards in 1 node intervals, stopping below top damage point.
+ for (float dam_height = 0.1f; dam_height < dam_top; dam_height++) {
+ v3s16 p = floatToInt(m_base_position +
+ v3f(0.0f, dam_height * BS, 0.0f), BS);
+ MapNode n = m_env->getMap().getNodeNoEx(p);
+ const ContentFeatures &c = m_env->getGameDef()->ndef()->get(n);
+ if (c.damage_per_second > damage_per_second) {
+ damage_per_second = c.damage_per_second;
+ nodename = c.name;
}
}
- v3s16 pos_i = floatToInt(m_base_position, BS);
- v3s16 size_blocks = v3s16(m_size.X+0.5,m_size.Y+0.5,m_size.X+0.5);
- v3s16 pos_size_off(0,0,0);
- if(m_size.X >= 2.5){
- pos_size_off.X = -1;
- pos_size_off.Y = -1;
- }
-
- if(!m_next_pos_exists){
- /* Check whether to drop down */
- if(checkFreePosition(map,
- pos_i + pos_size_off + v3s16(0,-1,0), size_blocks)){
- m_next_pos_i = pos_i + v3s16(0,-1,0);
- m_next_pos_exists = true;
- m_falling = true;
- } else {
- m_falling = false;
- }
+ // Top damage point
+ v3s16 ptop = floatToInt(m_base_position +
+ v3f(0.0f, dam_top * BS, 0.0f), BS);
+ MapNode ntop = m_env->getMap().getNodeNoEx(ptop);
+ const ContentFeatures &c = m_env->getGameDef()->ndef()->get(ntop);
+ if (c.damage_per_second > damage_per_second) {
+ damage_per_second = c.damage_per_second;
+ nodename = c.name;
}
- if(m_walk_around)
- {
- if(!m_next_pos_exists){
- /* Find some position where to go next */
- v3s16 dps[3*3*3];
- int num_dps = 0;
- for(int dx=-1; dx<=1; dx++)
- for(int dy=-1; dy<=1; dy++)
- for(int dz=-1; dz<=1; dz++){
- if(dx == 0 && dy == 0)
- continue;
- if(dx != 0 && dz != 0 && dy != 0)
- continue;
- dps[num_dps++] = v3s16(dx,dy,dz);
- }
- u32 order[3*3*3];
- get_random_u32_array(order, num_dps);
- for(int i=0; i<num_dps; i++){
- v3s16 p = dps[order[i]] + pos_i;
- bool is_free = checkFreeAndWalkablePosition(map,
- p + pos_size_off, size_blocks);
- if(!is_free)
- continue;
- m_next_pos_i = p;
- m_next_pos_exists = true;
- break;
- }
- }
- }
- }
- else if(m_move_type == "constant_speed")
- {
- m_base_position += m_speed * dtime;
-
- v3s16 pos_i = floatToInt(m_base_position, BS);
- v3s16 size_blocks = v3s16(m_size.X+0.5,m_size.Y+0.5,m_size.X+0.5);
- v3s16 pos_size_off(0,0,0);
- if(m_size.X >= 2.5){
- pos_size_off.X = -1;
- pos_size_off.Y = -1;
- }
- bool free = checkFreePosition(map, pos_i + pos_size_off, size_blocks);
- if(!free){
- explodeSquare(map, pos_i, v3s16(3,3,3));
- m_removed = true;
- return;
+ if (damage_per_second != 0 && m_hp > 0) {
+ s32 newhp = (s32)m_hp - (s32)damage_per_second;
+ PlayerHPChangeReason reason(PlayerHPChangeReason::NODE_DAMAGE, nodename);
+ setHP(newhp, reason);
+ m_env->getGameDef()->SendPlayerHPOrDie(this, reason);
}
}
- else
- {
- errorstream<<"MobV2SAO::step(): id="<<m_id<<" unknown move_type=\""
- <<m_move_type<<"\""<<std::endl;
+
+ if (!m_properties_sent) {
+ m_properties_sent = true;
+ std::string str = getPropertyPacket();
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
}
- if(send_recommended == false)
- return;
+ // 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.0f, 0.0f, 0.0f);
+ m_attachment_rotation = v3f(0.0f, 0.0f, 0.0f);
+ setBasePosition(m_last_good_position);
+ m_env->getGameDef()->SendMovePlayer(m_peer_id);
+ }
- if(m_base_position.getDistanceFrom(m_last_sent_position) > 0.05*BS)
- {
- sendPosition();
+ //dstream<<"PlayerSAO::step: dtime: "<<dtime<<std::endl;
+
+ // Set lag pool maximums based on estimated lag
+ const float LAG_POOL_MIN = 5.0f;
+ float lag_pool_max = m_env->getMaxLagEstimate() * 2.0f;
+ 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);
+ m_time_from_last_teleport += dtime;
+ m_time_from_last_punch += dtime;
+ m_nocheat_dig_time += dtime;
+
+ // 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()) {
+ v3f pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition();
+ m_last_good_position = pos;
+ setBasePosition(pos);
}
-}
-void MobV2SAO::punch(ServerActiveObject *puncher, float time_from_last_punch)
-{
- if(!puncher)
+ if (!send_recommended)
return;
-
- v3f dir = (getBasePosition() - puncher->getBasePosition()).normalize();
-
- // A quick hack; SAO description is player name for player
- std::string playername = puncher->getDescription();
-
- Map *map = &m_env->getMap();
-
- actionstream<<playername<<" punches mob id="<<m_id
- <<" at "<<PP(m_base_position/BS)<<std::endl;
-
- m_disturb_timer = 0;
- m_disturbing_player = playername;
- m_next_pos_exists = false; // Cancel moving immediately
-
- m_yaw = wrapDegrees_180(180./PI*atan2(dir.Z, dir.X) + 180.);
- v3f new_base_position = m_base_position + dir * BS;
- {
- v3s16 pos_i = floatToInt(new_base_position, BS);
- v3s16 size_blocks = v3s16(m_size.X+0.5,m_size.Y+0.5,m_size.X+0.5);
- v3s16 pos_size_off(0,0,0);
- if(m_size.X >= 2.5){
- pos_size_off.X = -1;
- pos_size_off.Y = -1;
- }
- bool free = checkFreePosition(map, pos_i + pos_size_off, size_blocks);
- if(free)
- m_base_position = new_base_position;
+
+ // If the object is attached client-side, don't waste bandwidth sending its
+ // position or rotation to clients.
+ if (m_position_not_sent && !isAttached()) {
+ m_position_not_sent = false;
+ float update_interval = m_env->getSendRecommendedInterval();
+ v3f pos;
+ if (isAttached()) // Just in case we ever do send attachment position too
+ pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition();
+ else
+ pos = m_base_position;
+
+ std::string str = gob_cmd_update_position(
+ pos,
+ v3f(0.0f, 0.0f, 0.0f),
+ v3f(0.0f, 0.0f, 0.0f),
+ m_rotation,
+ true,
+ false,
+ update_interval
+ );
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), false, str);
+ m_messages_out.push(aom);
}
- sendPosition();
-
- // "Material" groups of the object
- std::map<std::string, int> groups;
- groups["snappy"] = 1;
- groups["choppy"] = 1;
- groups["fleshy"] = 3;
+ if (!m_armor_groups_sent) {
+ m_armor_groups_sent = true;
+ std::string str = gob_cmd_update_armor_groups(
+ m_armor_groups);
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
+ }
- IItemDefManager *idef = m_env->getGameDef()->idef();
- ItemStack punchitem = puncher->getWieldedItem();
- ToolCapabilities tp = punchitem.getToolCapabilities(idef);
+ 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,
+ m_physics_override_sneak, m_physics_override_sneak_glitch,
+ m_physics_override_new_move);
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
+ }
- HitParams hit_params = getHitParams(groups, &tp,
- time_from_last_punch);
+ 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);
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
+ }
- doDamage(hit_params.hp);
- if(g_settings->getBool("creative_mode") == false)
- {
- punchitem.addWear(hit_params.wear, idef);
- puncher->setWieldedItem(punchitem);
+ if (!m_bone_position_sent) {
+ m_bone_position_sent = true;
+ for (std::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);
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
+ }
}
-}
-bool MobV2SAO::isPeaceful()
-{
- return m_properties->getBool("is_peaceful");
+ if (!m_attachment_sent) {
+ m_attachment_sent = true;
+ std::string str = gob_cmd_update_attachment(m_attachment_parent_id,
+ m_attachment_bone, m_attachment_position, m_attachment_rotation);
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
+ }
}
-void MobV2SAO::sendPosition()
+void PlayerSAO::setBasePosition(const v3f &position)
{
- m_last_sent_position = m_base_position;
+ if (m_player && position != m_base_position)
+ m_player->setDirty(true);
- std::ostringstream os(std::ios::binary);
- // command (0 = update position)
- writeU8(os, 0);
- // pos
- writeV3F1000(os, m_base_position);
- // yaw
- writeF1000(os, m_yaw);
- // create message and add to list
- ActiveObjectMessage aom(getId(), false, os.str());
- m_messages_out.push_back(aom);
-}
-
-void MobV2SAO::setPropertyDefaults()
-{
- m_properties->setDefault("is_peaceful", "false");
- m_properties->setDefault("move_type", "ground_nodes");
- m_properties->setDefault("speed", "(0,0,0)");
- m_properties->setDefault("age", "0");
- m_properties->setDefault("yaw", "0");
- m_properties->setDefault("pos", "(0,0,0)");
- m_properties->setDefault("hp", "0");
- m_properties->setDefault("die_age", "-1");
- m_properties->setDefault("size", "(1,2)");
- m_properties->setDefault("shoot_type", "fireball");
- m_properties->setDefault("shoot_y", "0");
- m_properties->setDefault("mindless_rage", "false");
-}
-void MobV2SAO::readProperties()
-{
- m_move_type = m_properties->get("move_type");
- m_speed = m_properties->getV3F("speed");
- m_age = m_properties->getFloat("age");
- m_yaw = m_properties->getFloat("yaw");
- m_base_position = m_properties->getV3F("pos");
- m_hp = m_properties->getS32("hp");
- m_die_age = m_properties->getFloat("die_age");
- m_size = m_properties->getV2F("size");
-}
-void MobV2SAO::updateProperties()
-{
- m_properties->set("move_type", m_move_type);
- m_properties->setV3F("speed", m_speed);
- m_properties->setFloat("age", m_age);
- m_properties->setFloat("yaw", m_yaw);
- m_properties->setV3F("pos", m_base_position);
- m_properties->setS32("hp", m_hp);
- m_properties->setFloat("die_age", m_die_age);
- m_properties->setV2F("size", m_size);
-
- m_properties->setS32("version", 0);
-}
-
-void MobV2SAO::doDamage(u16 d)
-{
- if(d > 0)
- actionstream<<"MobV2 ("<<m_hp<<"hp) takes "<<d<<"hp of damage"<<std::endl;
-
- if(d < m_hp)
- {
- m_hp -= d;
- }
- else
- {
- actionstream<<"A "<<(isPeaceful()?"peaceful":"non-peaceful")
- <<" mob id="<<m_id<<" dies at "<<PP(m_base_position)<<std::endl;
- // Die
- m_hp = 0;
- m_removed = true;
- }
+ // This needs to be ran for attachments too
+ ServerActiveObject::setBasePosition(position);
- {
- std::ostringstream os(std::ios::binary);
- // command (1 = damage)
- writeU8(os, 1);
- // amount
- writeU16(os, d);
- // create message and add to list
- ActiveObjectMessage aom(getId(), false, os.str());
- m_messages_out.push_back(aom);
+ // Updating is not wanted/required for player migration
+ if (m_env) {
+ m_position_not_sent = true;
}
}
+void PlayerSAO::setPos(const v3f &pos)
+{
+ if(isAttached())
+ return;
-/*
- LuaEntitySAO
-*/
-
-#include "scriptapi.h"
-#include "luaentity_common.h"
+ // Send mapblock of target location
+ v3s16 blockpos = v3s16(pos.X / MAP_BLOCKSIZE, pos.Y / MAP_BLOCKSIZE, pos.Z / MAP_BLOCKSIZE);
+ m_env->getGameDef()->SendBlock(m_peer_id, blockpos);
-// Prototype
-LuaEntitySAO proto_LuaEntitySAO(NULL, v3f(0,0,0), "_prototype", "");
+ setBasePosition(pos);
+ // Movement caused by this command is always valid
+ m_last_good_position = pos;
+ m_move_pool.empty();
+ m_time_from_last_teleport = 0.0;
+ m_env->getGameDef()->SendMovePlayer(m_peer_id);
+}
-LuaEntitySAO::LuaEntitySAO(ServerEnvironment *env, v3f pos,
- const std::string &name, const std::string &state):
- ServerActiveObject(env, pos),
- m_init_name(name),
- m_init_state(state),
- m_registered(false),
- m_prop(new LuaEntityProperties),
- m_velocity(0,0,0),
- m_acceleration(0,0,0),
- m_yaw(0),
- m_last_sent_yaw(0),
- m_last_sent_position(0,0,0),
- m_last_sent_velocity(0,0,0),
- m_last_sent_position_timer(0),
- m_last_sent_move_precision(0)
+void PlayerSAO::moveTo(v3f pos, bool continuous)
{
- // Only register type if no environment supplied
- if(env == NULL){
- ServerActiveObject::registerType(getType(), create);
+ if(isAttached())
return;
- }
+
+ setBasePosition(pos);
+ // Movement caused by this command is always valid
+ m_last_good_position = pos;
+ m_move_pool.empty();
+ m_time_from_last_teleport = 0.0;
+ m_env->getGameDef()->SendMovePlayer(m_peer_id);
}
-LuaEntitySAO::~LuaEntitySAO()
+void PlayerSAO::setPlayerYaw(const float yaw)
{
- if(m_registered){
- lua_State *L = m_env->getLua();
- scriptapi_luaentity_rm(L, m_id);
- }
- delete m_prop;
+ v3f rotation(0, yaw, 0);
+ if (m_player && yaw != m_rotation.Y)
+ m_player->setDirty(true);
+
+ // Set player model yaw, not look view
+ UnitSAO::setRotation(rotation);
}
-void LuaEntitySAO::addedToEnvironment()
+void PlayerSAO::setFov(const float fov)
{
- ServerActiveObject::addedToEnvironment();
-
- // Create entity from name and state
- lua_State *L = m_env->getLua();
- m_registered = scriptapi_luaentity_add(L, m_id, m_init_name.c_str(),
- m_init_state.c_str());
-
- if(m_registered){
- // Get properties
- scriptapi_luaentity_get_properties(L, m_id, m_prop);
- }
+ if (m_player && fov != m_fov)
+ m_player->setDirty(true);
+
+ m_fov = fov;
}
-ServerActiveObject* LuaEntitySAO::create(ServerEnvironment *env, v3f pos,
- const std::string &data)
+void PlayerSAO::setWantedRange(const s16 range)
{
- std::istringstream is(data, std::ios::binary);
- // read version
- u8 version = readU8(is);
- // check if version is supported
- if(version != 0)
- return NULL;
- // read name
- std::string name = deSerializeString(is);
- // read state
- std::string state = deSerializeLongString(is);
- // create object
- infostream<<"LuaEntitySAO::create(name=\""<<name<<"\" state=\""
- <<state<<"\")"<<std::endl;
- return new LuaEntitySAO(env, pos, name, state);
+ if (m_player && range != m_wanted_range)
+ m_player->setDirty(true);
+
+ m_wanted_range = range;
}
-void LuaEntitySAO::step(float dtime, bool send_recommended)
+void PlayerSAO::setPlayerYawAndSend(const float yaw)
{
- m_last_sent_position_timer += dtime;
-
- if(m_prop->physical){
- core::aabbox3d<f32> box = m_prop->collisionbox;
- box.MinEdge *= BS;
- box.MaxEdge *= BS;
- collisionMoveResult moveresult;
- f32 pos_max_d = BS*0.25; // Distance per iteration
- v3f p_pos = getBasePosition();
- v3f p_velocity = m_velocity;
- IGameDef *gamedef = m_env->getGameDef();
- moveresult = collisionMovePrecise(&m_env->getMap(), gamedef,
- pos_max_d, box, dtime, p_pos, p_velocity);
- // Apply results
- setBasePosition(p_pos);
- m_velocity = p_velocity;
-
- m_velocity += dtime * m_acceleration;
- } else {
- m_base_position += dtime * m_velocity + 0.5 * dtime
- * dtime * m_acceleration;
- m_velocity += dtime * m_acceleration;
- }
+ setPlayerYaw(yaw);
+ m_env->getGameDef()->SendMovePlayer(m_peer_id);
+}
- if(m_registered){
- lua_State *L = m_env->getLua();
- scriptapi_luaentity_step(L, m_id, dtime);
- }
+void PlayerSAO::setLookPitch(const float pitch)
+{
+ if (m_player && pitch != m_pitch)
+ m_player->setDirty(true);
- if(send_recommended == false)
- return;
-
- // 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);
- }
+ m_pitch = pitch;
}
-std::string LuaEntitySAO::getClientInitializationData()
+void PlayerSAO::setLookPitchAndSend(const float pitch)
{
- std::ostringstream os(std::ios::binary);
- // version
- writeU8(os, 0);
- // pos
- writeV3F1000(os, m_base_position);
- // yaw
- writeF1000(os, m_yaw);
- // properties
- std::ostringstream prop_os(std::ios::binary);
- m_prop->serialize(prop_os);
- os<<serializeLongString(prop_os.str());
- // return result
- return os.str();
+ setLookPitch(pitch);
+ m_env->getGameDef()->SendMovePlayer(m_peer_id);
}
-std::string LuaEntitySAO::getStaticData()
+int PlayerSAO::punch(v3f dir,
+ const ToolCapabilities *toolcap,
+ ServerActiveObject *puncher,
+ float time_from_last_punch)
{
- infostream<<__FUNCTION_NAME<<std::endl;
- std::ostringstream os(std::ios::binary);
- // version
- writeU8(os, 0);
- // name
- os<<serializeString(m_init_name);
- // state
- if(m_registered){
- lua_State *L = m_env->getLua();
- std::string state = scriptapi_luaentity_get_staticdata(L, m_id);
- os<<serializeLongString(state);
- } else {
- os<<serializeLongString(m_init_state);
+ if (!toolcap)
+ return 0;
+
+ FATAL_ERROR_IF(!puncher, "Punch action called without SAO");
+
+ // No effect if PvP disabled
+ if (!g_settings->getBool("enable_pvp")) {
+ if (puncher->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
+ std::string str = gob_cmd_punched(getHP());
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
+ return 0;
+ }
}
- return os.str();
+
+ s32 old_hp = getHP();
+ HitParams hitparams = getHitParams(m_armor_groups, toolcap,
+ time_from_last_punch);
+
+ 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((s32)getHP() - (s32)hitparams.hp,
+ PlayerHPChangeReason(PlayerHPChangeReason::PLAYER_PUNCH, puncher));
+ } else { // override client prediction
+ if (puncher->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
+ std::string str = gob_cmd_punched(getHP());
+ // create message and add to list
+ ActiveObjectMessage aom(getId(), true, str);
+ m_messages_out.push(aom);
+ }
+ }
+
+ actionstream << puncher->getDescription() << " (id=" << puncher->getId() <<
+ ", hp=" << puncher->getHP() << ") punched " <<
+ getDescription() << " (id=" << m_id << ", hp=" << m_hp <<
+ "), damage=" << (old_hp - (s32)getHP()) <<
+ (damage_handled ? " (handled by Lua)" : "") << std::endl;
+
+ return hitparams.wear;
}
-void LuaEntitySAO::punch(ServerActiveObject *puncher, float time_from_last_punch)
+void PlayerSAO::setHP(s32 hp, const PlayerHPChangeReason &reason)
{
- if(!m_registered){
- // Delete unknown LuaEntities when punched
- m_removed = true;
- return;
+ s32 oldhp = m_hp;
+
+ hp = rangelim(hp, 0, m_prop.hp_max);
+
+ if (oldhp != hp) {
+ s32 hp_change = m_env->getScriptIface()->on_player_hpchange(this, hp - oldhp, reason);
+ if (hp_change == 0)
+ return;
+
+ hp = rangelim(oldhp + hp_change, 0, m_prop.hp_max);
}
- lua_State *L = m_env->getLua();
- scriptapi_luaentity_punch(L, m_id, puncher, time_from_last_punch);
+
+ if (hp < oldhp && isImmortal())
+ return;
+
+ m_hp = hp;
+
+ // Update properties on death
+ if ((hp == 0) != (oldhp == 0))
+ m_properties_sent = false;
}
-void LuaEntitySAO::rightClick(ServerActiveObject *clicker)
+void PlayerSAO::setBreath(const u16 breath, bool send)
{
- if(!m_registered)
- return;
- lua_State *L = m_env->getLua();
- scriptapi_luaentity_rightclick(L, m_id, clicker);
+ if (m_player && breath != m_breath)
+ m_player->setDirty(true);
+
+ m_breath = rangelim(breath, 0, m_prop.breath_max);
+
+ if (send)
+ m_env->getGameDef()->SendPlayerBreath(this);
}
-void LuaEntitySAO::setPos(v3f pos)
+Inventory* PlayerSAO::getInventory()
{
- m_base_position = pos;
- sendPosition(false, true);
+ return m_inventory;
+}
+const Inventory* PlayerSAO::getInventory() const
+{
+ return m_inventory;
}
-void LuaEntitySAO::moveTo(v3f pos, bool continuous)
+InventoryLocation PlayerSAO::getInventoryLocation() const
{
- m_base_position = pos;
- if(!continuous)
- sendPosition(true, true);
+ InventoryLocation loc;
+ loc.setPlayer(m_player->getName());
+ return loc;
}
-float LuaEntitySAO::getMinimumSavedMovement()
+std::string PlayerSAO::getWieldList() const
{
- return 0.1 * BS;
+ return "main";
}
-void LuaEntitySAO::setVelocity(v3f velocity)
+ItemStack PlayerSAO::getWieldedItem() const
{
- m_velocity = velocity;
+ const Inventory *inv = getInventory();
+ ItemStack ret;
+ const InventoryList *mlist = inv->getList(getWieldList());
+ if (mlist && getWieldIndex() < (s32)mlist->getSize())
+ ret = mlist->getItem(getWieldIndex());
+ return ret;
}
-v3f LuaEntitySAO::getVelocity()
+ItemStack PlayerSAO::getWieldedItemOrHand() const
{
- return m_velocity;
+ 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;
}
-void LuaEntitySAO::setAcceleration(v3f acceleration)
+bool PlayerSAO::setWieldedItem(const ItemStack &item)
{
- m_acceleration = acceleration;
+ Inventory *inv = getInventory();
+ if (inv) {
+ InventoryList *mlist = inv->getList(getWieldList());
+ if (mlist) {
+ mlist->changeItem(getWieldIndex(), item);
+ return true;
+ }
+ }
+ return false;
}
-v3f LuaEntitySAO::getAcceleration()
+int PlayerSAO::getWieldIndex() const
{
- return m_acceleration;
+ return m_wield_index;
}
-void LuaEntitySAO::setYaw(float yaw)
+void PlayerSAO::setWieldIndex(int i)
{
- m_yaw = yaw;
+ if(i != m_wield_index) {
+ m_wield_index = i;
+ }
}
-float LuaEntitySAO::getYaw()
+void PlayerSAO::disconnected()
{
- return m_yaw;
+ m_peer_id = 0;
+ m_pending_removal = true;
}
-void LuaEntitySAO::setTextureMod(const std::string &mod)
+void PlayerSAO::unlinkPlayerSessionAndSave()
{
- std::ostringstream os(std::ios::binary);
- // command (1 = set texture modification)
- writeU8(os, 1);
- // parameters
- os<<serializeString(mod);
- // create message and add to list
- ActiveObjectMessage aom(getId(), false, os.str());
- m_messages_out.push_back(aom);
+ assert(m_player->getPlayerSAO() == this);
+ m_player->setPeerId(PEER_ID_INEXISTENT);
+ m_env->savePlayer(m_player);
+ m_player->setPlayerSAO(NULL);
+ m_env->removePlayer(m_player);
}
-void LuaEntitySAO::setSprite(v2s16 p, int num_frames, float framelength,
- bool select_horiz_by_yawpitch)
+std::string PlayerSAO::getPropertyPacket()
{
- std::ostringstream os(std::ios::binary);
- // command (2 = set sprite)
- writeU8(os, 2);
- // parameters
- writeV2S16(os, p);
- writeU16(os, num_frames);
- writeF1000(os, framelength);
- writeU8(os, select_horiz_by_yawpitch);
- // create message and add to list
- ActiveObjectMessage aom(getId(), false, os.str());
- m_messages_out.push_back(aom);
+ m_prop.is_visible = (true);
+ return gob_cmd_set_properties(m_prop);
}
-std::string LuaEntitySAO::getName()
+bool PlayerSAO::checkMovementCheat()
{
- return m_init_name;
+ if (isAttached() || m_is_singleplayer ||
+ g_settings->getBool("disable_anticheat")) {
+ m_last_good_position = m_base_position;
+ return false;
+ }
+
+ 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_walk = 0; // horizontal movement
+ float player_max_jump = 0; // vertical upwards movement
+
+ if (m_privs.count("fast") != 0)
+ player_max_walk = m_player->movement_speed_fast; // Fast speed
+ else
+ player_max_walk = m_player->movement_speed_walk; // Normal speed
+ player_max_walk *= m_physics_override_speed;
+ player_max_jump = m_player->movement_speed_jump * m_physics_override_jump;
+ // FIXME: Bouncy nodes cause practically unbound increase in Y speed,
+ // until this can be verified correctly, tolerate higher jumping speeds
+ player_max_jump *= 2.0;
+
+ // Don't divide by zero!
+ if (player_max_walk < 0.0001f)
+ player_max_walk = 0.0001f;
+ if (player_max_jump < 0.0001f)
+ player_max_jump = 0.0001f;
+
+ v3f diff = (m_base_position - m_last_good_position);
+ float d_vert = diff.Y;
+ diff.Y = 0;
+ float d_horiz = diff.getLength();
+ float required_time = d_horiz / player_max_walk;
+
+ // FIXME: Checking downwards movement is not easily possible currently,
+ // the server could calculate speed differences to examine the gravity
+ if (d_vert > 0) {
+ // In certain cases (water, ladders) walking speed is applied vertically
+ float s = MYMAX(player_max_jump, player_max_walk);
+ required_time = MYMAX(required_time, d_vert / s);
+ }
+
+ if (m_move_pool.grab(required_time)) {
+ m_last_good_position = m_base_position;
+ } else {
+ const float LAG_POOL_MIN = 5.0;
+ float lag_pool_max = m_env->getMaxLagEstimate() * 2.0;
+ lag_pool_max = MYMAX(lag_pool_max, LAG_POOL_MIN);
+ if (m_time_from_last_teleport > lag_pool_max) {
+ actionstream << "Player " << m_player->getName()
+ << " moved too fast; resetting position"
+ << std::endl;
+ cheated = true;
+ }
+ setBasePosition(m_last_good_position);
+ }
+ return cheated;
}
-void LuaEntitySAO::sendPosition(bool do_interpolate, bool is_movement_end)
+bool PlayerSAO::getCollisionBox(aabb3f *toset) const
{
- m_last_sent_move_precision = m_base_position.getDistanceFrom(
- m_last_sent_position);
- m_last_sent_position_timer = 0;
- m_last_sent_yaw = m_yaw;
- m_last_sent_position = m_base_position;
- m_last_sent_velocity = m_velocity;
- //m_last_sent_acceleration = m_acceleration;
+ //update collision box
+ toset->MinEdge = m_prop.collisionbox.MinEdge * BS;
+ toset->MaxEdge = m_prop.collisionbox.MaxEdge * BS;
- float update_interval = m_env->getSendRecommendedInterval();
+ toset->MinEdge += m_base_position;
+ toset->MaxEdge += m_base_position;
+ return true;
+}
- std::ostringstream os(std::ios::binary);
- // command (0 = update position)
- writeU8(os, 0);
-
- // do_interpolate
- writeU8(os, do_interpolate);
- // pos
- writeV3F1000(os, m_base_position);
- // velocity
- writeV3F1000(os, m_velocity);
- // acceleration
- writeV3F1000(os, m_acceleration);
- // yaw
- writeF1000(os, m_yaw);
- // is_end_position (for interpolation)
- writeU8(os, is_movement_end);
- // update_interval (for interpolation)
- writeF1000(os, update_interval);
+bool PlayerSAO::getSelectionBox(aabb3f *toset) const
+{
+ if (!m_prop.is_visible || !m_prop.pointable) {
+ return false;
+ }
- // create message and add to list
- ActiveObjectMessage aom(getId(), false, os.str());
- m_messages_out.push_back(aom);
+ toset->MinEdge = m_prop.selectionbox.MinEdge * BS;
+ toset->MaxEdge = m_prop.selectionbox.MaxEdge * BS;
+
+ return true;
}
+float PlayerSAO::getZoomFOV() const
+{
+ return m_prop.zoom_fov;
+}
projects / dragonfireclient.git / blobdiff