src/serverremoteplayer.cpp

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010-2011 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 General Public License as published by
   7 the Free Software Foundation; either version 2 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 General Public License for more details.
  14
  15 You should have received a copy of the GNU 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 "serverremoteplayer.h"
  21 #include "main.h" // For g_settings
  22 #include "settings.h"
  23 #include "log.h"
  24 #include "gamedef.h"
  25 #include "tooldef.h"
  26 #include "environment.h"
  27 #include "materials.h"
  28
  29 ServerRemotePlayer::ServerRemotePlayer(ServerEnvironment *env):
  30         Player(env->getGameDef()),
  31         ServerActiveObject(env, v3f(0,0,0)),
  32         m_last_good_position(0,0,0),
  33         m_last_good_position_age(0),
  34         m_additional_items(),
  35         m_inventory_not_sent(false),
  36         m_hp_not_sent(false),
  37         m_respawn_active(false),
  38         m_is_in_environment(false),
  39         m_position_not_sent(false)
  40 {
  41 }
  42 ServerRemotePlayer::ServerRemotePlayer(ServerEnvironment *env, v3f pos_, u16 peer_id_,
  43                 const char *name_):
  44         Player(env->getGameDef()),
  45         ServerActiveObject(env, pos_),
  46         m_inventory_not_sent(false),
  47         m_hp_not_sent(false),
  48         m_is_in_environment(false),
  49         m_position_not_sent(false)
  50 {
  51         setPosition(pos_);
  52         peer_id = peer_id_;
  53         updateName(name_);
  54 }
  55 ServerRemotePlayer::~ServerRemotePlayer()
  56 {
  57         clearAddToInventoryLater();
  58 }
  59
  60 void ServerRemotePlayer::setPosition(const v3f &position)
  61 {
  62         Player::setPosition(position);
  63         ServerActiveObject::setBasePosition(position);
  64         m_position_not_sent = true;
  65 }
  66
  67 InventoryItem* ServerRemotePlayer::getWieldedItem()
  68 {
  69         InventoryList *list = inventory.getList("main");
  70         if (list)
  71                 return list->getItem(m_selected_item);
  72         return NULL;
  73 }
  74
  75 /* ServerActiveObject interface */
  76
  77 void ServerRemotePlayer::addedToEnvironment()
  78 {
  79         assert(!m_is_in_environment);
  80         m_is_in_environment = true;
  81 }
  82
  83 void ServerRemotePlayer::removingFromEnvironment()
  84 {
  85         assert(m_is_in_environment);
  86         m_is_in_environment = false;
  87 }
  88
  89 bool ServerRemotePlayer::unlimitedTransferDistance() const
  90 {
  91         return g_settings->getBool("unlimited_player_transfer_distance");
  92 }
  93
  94 void ServerRemotePlayer::step(float dtime, bool send_recommended)
  95 {
  96         if(send_recommended == false)
  97                 return;
  98
  99         if(m_position_not_sent)
 100         {
 101                 m_position_not_sent = false;
 102
 103                 std::ostringstream os(std::ios::binary);
 104                 // command (0 = update position)
 105                 writeU8(os, 0);
 106                 // pos
 107                 writeV3F1000(os, getPosition());
 108                 // yaw
 109                 writeF1000(os, getYaw());
 110                 // create message and add to list
 111                 ActiveObjectMessage aom(getId(), false, os.str());
 112                 m_messages_out.push_back(aom);
 113         }
 114 }
 115
 116 std::string ServerRemotePlayer::getClientInitializationData()
 117 {
 118         std::ostringstream os(std::ios::binary);
 119         // version
 120         writeU8(os, 0);
 121         // name
 122         os<<serializeString(getName());
 123         // pos
 124         writeV3F1000(os, getPosition());
 125         // yaw
 126         writeF1000(os, getYaw());
 127         return os.str();
 128 }
 129
 130 std::string ServerRemotePlayer::getStaticData()
 131 {
 132         assert(0);
 133         return "";
 134 }
 135
 136 void ServerRemotePlayer::punch(ServerActiveObject *puncher,
 137                 float time_from_last_punch)
 138 {
 139         if(!puncher)
 140                 return;
 141
 142         // No effect if PvP disabled
 143         if(g_settings->getBool("enable_pvp") == false){
 144                 if(puncher->getType() == ACTIVEOBJECT_TYPE_PLAYER)
 145                         return;
 146         }
 147
 148         // "Material" properties of a player
 149         MaterialProperties mp;
 150         mp.diggability = DIGGABLE_NORMAL;
 151         mp.crackiness = -0.5;
 152         mp.cuttability = 0.5;
 153
 154         ToolDiggingProperties tp;
 155         puncher->getWieldDiggingProperties(&tp);
 156
 157         HittingProperties hitprop = getHittingProperties(&mp, &tp,
 158                         time_from_last_punch);
 159
 160         setHP(getHP() - hitprop.hp);
 161         puncher->damageWieldedItem(hitprop.wear);
 162
 163         {
 164                 std::ostringstream os(std::ios::binary);
 165                 // command (1 = punched)
 166                 writeU8(os, 1);
 167                 // damage
 168                 writeS16(os, hitprop.hp);
 169                 // create message and add to list
 170                 ActiveObjectMessage aom(getId(), false, os.str());
 171                 m_messages_out.push_back(aom);
 172         }
 173 }
 174
 175 void ServerRemotePlayer::rightClick(ServerActiveObject *clicker)
 176 {
 177 }
 178
 179 void ServerRemotePlayer::setPos(v3f pos)
 180 {
 181         setPosition(pos);
 182         // Movement caused by this command is always valid
 183         m_last_good_position = pos;
 184         m_last_good_position_age = 0;
 185 }
 186 void ServerRemotePlayer::moveTo(v3f pos, bool continuous)
 187 {
 188         setPosition(pos);
 189         // Movement caused by this command is always valid
 190         m_last_good_position = pos;
 191         m_last_good_position_age = 0;
 192 }
 193
 194 void ServerRemotePlayer::getWieldDiggingProperties(ToolDiggingProperties *dst)
 195 {
 196         IGameDef *gamedef = m_env->getGameDef();
 197         IToolDefManager *tdef = gamedef->tdef();
 198
 199         InventoryItem *item = getWieldedItem();
 200         if(item == NULL || std::string(item->getName()) != "ToolItem"){
 201                 *dst = ToolDiggingProperties();
 202                 return;
 203         }
 204         ToolItem *titem = (ToolItem*)item;
 205         *dst = tdef->getDiggingProperties(titem->getToolName());
 206 }
 207
 208 void ServerRemotePlayer::damageWieldedItem(u16 amount)
 209 {
 210         infostream<<"Damaging "<<getName()<<"'s wielded item for amount="
 211                         <<amount<<std::endl;
 212         InventoryList *list = inventory.getList("main");
 213         if(!list)
 214                 return;
 215         InventoryItem *item = list->getItem(m_selected_item);
 216         if(item && (std::string)item->getName() == "ToolItem"){
 217                 ToolItem *titem = (ToolItem*)item;
 218                 bool weared_out = titem->addWear(amount);
 219                 if(weared_out)
 220                         list->deleteItem(m_selected_item);
 221         }
 222 }
 223 bool ServerRemotePlayer::addToInventory(InventoryItem *item)
 224 {
 225         infostream<<"Adding "<<item->getName()<<" into "<<getName()
 226                         <<"'s inventory"<<std::endl;
 227
 228         InventoryList *ilist = inventory.getList("main");
 229         if(ilist == NULL)
 230                 return false;
 231
 232         // In creative mode, just delete the item
 233         if(g_settings->getBool("creative_mode")){
 234                 return false;
 235         }
 236
 237         // Skip if inventory has no free space
 238         if(ilist->roomForItem(item) == false)
 239         {
 240                 infostream<<"Player inventory has no free space"<<std::endl;
 241                 return false;
 242         }
 243
 244         // Add to inventory
 245         InventoryItem *leftover = ilist->addItem(item);
 246         assert(!leftover);
 247
 248         m_inventory_not_sent = true;
 249
 250         return true;
 251 }
 252 void ServerRemotePlayer::addToInventoryLater(InventoryItem *item)
 253 {
 254         infostream<<"Adding (later) "<<item->getName()<<" into "<<getName()
 255                         <<"'s inventory"<<std::endl;
 256         m_additional_items.push_back(item);
 257 }
 258 void ServerRemotePlayer::clearAddToInventoryLater()
 259 {
 260         for (std::vector<InventoryItem*>::iterator
 261                         i = m_additional_items.begin();
 262                         i != m_additional_items.end(); i++)
 263         {
 264                 delete *i;
 265         }
 266         m_additional_items.clear();
 267 }
 268 void ServerRemotePlayer::completeAddToInventoryLater(u16 preferred_index)
 269 {
 270         InventoryList *ilist = inventory.getList("main");
 271         if(ilist == NULL)
 272         {
 273                 clearAddToInventoryLater();
 274                 return;
 275         }
 276
 277         // In creative mode, just delete the items
 278         if(g_settings->getBool("creative_mode"))
 279         {
 280                 clearAddToInventoryLater();
 281                 return;
 282         }
 283
 284         for (std::vector<InventoryItem*>::iterator
 285                         i = m_additional_items.begin();
 286                         i != m_additional_items.end(); i++)
 287         {
 288                 InventoryItem *item = *i;
 289                 InventoryItem *leftover = item;
 290                 leftover = ilist->addItem(preferred_index, leftover);
 291                 leftover = ilist->addItem(leftover);
 292                 delete leftover;
 293         }
 294         m_additional_items.clear();
 295         m_inventory_not_sent = true;
 296 }
 297 void ServerRemotePlayer::setHP(s16 hp_)
 298 {
 299         s16 oldhp = hp;
 300
 301         // FIXME: don't hardcode maximum HP, make configurable per object
 302         if(hp_ < 0)
 303                 hp_ = 0;
 304         else if(hp_ > 20)
 305                 hp_ = 20;
 306         hp = hp_;
 307
 308         if(hp != oldhp)
 309                 m_hp_not_sent = true;
 310 }
 311 s16 ServerRemotePlayer::getHP()
 312 {
 313         return hp;
 314 }
 315
 316