src/content_sao.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "content_sao.h"
  21 #include "util/serialize.h"
  22 #include "collision.h"
  23 #include "environment.h"
  24 #include "tool.h" // For ToolCapabilities
  25 #include "gamedef.h"
  26 #include "nodedef.h"
  27 #include "remoteplayer.h"
  28 #include "server.h"
  29 #include "scripting_game.h"
  30 #include "genericobject.h"
  31
  32 std::map<u16, ServerActiveObject::Factory> ServerActiveObject::m_types;
  33
  34 /*
  35         TestSAO
  36 */
  37
  38 class TestSAO : public ServerActiveObject
  39 {
  40 public:
  41         TestSAO(ServerEnvironment *env, v3f pos):
  42                 ServerActiveObject(env, pos),
  43                 m_timer1(0),
  44                 m_age(0)
  45         {
  46                 ServerActiveObject::registerType(getType(), create);
  47         }
  48         ActiveObjectType getType() const
  49         { return ACTIVEOBJECT_TYPE_TEST; }
  50
  51         static ServerActiveObject* create(ServerEnvironment *env, v3f pos,
  52                         const std::string &data)
  53         {
  54                 return new TestSAO(env, pos);
  55         }
  56
  57         void step(float dtime, bool send_recommended)
  58         {
  59                 m_age += dtime;
  60                 if(m_age > 10)
  61                 {
  62                         m_removed = true;
  63                         return;
  64                 }
  65
  66                 m_base_position.Y += dtime * BS * 2;
  67                 if(m_base_position.Y > 8*BS)
  68                         m_base_position.Y = 2*BS;
  69
  70                 if(send_recommended == false)
  71                         return;
  72
  73                 m_timer1 -= dtime;
  74                 if(m_timer1 < 0.0)
  75                 {
  76                         m_timer1 += 0.125;
  77
  78                         std::string data;
  79
  80                         data += itos(0); // 0 = position
  81                         data += " ";
  82                         data += itos(m_base_position.X);
  83                         data += " ";
  84                         data += itos(m_base_position.Y);
  85                         data += " ";
  86                         data += itos(m_base_position.Z);
  87
  88                         ActiveObjectMessage aom(getId(), false, data);
  89                         m_messages_out.push(aom);
  90                 }
  91         }
  92
  93         bool getCollisionBox(aabb3f *toset) const { return false; }
  94         bool collideWithObjects() const { return false; }
  95
  96 private:
  97         float m_timer1;
  98         float m_age;
  99 };
 100
 101 // Prototype (registers item for deserialization)
 102 TestSAO proto_TestSAO(NULL, v3f(0,0,0));
 103
 104 /*
 105         UnitSAO
 106  */
 107
 108 UnitSAO::UnitSAO(ServerEnvironment *env, v3f pos):
 109         ServerActiveObject(env, pos),
 110         m_hp(-1),
 111         m_yaw(0),
 112         m_properties_sent(true),
 113         m_armor_groups_sent(false),
 114         m_animation_range(0,0),
 115         m_animation_speed(0),
 116         m_animation_blend(0),
 117         m_animation_loop(true),
 118         m_animation_sent(false),
 119         m_bone_position_sent(false),
 120         m_attachment_parent_id(0),
 121         m_attachment_sent(false)
 122 {
 123         // Initialize something to armor groups
 124         m_armor_groups["fleshy"] = 100;
 125 }
 126
 127 bool UnitSAO::isAttached() const
 128 {
 129         if (!m_attachment_parent_id)
 130                 return false;
 131         // Check if the parent still exists
 132         ServerActiveObject *obj = m_env->getActiveObject(m_attachment_parent_id);
 133         if (obj)
 134                 return true;
 135         return false;
 136 }
 137
 138 void UnitSAO::setArmorGroups(const ItemGroupList &armor_groups)
 139 {
 140         m_armor_groups = armor_groups;
 141         m_armor_groups_sent = false;
 142 }
 143
 144 const ItemGroupList &UnitSAO::getArmorGroups()
 145 {
 146         return m_armor_groups;
 147 }
 148
 149 void UnitSAO::setAnimation(v2f frame_range, float frame_speed, float frame_blend, bool frame_loop)
 150 {
 151         // store these so they can be updated to clients
 152         m_animation_range = frame_range;
 153         m_animation_speed = frame_speed;
 154         m_animation_blend = frame_blend;
 155         m_animation_loop = frame_loop;
 156         m_animation_sent = false;
 157 }
 158
 159 void UnitSAO::getAnimation(v2f *frame_range, float *frame_speed, float *frame_blend, bool *frame_loop)
 160 {
 161         *frame_range = m_animation_range;
 162         *frame_speed = m_animation_speed;
 163         *frame_blend = m_animation_blend;
 164         *frame_loop = m_animation_loop;
 165 }
 166
 167 void UnitSAO::setBonePosition(const std::string &bone, v3f position, v3f rotation)
 168 {
 169         // store these so they can be updated to clients
 170         m_bone_position[bone] = core::vector2d<v3f>(position, rotation);
 171         m_bone_position_sent = false;
 172 }
 173
 174 void UnitSAO::getBonePosition(const std::string &bone, v3f *position, v3f *rotation)
 175 {
 176         *position = m_bone_position[bone].X;
 177         *rotation = m_bone_position[bone].Y;
 178 }
 179
 180 void UnitSAO::setAttachment(int parent_id, const std::string &bone, v3f position, v3f rotation)
 181 {
 182         // Attachments need to be handled on both the server and client.
 183         // If we just attach on the server, we can only copy the position of the parent. Attachments
 184         // are still sent to clients at an interval so players might see them lagging, plus we can't
 185         // read and attach to skeletal bones.
 186         // If we just attach on the client, the server still sees the child at its original location.
 187         // This breaks some things so we also give the server the most accurate representation
 188         // even if players only see the client changes.
 189
 190         m_attachment_parent_id = parent_id;
 191         m_attachment_bone = bone;
 192         m_attachment_position = position;
 193         m_attachment_rotation = rotation;
 194         m_attachment_sent = false;
 195 }
 196
 197 void UnitSAO::getAttachment(int *parent_id, std::string *bone, v3f *position,
 198         v3f *rotation)
 199 {
 200         *parent_id = m_attachment_parent_id;
 201         *bone = m_attachment_bone;
 202         *position = m_attachment_position;
 203         *rotation = m_attachment_rotation;
 204 }
 205
 206 void UnitSAO::addAttachmentChild(int child_id)
 207 {
 208         m_attachment_child_ids.insert(child_id);
 209 }
 210
 211 void UnitSAO::removeAttachmentChild(int child_id)
 212 {
 213         m_attachment_child_ids.erase(child_id);
 214 }
 215
 216 const UNORDERED_SET<int> &UnitSAO::getAttachmentChildIds()
 217 {
 218         return m_attachment_child_ids;
 219 }
 220
 221 ObjectProperties* UnitSAO::accessObjectProperties()
 222 {
 223         return &m_prop;
 224 }
 225
 226 void UnitSAO::notifyObjectPropertiesModified()
 227 {
 228         m_properties_sent = false;
 229 }
 230
 231 /*
 232         LuaEntitySAO
 233 */
 234
 235 // Prototype (registers item for deserialization)
 236 LuaEntitySAO proto_LuaEntitySAO(NULL, v3f(0,0,0), "_prototype", "");
 237
 238 LuaEntitySAO::LuaEntitySAO(ServerEnvironment *env, v3f pos,
 239                 const std::string &name, const std::string &state):
 240         UnitSAO(env, pos),
 241         m_init_name(name),
 242         m_init_state(state),
 243         m_registered(false),
 244         m_velocity(0,0,0),
 245         m_acceleration(0,0,0),
 246         m_last_sent_yaw(0),
 247         m_last_sent_position(0,0,0),
 248         m_last_sent_velocity(0,0,0),
 249         m_last_sent_position_timer(0),
 250         m_last_sent_move_precision(0)
 251 {
 252         // Only register type if no environment supplied
 253         if(env == NULL){
 254                 ServerActiveObject::registerType(getType(), create);
 255                 return;
 256         }
 257 }
 258
 259 LuaEntitySAO::~LuaEntitySAO()
 260 {
 261         if(m_registered){
 262                 m_env->getScriptIface()->luaentity_Remove(m_id);
 263         }
 264
 265         for (UNORDERED_SET<u32>::iterator it = m_attached_particle_spawners.begin();
 266                 it != m_attached_particle_spawners.end(); ++it) {
 267                 m_env->deleteParticleSpawner(*it, false);
 268         }
 269 }
 270
 271 void LuaEntitySAO::addedToEnvironment(u32 dtime_s)
 272 {
 273         ServerActiveObject::addedToEnvironment(dtime_s);
 274
 275         // Create entity from name
 276         m_registered = m_env->getScriptIface()->
 277                 luaentity_Add(m_id, m_init_name.c_str());
 278
 279         if(m_registered){
 280                 // Get properties
 281                 m_env->getScriptIface()->
 282                         luaentity_GetProperties(m_id, &m_prop);
 283                 // Initialize HP from properties
 284                 m_hp = m_prop.hp_max;
 285                 // Activate entity, supplying serialized state
 286                 m_env->getScriptIface()->
 287                         luaentity_Activate(m_id, m_init_state.c_str(), dtime_s);
 288         } else {
 289                 m_prop.infotext = m_init_name;
 290         }
 291 }
 292
 293 ServerActiveObject* LuaEntitySAO::create(ServerEnvironment *env, v3f pos,
 294                 const std::string &data)
 295 {
 296         std::string name;
 297         std::string state;
 298         s16 hp = 1;
 299         v3f velocity;
 300         float yaw = 0;
 301         if(data != ""){
 302                 std::istringstream is(data, std::ios::binary);
 303                 // read version
 304                 u8 version = readU8(is);
 305                 // check if version is supported
 306                 if(version == 0){
 307                         name = deSerializeString(is);
 308                         state = deSerializeLongString(is);
 309                 }
 310                 else if(version == 1){
 311                         name = deSerializeString(is);
 312                         state = deSerializeLongString(is);
 313                         hp = readS16(is);
 314                         velocity = readV3F1000(is);
 315                         yaw = readF1000(is);
 316                 }
 317         }
 318         // create object
 319         infostream<<"LuaEntitySAO::create(name=\""<<name<<"\" state=\""
 320                         <<state<<"\")"<<std::endl;
 321         LuaEntitySAO *sao = new LuaEntitySAO(env, pos, name, state);
 322         sao->m_hp = hp;
 323         sao->m_velocity = velocity;
 324         sao->m_yaw = yaw;
 325         return sao;
 326 }
 327
 328 void LuaEntitySAO::step(float dtime, bool send_recommended)
 329 {
 330         if(!m_properties_sent)
 331         {
 332                 m_properties_sent = true;
 333                 std::string str = getPropertyPacket();
 334                 // create message and add to list
 335                 ActiveObjectMessage aom(getId(), true, str);
 336                 m_messages_out.push(aom);
 337         }
 338
 339         // If attached, check that our parent is still there. If it isn't, detach.
 340         if(m_attachment_parent_id && !isAttached())
 341         {
 342                 m_attachment_parent_id = 0;
 343                 m_attachment_bone = "";
 344                 m_attachment_position = v3f(0,0,0);
 345                 m_attachment_rotation = v3f(0,0,0);
 346                 sendPosition(false, true);
 347         }
 348
 349         m_last_sent_position_timer += dtime;
 350
 351         // Each frame, parent position is copied if the object is attached, otherwise it's calculated normally
 352         // If the object gets detached this comes into effect automatically from the last known origin
 353         if(isAttached())
 354         {
 355                 v3f pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition();
 356                 m_base_position = pos;
 357                 m_velocity = v3f(0,0,0);
 358                 m_acceleration = v3f(0,0,0);
 359         }
 360         else
 361         {
 362                 if(m_prop.physical){
 363                         aabb3f box = m_prop.collisionbox;
 364                         box.MinEdge *= BS;
 365                         box.MaxEdge *= BS;
 366                         collisionMoveResult moveresult;
 367                         f32 pos_max_d = BS*0.25; // Distance per iteration
 368                         v3f p_pos = m_base_position;
 369                         v3f p_velocity = m_velocity;
 370                         v3f p_acceleration = m_acceleration;
 371                         moveresult = collisionMoveSimple(m_env, m_env->getGameDef(),
 372                                         pos_max_d, box, m_prop.stepheight, dtime,
 373                                         &p_pos, &p_velocity, p_acceleration,
 374                                         this, m_prop.collideWithObjects);
 375
 376                         // Apply results
 377                         m_base_position = p_pos;
 378                         m_velocity = p_velocity;
 379                         m_acceleration = p_acceleration;
 380                 } else {
 381                         m_base_position += dtime * m_velocity + 0.5 * dtime
 382                                         * dtime * m_acceleration;
 383                         m_velocity += dtime * m_acceleration;
 384                 }
 385
 386                 if((m_prop.automatic_face_movement_dir) &&
 387                                 (fabs(m_velocity.Z) > 0.001 || fabs(m_velocity.X) > 0.001))
 388                 {
 389                         float optimal_yaw = atan2(m_velocity.Z,m_velocity.X) * 180 / M_PI
 390                                         + m_prop.automatic_face_movement_dir_offset;
 391                         float max_rotation_delta =
 392                                         dtime * m_prop.automatic_face_movement_max_rotation_per_sec;
 393
 394                         if ((m_prop.automatic_face_movement_max_rotation_per_sec > 0) &&
 395                                 (fabs(m_yaw - optimal_yaw) > max_rotation_delta)) {
 396
 397                                 m_yaw = optimal_yaw < m_yaw ? m_yaw - max_rotation_delta : m_yaw + max_rotation_delta;
 398                         } else {
 399                                 m_yaw = optimal_yaw;
 400                         }
 401                 }
 402         }
 403
 404         if(m_registered){
 405                 m_env->getScriptIface()->luaentity_Step(m_id, dtime);
 406         }
 407
 408         if(send_recommended == false)
 409                 return;
 410
 411         if(!isAttached())
 412         {
 413                 // TODO: force send when acceleration changes enough?
 414                 float minchange = 0.2*BS;
 415                 if(m_last_sent_position_timer > 1.0){
 416                         minchange = 0.01*BS;
 417                 } else if(m_last_sent_position_timer > 0.2){
 418                         minchange = 0.05*BS;
 419                 }
 420                 float move_d = m_base_position.getDistanceFrom(m_last_sent_position);
 421                 move_d += m_last_sent_move_precision;
 422                 float vel_d = m_velocity.getDistanceFrom(m_last_sent_velocity);
 423                 if(move_d > minchange || vel_d > minchange ||
 424                                 fabs(m_yaw - m_last_sent_yaw) > 1.0){
 425                         sendPosition(true, false);
 426                 }
 427         }
 428
 429         if(m_armor_groups_sent == false){
 430                 m_armor_groups_sent = true;
 431                 std::string str = gob_cmd_update_armor_groups(
 432                                 m_armor_groups);
 433                 // create message and add to list
 434                 ActiveObjectMessage aom(getId(), true, str);
 435                 m_messages_out.push(aom);
 436         }
 437
 438         if(m_animation_sent == false){
 439                 m_animation_sent = true;
 440                 std::string str = gob_cmd_update_animation(
 441                         m_animation_range, m_animation_speed, m_animation_blend, m_animation_loop);
 442                 // create message and add to list
 443                 ActiveObjectMessage aom(getId(), true, str);
 444                 m_messages_out.push(aom);
 445         }
 446
 447         if(m_bone_position_sent == false){
 448                 m_bone_position_sent = true;
 449                 for (UNORDERED_MAP<std::string, core::vector2d<v3f> >::const_iterator
 450                                 ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii){
 451                         std::string str = gob_cmd_update_bone_position((*ii).first,
 452                                         (*ii).second.X, (*ii).second.Y);
 453                         // create message and add to list
 454                         ActiveObjectMessage aom(getId(), true, str);
 455                         m_messages_out.push(aom);
 456                 }
 457         }
 458
 459         if(m_attachment_sent == false){
 460                 m_attachment_sent = true;
 461                 std::string str = gob_cmd_update_attachment(m_attachment_parent_id, m_attachment_bone, m_attachment_position, m_attachment_rotation);
 462                 // create message and add to list
 463                 ActiveObjectMessage aom(getId(), true, str);
 464                 m_messages_out.push(aom);
 465         }
 466 }
 467
 468 std::string LuaEntitySAO::getClientInitializationData(u16 protocol_version)
 469 {
 470         std::ostringstream os(std::ios::binary);
 471
 472         if(protocol_version >= 14)
 473         {
 474                 writeU8(os, 1); // version
 475                 os<<serializeString(""); // name
 476                 writeU8(os, 0); // is_player
 477                 writeS16(os, getId()); //id
 478                 writeV3F1000(os, m_base_position);
 479                 writeF1000(os, m_yaw);
 480                 writeS16(os, m_hp);
 481
 482                 std::ostringstream msg_os(std::ios::binary);
 483                 msg_os << serializeLongString(getPropertyPacket()); // message 1
 484                 msg_os << serializeLongString(gob_cmd_update_armor_groups(m_armor_groups)); // 2
 485                 msg_os << serializeLongString(gob_cmd_update_animation(
 486                         m_animation_range, m_animation_speed, m_animation_blend, m_animation_loop)); // 3
 487                 for (UNORDERED_MAP<std::string, core::vector2d<v3f> >::const_iterator
 488                                 ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii) {
 489                         msg_os << serializeLongString(gob_cmd_update_bone_position((*ii).first,
 490                                         (*ii).second.X, (*ii).second.Y)); // m_bone_position.size
 491                 }
 492                 msg_os << serializeLongString(gob_cmd_update_attachment(m_attachment_parent_id,
 493                         m_attachment_bone, m_attachment_position, m_attachment_rotation)); // 4
 494                 int message_count = 4 + m_bone_position.size();
 495                 for (UNORDERED_SET<int>::const_iterator ii = m_attachment_child_ids.begin();
 496                                 (ii != m_attachment_child_ids.end()); ++ii) {
 497                         if (ServerActiveObject *obj = m_env->getActiveObject(*ii)) {
 498                                 message_count++;
 499                                 msg_os << serializeLongString(gob_cmd_update_infant(*ii, obj->getSendType(),
 500                                         obj->getClientInitializationData(protocol_version)));
 501                         }
 502                 }
 503
 504                 writeU8(os, message_count);
 505                 os.write(msg_os.str().c_str(), msg_os.str().size());
 506         }
 507         else
 508         {
 509                 writeU8(os, 0); // version
 510                 os<<serializeString(""); // name
 511                 writeU8(os, 0); // is_player
 512                 writeV3F1000(os, m_base_position);
 513                 writeF1000(os, m_yaw);
 514                 writeS16(os, m_hp);
 515                 writeU8(os, 2); // number of messages stuffed in here
 516                 os<<serializeLongString(getPropertyPacket()); // message 1
 517                 os<<serializeLongString(gob_cmd_update_armor_groups(m_armor_groups)); // 2
 518         }
 519
 520         // return result
 521         return os.str();
 522 }
 523
 524 std::string LuaEntitySAO::getStaticData() const
 525 {
 526         verbosestream<<FUNCTION_NAME<<std::endl;
 527         std::ostringstream os(std::ios::binary);
 528         // version
 529         writeU8(os, 1);
 530         // name
 531         os<<serializeString(m_init_name);
 532         // state
 533         if(m_registered){
 534                 std::string state = m_env->getScriptIface()->
 535                         luaentity_GetStaticdata(m_id);
 536                 os<<serializeLongString(state);
 537         } else {
 538                 os<<serializeLongString(m_init_state);
 539         }
 540         // hp
 541         writeS16(os, m_hp);
 542         // velocity
 543         writeV3F1000(os, m_velocity);
 544         // yaw
 545         writeF1000(os, m_yaw);
 546         return os.str();
 547 }
 548
 549 int LuaEntitySAO::punch(v3f dir,
 550                 const ToolCapabilities *toolcap,
 551                 ServerActiveObject *puncher,
 552                 float time_from_last_punch)
 553 {
 554         if (!m_registered){
 555                 // Delete unknown LuaEntities when punched
 556                 m_removed = true;
 557                 return 0;
 558         }
 559
 560         // It's best that attachments cannot be punched
 561         if (isAttached())
 562                 return 0;
 563
 564         ItemStack *punchitem = NULL;
 565         ItemStack punchitem_static;
 566         if (puncher) {
 567                 punchitem_static = puncher->getWieldedItem();
 568                 punchitem = &punchitem_static;
 569         }
 570
 571         PunchDamageResult result = getPunchDamage(
 572                         m_armor_groups,
 573                         toolcap,
 574                         punchitem,
 575                         time_from_last_punch);
 576
 577         if (result.did_punch) {
 578                 setHP(getHP() - result.damage);
 579
 580                 if (result.damage > 0) {
 581                         std::string punchername = puncher ? puncher->getDescription() : "nil";
 582
 583                         actionstream << getDescription() << " punched by "
 584                                         << punchername << ", damage " << result.damage
 585                                         << " hp, health now " << getHP() << " hp" << std::endl;
 586                 }
 587
 588                 std::string str = gob_cmd_punched(result.damage, getHP());
 589                 // create message and add to list
 590                 ActiveObjectMessage aom(getId(), true, str);
 591                 m_messages_out.push(aom);
 592         }
 593
 594         if (getHP() == 0)
 595                 m_removed = true;
 596
 597         m_env->getScriptIface()->luaentity_Punch(m_id, puncher,
 598                         time_from_last_punch, toolcap, dir);
 599
 600         return result.wear;
 601 }
 602
 603 void LuaEntitySAO::rightClick(ServerActiveObject *clicker)
 604 {
 605         if (!m_registered)
 606                 return;
 607         // It's best that attachments cannot be clicked
 608         if (isAttached())
 609                 return;
 610         m_env->getScriptIface()->luaentity_Rightclick(m_id, clicker);
 611 }
 612
 613 void LuaEntitySAO::setPos(const v3f &pos)
 614 {
 615         if(isAttached())
 616                 return;
 617         m_base_position = pos;
 618         sendPosition(false, true);
 619 }
 620
 621 void LuaEntitySAO::moveTo(v3f pos, bool continuous)
 622 {
 623         if(isAttached())
 624                 return;
 625         m_base_position = pos;
 626         if(!continuous)
 627                 sendPosition(true, true);
 628 }
 629
 630 float LuaEntitySAO::getMinimumSavedMovement()
 631 {
 632         return 0.1 * BS;
 633 }
 634
 635 std::string LuaEntitySAO::getDescription()
 636 {
 637         std::ostringstream os(std::ios::binary);
 638         os<<"LuaEntitySAO at (";
 639         os<<(m_base_position.X/BS)<<",";
 640         os<<(m_base_position.Y/BS)<<",";
 641         os<<(m_base_position.Z/BS);
 642         os<<")";
 643         return os.str();
 644 }
 645
 646 void LuaEntitySAO::setHP(s16 hp)
 647 {
 648         if(hp < 0) hp = 0;
 649         m_hp = hp;
 650 }
 651
 652 s16 LuaEntitySAO::getHP() const
 653 {
 654         return m_hp;
 655 }
 656
 657 void LuaEntitySAO::setVelocity(v3f velocity)
 658 {
 659         m_velocity = velocity;
 660 }
 661
 662 v3f LuaEntitySAO::getVelocity()
 663 {
 664         return m_velocity;
 665 }
 666
 667 void LuaEntitySAO::setAcceleration(v3f acceleration)
 668 {
 669         m_acceleration = acceleration;
 670 }
 671
 672 v3f LuaEntitySAO::getAcceleration()
 673 {
 674         return m_acceleration;
 675 }
 676
 677 void LuaEntitySAO::setTextureMod(const std::string &mod)
 678 {
 679         std::string str = gob_cmd_set_texture_mod(mod);
 680         // create message and add to list
 681         ActiveObjectMessage aom(getId(), true, str);
 682         m_messages_out.push(aom);
 683 }
 684
 685 void LuaEntitySAO::setSprite(v2s16 p, int num_frames, float framelength,
 686                 bool select_horiz_by_yawpitch)
 687 {
 688         std::string str = gob_cmd_set_sprite(
 689                 p,
 690                 num_frames,
 691                 framelength,
 692                 select_horiz_by_yawpitch
 693         );
 694         // create message and add to list
 695         ActiveObjectMessage aom(getId(), true, str);
 696         m_messages_out.push(aom);
 697 }
 698
 699 std::string LuaEntitySAO::getName()
 700 {
 701         return m_init_name;
 702 }
 703
 704 std::string LuaEntitySAO::getPropertyPacket()
 705 {
 706         return gob_cmd_set_properties(m_prop);
 707 }
 708
 709 void LuaEntitySAO::sendPosition(bool do_interpolate, bool is_movement_end)
 710 {
 711         // If the object is attached client-side, don't waste bandwidth sending its position to clients
 712         if(isAttached())
 713                 return;
 714
 715         m_last_sent_move_precision = m_base_position.getDistanceFrom(
 716                         m_last_sent_position);
 717         m_last_sent_position_timer = 0;
 718         m_last_sent_yaw = m_yaw;
 719         m_last_sent_position = m_base_position;
 720         m_last_sent_velocity = m_velocity;
 721         //m_last_sent_acceleration = m_acceleration;
 722
 723         float update_interval = m_env->getSendRecommendedInterval();
 724
 725         std::string str = gob_cmd_update_position(
 726                 m_base_position,
 727                 m_velocity,
 728                 m_acceleration,
 729                 m_yaw,
 730                 do_interpolate,
 731                 is_movement_end,
 732                 update_interval
 733         );
 734         // create message and add to list
 735         ActiveObjectMessage aom(getId(), false, str);
 736         m_messages_out.push(aom);
 737 }
 738
 739 bool LuaEntitySAO::getCollisionBox(aabb3f *toset) const
 740 {
 741         if (m_prop.physical)
 742         {
 743                 //update collision box
 744                 toset->MinEdge = m_prop.collisionbox.MinEdge * BS;
 745                 toset->MaxEdge = m_prop.collisionbox.MaxEdge * BS;
 746
 747                 toset->MinEdge += m_base_position;
 748                 toset->MaxEdge += m_base_position;
 749
 750                 return true;
 751         }
 752
 753         return false;
 754 }
 755
 756 bool LuaEntitySAO::collideWithObjects() const
 757 {
 758         return m_prop.collideWithObjects;
 759 }
 760
 761 /*
 762         PlayerSAO
 763 */
 764
 765 // No prototype, PlayerSAO does not need to be deserialized
 766
 767 PlayerSAO::PlayerSAO(ServerEnvironment *env_, u16 peer_id_, bool is_singleplayer):
 768         UnitSAO(env_, v3f(0,0,0)),
 769         m_player(NULL),
 770         m_peer_id(peer_id_),
 771         m_inventory(NULL),
 772         m_damage(0),
 773         m_last_good_position(0,0,0),
 774         m_time_from_last_punch(0),
 775         m_nocheat_dig_pos(32767, 32767, 32767),
 776         m_nocheat_dig_time(0),
 777         m_wield_index(0),
 778         m_position_not_sent(false),
 779         m_is_singleplayer(is_singleplayer),
 780         m_breath(PLAYER_MAX_BREATH),
 781         m_pitch(0),
 782         m_fov(0),
 783         m_wanted_range(0),
 784         // public
 785         m_physics_override_speed(1),
 786         m_physics_override_jump(1),
 787         m_physics_override_gravity(1),
 788         m_physics_override_sneak(true),
 789         m_physics_override_sneak_glitch(true),
 790         m_physics_override_sent(false)
 791 {
 792         assert(m_peer_id != 0); // pre-condition
 793
 794         m_prop.hp_max = PLAYER_MAX_HP;
 795         m_prop.physical = false;
 796         m_prop.weight = 75;
 797         m_prop.collisionbox = aabb3f(-1/3.,-1.0,-1/3., 1/3.,1.0,1/3.);
 798         // start of default appearance, this should be overwritten by LUA
 799         m_prop.visual = "upright_sprite";
 800         m_prop.visual_size = v2f(1, 2);
 801         m_prop.textures.clear();
 802         m_prop.textures.push_back("player.png");
 803         m_prop.textures.push_back("player_back.png");
 804         m_prop.colors.clear();
 805         m_prop.colors.push_back(video::SColor(255, 255, 255, 255));
 806         m_prop.spritediv = v2s16(1,1);
 807         // end of default appearance
 808         m_prop.is_visible = true;
 809         m_prop.makes_footstep_sound = true;
 810         m_hp = PLAYER_MAX_HP;
 811 }
 812
 813 PlayerSAO::~PlayerSAO()
 814 {
 815         if(m_inventory != &m_player->inventory)
 816                 delete m_inventory;
 817 }
 818
 819 void PlayerSAO::initialize(RemotePlayer *player, const std::set<std::string> &privs)
 820 {
 821         assert(player);
 822         m_player = player;
 823         m_privs = privs;
 824         m_inventory = &m_player->inventory;
 825 }
 826
 827 v3f PlayerSAO::getEyeOffset() const
 828 {
 829         return v3f(0, BS * 1.625f, 0);
 830 }
 831
 832 std::string PlayerSAO::getDescription()
 833 {
 834         return std::string("player ") + m_player->getName();
 835 }
 836
 837 // Called after id has been set and has been inserted in environment
 838 void PlayerSAO::addedToEnvironment(u32 dtime_s)
 839 {
 840         ServerActiveObject::addedToEnvironment(dtime_s);
 841         ServerActiveObject::setBasePosition(m_base_position);
 842         m_player->setPlayerSAO(this);
 843         m_player->peer_id = m_peer_id;
 844         m_last_good_position = m_base_position;
 845 }
 846
 847 // Called before removing from environment
 848 void PlayerSAO::removingFromEnvironment()
 849 {
 850         ServerActiveObject::removingFromEnvironment();
 851         if (m_player->getPlayerSAO() == this) {
 852                 unlinkPlayerSessionAndSave();
 853                 for (UNORDERED_SET<u32>::iterator it = m_attached_particle_spawners.begin();
 854                         it != m_attached_particle_spawners.end(); ++it) {
 855                         m_env->deleteParticleSpawner(*it, false);
 856                 }
 857         }
 858 }
 859
 860 std::string PlayerSAO::getClientInitializationData(u16 protocol_version)
 861 {
 862         std::ostringstream os(std::ios::binary);
 863
 864         if(protocol_version >= 15)
 865         {
 866                 writeU8(os, 1); // version
 867                 os<<serializeString(m_player->getName()); // name
 868                 writeU8(os, 1); // is_player
 869                 writeS16(os, getId()); //id
 870                 writeV3F1000(os, m_base_position + v3f(0,BS*1,0));
 871                 writeF1000(os, m_yaw);
 872                 writeS16(os, getHP());
 873
 874                 std::ostringstream msg_os(std::ios::binary);
 875                 msg_os << serializeLongString(getPropertyPacket()); // message 1
 876                 msg_os << serializeLongString(gob_cmd_update_armor_groups(m_armor_groups)); // 2
 877                 msg_os << serializeLongString(gob_cmd_update_animation(
 878                         m_animation_range, m_animation_speed, m_animation_blend, m_animation_loop)); // 3
 879                 for (UNORDERED_MAP<std::string, core::vector2d<v3f> >::const_iterator
 880                                 ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii) {
 881                         msg_os << serializeLongString(gob_cmd_update_bone_position((*ii).first,
 882                                 (*ii).second.X, (*ii).second.Y)); // m_bone_position.size
 883                 }
 884                 msg_os << serializeLongString(gob_cmd_update_attachment(m_attachment_parent_id,
 885                         m_attachment_bone, m_attachment_position, m_attachment_rotation)); // 4
 886                 msg_os << serializeLongString(gob_cmd_update_physics_override(m_physics_override_speed,
 887                                 m_physics_override_jump, m_physics_override_gravity, m_physics_override_sneak,
 888                                 m_physics_override_sneak_glitch)); // 5
 889                 // (GENERIC_CMD_UPDATE_NAMETAG_ATTRIBUTES) : Deprecated, for backwards compatibility only.
 890                 msg_os << serializeLongString(gob_cmd_update_nametag_attributes(m_prop.nametag_color)); // 6
 891                 int message_count = 6 + m_bone_position.size();
 892                 for (UNORDERED_SET<int>::const_iterator ii = m_attachment_child_ids.begin();
 893                                 ii != m_attachment_child_ids.end(); ++ii) {
 894                         if (ServerActiveObject *obj = m_env->getActiveObject(*ii)) {
 895                                 message_count++;
 896                                 msg_os << serializeLongString(gob_cmd_update_infant(*ii, obj->getSendType(),
 897                                         obj->getClientInitializationData(protocol_version)));
 898                         }
 899                 }
 900
 901                 writeU8(os, message_count);
 902                 os.write(msg_os.str().c_str(), msg_os.str().size());
 903         }
 904         else
 905         {
 906                 writeU8(os, 0); // version
 907                 os<<serializeString(m_player->getName()); // name
 908                 writeU8(os, 1); // is_player
 909                 writeV3F1000(os, m_base_position + v3f(0,BS*1,0));
 910                 writeF1000(os, m_yaw);
 911                 writeS16(os, getHP());
 912                 writeU8(os, 2); // number of messages stuffed in here
 913                 os<<serializeLongString(getPropertyPacket()); // message 1
 914                 os<<serializeLongString(gob_cmd_update_armor_groups(m_armor_groups)); // 2
 915         }
 916
 917         // return result
 918         return os.str();
 919 }
 920
 921 std::string PlayerSAO::getStaticData() const
 922 {
 923         FATAL_ERROR("Deprecated function (?)");
 924         return "";
 925 }
 926
 927 void PlayerSAO::step(float dtime, bool send_recommended)
 928 {
 929         if (m_drowning_interval.step(dtime, 2.0)) {
 930                 // get head position
 931                 v3s16 p = floatToInt(m_base_position + v3f(0, BS * 1.6, 0), BS);
 932                 MapNode n = m_env->getMap().getNodeNoEx(p);
 933                 const ContentFeatures &c = m_env->getGameDef()->ndef()->get(n);
 934                 // If node generates drown
 935                 if (c.drowning > 0) {
 936                         if (m_hp > 0 && m_breath > 0)
 937                                 setBreath(m_breath - 1);
 938
 939                         // No more breath, damage player
 940                         if (m_breath == 0) {
 941                                 setHP(m_hp - c.drowning);
 942                                 m_env->getGameDef()->SendPlayerHPOrDie(this);
 943                         }
 944                 }
 945         }
 946
 947         if (m_breathing_interval.step(dtime, 0.5)) {
 948                 // get head position
 949                 v3s16 p = floatToInt(m_base_position + v3f(0, BS * 1.6, 0), BS);
 950                 MapNode n = m_env->getMap().getNodeNoEx(p);
 951                 const ContentFeatures &c = m_env->getGameDef()->ndef()->get(n);
 952                 // If player is alive & no drowning, breath
 953                 if (m_hp > 0 && c.drowning == 0)
 954                         setBreath(m_breath + 1);
 955         }
 956
 957         if (!m_properties_sent) {
 958                 m_properties_sent = true;
 959                 std::string str = getPropertyPacket();
 960                 // create message and add to list
 961                 ActiveObjectMessage aom(getId(), true, str);
 962                 m_messages_out.push(aom);
 963         }
 964
 965         // If attached, check that our parent is still there. If it isn't, detach.
 966         if(m_attachment_parent_id && !isAttached())
 967         {
 968                 m_attachment_parent_id = 0;
 969                 m_attachment_bone = "";
 970                 m_attachment_position = v3f(0,0,0);
 971                 m_attachment_rotation = v3f(0,0,0);
 972                 setBasePosition(m_last_good_position);
 973                 m_env->getGameDef()->SendMovePlayer(m_peer_id);
 974         }
 975
 976         //dstream<<"PlayerSAO::step: dtime: "<<dtime<<std::endl;
 977
 978         // Set lag pool maximums based on estimated lag
 979         const float LAG_POOL_MIN = 5.0;
 980         float lag_pool_max = m_env->getMaxLagEstimate() * 2.0;
 981         if(lag_pool_max < LAG_POOL_MIN)
 982                 lag_pool_max = LAG_POOL_MIN;
 983         m_dig_pool.setMax(lag_pool_max);
 984         m_move_pool.setMax(lag_pool_max);
 985
 986         // Increment cheat prevention timers
 987         m_dig_pool.add(dtime);
 988         m_move_pool.add(dtime);
 989         m_time_from_last_punch += dtime;
 990         m_nocheat_dig_time += dtime;
 991
 992         // Each frame, parent position is copied if the object is attached, otherwise it's calculated normally
 993         // If the object gets detached this comes into effect automatically from the last known origin
 994         if (isAttached()) {
 995                 v3f pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition();
 996                 m_last_good_position = pos;
 997                 setBasePosition(pos);
 998         }
 999
1000         if (!send_recommended)
1001                 return;
1002
1003         // If the object is attached client-side, don't waste bandwidth sending its position to clients
1004         if(m_position_not_sent && !isAttached())
1005         {
1006                 m_position_not_sent = false;
1007                 float update_interval = m_env->getSendRecommendedInterval();
1008                 v3f pos;
1009                 if(isAttached()) // Just in case we ever do send attachment position too
1010                         pos = m_env->getActiveObject(m_attachment_parent_id)->getBasePosition();
1011                 else
1012                         pos = m_base_position + v3f(0,BS*1,0);
1013                 std::string str = gob_cmd_update_position(
1014                         pos,
1015                         v3f(0,0,0),
1016                         v3f(0,0,0),
1017                         m_yaw,
1018                         true,
1019                         false,
1020                         update_interval
1021                 );
1022                 // create message and add to list
1023                 ActiveObjectMessage aom(getId(), false, str);
1024                 m_messages_out.push(aom);
1025         }
1026
1027         if (!m_armor_groups_sent) {
1028                 m_armor_groups_sent = true;
1029                 std::string str = gob_cmd_update_armor_groups(
1030                                 m_armor_groups);
1031                 // create message and add to list
1032                 ActiveObjectMessage aom(getId(), true, str);
1033                 m_messages_out.push(aom);
1034         }
1035
1036         if (!m_physics_override_sent) {
1037                 m_physics_override_sent = true;
1038                 std::string str = gob_cmd_update_physics_override(m_physics_override_speed,
1039                                 m_physics_override_jump, m_physics_override_gravity,
1040                                 m_physics_override_sneak, m_physics_override_sneak_glitch);
1041                 // create message and add to list
1042                 ActiveObjectMessage aom(getId(), true, str);
1043                 m_messages_out.push(aom);
1044         }
1045
1046         if (!m_animation_sent) {
1047                 m_animation_sent = true;
1048                 std::string str = gob_cmd_update_animation(
1049                         m_animation_range, m_animation_speed, m_animation_blend, m_animation_loop);
1050                 // create message and add to list
1051                 ActiveObjectMessage aom(getId(), true, str);
1052                 m_messages_out.push(aom);
1053         }
1054
1055         if (!m_bone_position_sent) {
1056                 m_bone_position_sent = true;
1057                 for (UNORDERED_MAP<std::string, core::vector2d<v3f> >::const_iterator
1058                                 ii = m_bone_position.begin(); ii != m_bone_position.end(); ++ii) {
1059                         std::string str = gob_cmd_update_bone_position((*ii).first,
1060                                         (*ii).second.X, (*ii).second.Y);
1061                         // create message and add to list
1062                         ActiveObjectMessage aom(getId(), true, str);
1063                         m_messages_out.push(aom);
1064                 }
1065         }
1066
1067         if (!m_attachment_sent){
1068                 m_attachment_sent = true;
1069                 std::string str = gob_cmd_update_attachment(m_attachment_parent_id,
1070                                 m_attachment_bone, m_attachment_position, m_attachment_rotation);
1071                 // create message and add to list
1072                 ActiveObjectMessage aom(getId(), true, str);
1073                 m_messages_out.push(aom);
1074         }
1075 }
1076
1077 void PlayerSAO::setBasePosition(const v3f &position)
1078 {
1079         if (m_player && position != m_base_position)
1080                 m_player->setDirty(true);
1081
1082         // This needs to be ran for attachments too
1083         ServerActiveObject::setBasePosition(position);
1084         m_position_not_sent = true;
1085 }
1086
1087 void PlayerSAO::setPos(const v3f &pos)
1088 {
1089         if(isAttached())
1090                 return;
1091
1092         setBasePosition(pos);
1093         // Movement caused by this command is always valid
1094         m_last_good_position = pos;
1095         m_env->getGameDef()->SendMovePlayer(m_peer_id);
1096 }
1097
1098 void PlayerSAO::moveTo(v3f pos, bool continuous)
1099 {
1100         if(isAttached())
1101                 return;
1102
1103         setBasePosition(pos);
1104         // Movement caused by this command is always valid
1105         m_last_good_position = pos;
1106         m_env->getGameDef()->SendMovePlayer(m_peer_id);
1107 }
1108
1109 void PlayerSAO::setYaw(const float yaw)
1110 {
1111         if (m_player && yaw != m_yaw)
1112                 m_player->setDirty(true);
1113
1114         UnitSAO::setYaw(yaw);
1115 }
1116
1117 void PlayerSAO::setFov(const float fov)
1118 {
1119         if (m_player && fov != m_fov)
1120                 m_player->setDirty(true);
1121
1122         m_fov = fov;
1123 }
1124
1125 void PlayerSAO::setWantedRange(const s16 range)
1126 {
1127         if (m_player && range != m_wanted_range)
1128                 m_player->setDirty(true);
1129
1130         m_wanted_range = range;
1131 }
1132
1133 void PlayerSAO::setYawAndSend(const float yaw)
1134 {
1135         setYaw(yaw);
1136         m_env->getGameDef()->SendMovePlayer(m_peer_id);
1137 }
1138
1139 void PlayerSAO::setPitch(const float pitch)
1140 {
1141         if (m_player && pitch != m_pitch)
1142                 m_player->setDirty(true);
1143
1144         m_pitch = pitch;
1145 }
1146
1147 void PlayerSAO::setPitchAndSend(const float pitch)
1148 {
1149         setPitch(pitch);
1150         m_env->getGameDef()->SendMovePlayer(m_peer_id);
1151 }
1152
1153 int PlayerSAO::punch(v3f dir,
1154         const ToolCapabilities *toolcap,
1155         ServerActiveObject *puncher,
1156         float time_from_last_punch)
1157 {
1158         // It's best that attachments cannot be punched
1159         if (isAttached())
1160                 return 0;
1161
1162         if (!toolcap)
1163                 return 0;
1164
1165         // No effect if PvP disabled
1166         if (g_settings->getBool("enable_pvp") == false) {
1167                 if (puncher->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
1168                         std::string str = gob_cmd_punched(0, getHP());
1169                         // create message and add to list
1170                         ActiveObjectMessage aom(getId(), true, str);
1171                         m_messages_out.push(aom);
1172                         return 0;
1173                 }
1174         }
1175
1176         HitParams hitparams = getHitParams(m_armor_groups, toolcap,
1177                         time_from_last_punch);
1178
1179         std::string punchername = "nil";
1180
1181         if (puncher != 0)
1182                 punchername = puncher->getDescription();
1183
1184         PlayerSAO *playersao = m_player->getPlayerSAO();
1185
1186         bool damage_handled = m_env->getScriptIface()->on_punchplayer(playersao,
1187                                 puncher, time_from_last_punch, toolcap, dir,
1188                                 hitparams.hp);
1189
1190         if (!damage_handled) {
1191                 setHP(getHP() - hitparams.hp);
1192         } else { // override client prediction
1193                 if (puncher->getType() == ACTIVEOBJECT_TYPE_PLAYER) {
1194                         std::string str = gob_cmd_punched(0, getHP());
1195                         // create message and add to list
1196                         ActiveObjectMessage aom(getId(), true, str);
1197                         m_messages_out.push(aom);
1198                 }
1199         }
1200
1201
1202         actionstream << "Player " << m_player->getName() << " punched by "
1203                         << punchername;
1204         if (!damage_handled) {
1205                 actionstream << ", damage " << hitparams.hp << " HP";
1206         } else {
1207                 actionstream << ", damage handled by lua";
1208         }
1209         actionstream << std::endl;
1210
1211         return hitparams.wear;
1212 }
1213
1214 s16 PlayerSAO::readDamage()
1215 {
1216         s16 damage = m_damage;
1217         m_damage = 0;
1218         return damage;
1219 }
1220
1221 void PlayerSAO::setHP(s16 hp)
1222 {
1223         s16 oldhp = m_hp;
1224
1225         s16 hp_change = m_env->getScriptIface()->on_player_hpchange(this, hp - oldhp);
1226         if (hp_change == 0)
1227                 return;
1228         hp = oldhp + hp_change;
1229
1230         if (hp < 0)
1231                 hp = 0;
1232         else if (hp > PLAYER_MAX_HP)
1233                 hp = PLAYER_MAX_HP;
1234
1235         if (hp < oldhp && !g_settings->getBool("enable_damage")) {
1236                 return;
1237         }
1238
1239         m_hp = hp;
1240
1241         if (oldhp > hp)
1242                 m_damage += (oldhp - hp);
1243
1244         // Update properties on death
1245         if ((hp == 0) != (oldhp == 0))
1246                 m_properties_sent = false;
1247 }
1248
1249 void PlayerSAO::setBreath(const u16 breath, bool send)
1250 {
1251         if (m_player && breath != m_breath)
1252                 m_player->setDirty(true);
1253
1254         m_breath = MYMIN(breath, PLAYER_MAX_BREATH);
1255
1256         if (send)
1257                 m_env->getGameDef()->SendPlayerBreath(this);
1258 }
1259
1260 Inventory* PlayerSAO::getInventory()
1261 {
1262         return m_inventory;
1263 }
1264 const Inventory* PlayerSAO::getInventory() const
1265 {
1266         return m_inventory;
1267 }
1268
1269 InventoryLocation PlayerSAO::getInventoryLocation() const
1270 {
1271         InventoryLocation loc;
1272         loc.setPlayer(m_player->getName());
1273         return loc;
1274 }
1275
1276 std::string PlayerSAO::getWieldList() const
1277 {
1278         return "main";
1279 }
1280
1281 ItemStack PlayerSAO::getWieldedItem() const
1282 {
1283         const Inventory *inv = getInventory();
1284         ItemStack ret;
1285         const InventoryList *mlist = inv->getList(getWieldList());
1286         if (mlist && getWieldIndex() < (s32)mlist->getSize())
1287                 ret = mlist->getItem(getWieldIndex());
1288         if (ret.name.empty()) {
1289                 const InventoryList *hlist = inv->getList("hand");
1290                 if (hlist)
1291                         ret = hlist->getItem(0);
1292         }
1293         return ret;
1294 }
1295
1296 bool PlayerSAO::setWieldedItem(const ItemStack &item)
1297 {
1298         Inventory *inv = getInventory();
1299         if (inv) {
1300                 InventoryList *mlist = inv->getList(getWieldList());
1301                 if (mlist) {
1302                         ItemStack olditem = mlist->getItem(getWieldIndex());
1303                         if (olditem.name.empty()) {
1304                                 InventoryList *hlist = inv->getList("hand");
1305                                 if (hlist) {
1306                                         hlist->changeItem(0, item);
1307                                         return true;
1308                                 }
1309                         }
1310                         mlist->changeItem(getWieldIndex(), item);
1311                         return true;
1312                 }
1313         }
1314         return false;
1315 }
1316
1317 int PlayerSAO::getWieldIndex() const
1318 {
1319         return m_wield_index;
1320 }
1321
1322 void PlayerSAO::setWieldIndex(int i)
1323 {
1324         if(i != m_wield_index) {
1325                 m_wield_index = i;
1326         }
1327 }
1328
1329 // Erase the peer id and make the object for removal
1330 void PlayerSAO::disconnected()
1331 {
1332         m_peer_id = 0;
1333         m_removed = true;
1334 }
1335
1336 void PlayerSAO::unlinkPlayerSessionAndSave()
1337 {
1338         assert(m_player->getPlayerSAO() == this);
1339         m_player->peer_id = 0;
1340         m_env->savePlayer(m_player);
1341         m_player->setPlayerSAO(NULL);
1342         m_env->removePlayer(m_player);
1343 }
1344
1345 std::string PlayerSAO::getPropertyPacket()
1346 {
1347         m_prop.is_visible = (true);
1348         return gob_cmd_set_properties(m_prop);
1349 }
1350
1351 bool PlayerSAO::checkMovementCheat()
1352 {
1353         if (isAttached() || m_is_singleplayer ||
1354                         g_settings->getBool("disable_anticheat")) {
1355                 m_last_good_position = m_base_position;
1356                 return false;
1357         }
1358
1359         bool cheated = false;
1360         /*
1361                 Check player movements
1362
1363                 NOTE: Actually the server should handle player physics like the
1364                 client does and compare player's position to what is calculated
1365                 on our side. This is required when eg. players fly due to an
1366                 explosion. Altough a node-based alternative might be possible
1367                 too, and much more lightweight.
1368         */
1369
1370         float player_max_speed = 0;
1371
1372         if (m_privs.count("fast") != 0) {
1373                 // Fast speed
1374                 player_max_speed = m_player->movement_speed_fast * m_physics_override_speed;
1375         } else {
1376                 // Normal speed
1377                 player_max_speed = m_player->movement_speed_walk * m_physics_override_speed;
1378         }
1379         // Tolerance. The lag pool does this a bit.
1380         //player_max_speed *= 2.5;
1381
1382         v3f diff = (m_base_position - m_last_good_position);
1383         float d_vert = diff.Y;
1384         diff.Y = 0;
1385         float d_horiz = diff.getLength();
1386         float required_time = d_horiz / player_max_speed;
1387
1388         if (d_vert > 0 && d_vert / player_max_speed > required_time)
1389                 required_time = d_vert / player_max_speed; // Moving upwards
1390
1391         if (m_move_pool.grab(required_time)) {
1392                 m_last_good_position = m_base_position;
1393         } else {
1394                 actionstream << "Player " << m_player->getName()
1395                                 << " moved too fast; resetting position"
1396                                 << std::endl;
1397                 setBasePosition(m_last_good_position);
1398                 cheated = true;
1399         }
1400         return cheated;
1401 }
1402
1403 bool PlayerSAO::getCollisionBox(aabb3f *toset) const
1404 {
1405         *toset = aabb3f(-BS * 0.30, 0.0, -BS * 0.30, BS * 0.30, BS * 1.75, BS * 0.30);
1406         toset->MinEdge += m_base_position;
1407         toset->MaxEdge += m_base_position;
1408         return true;
1409 }