src/server/player_sao.h

   1 // Luanti
   2 // SPDX-License-Identifier: LGPL-2.1-or-later
   3 // Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4 // Copyright (C) 2013-2020 Minetest core developers & community
   5
   6 #pragma once
   7
   8 #include "constants.h"
   9 #include "metadata.h"
  10 #include "network/networkprotocol.h"
  11 #include "unit_sao.h"
  12 #include "util/numeric.h"
  13
  14 /*
  15         PlayerSAO needs some internals exposed.
  16 */
  17
  18 class LagPool
  19 {
  20         float m_pool = 15.0f;
  21         float m_max = 15.0f;
  22
  23 public:
  24         LagPool() = default;
  25
  26         void setMax(float new_max)
  27         {
  28                 m_max = new_max;
  29                 if (m_pool > new_max)
  30                         m_pool = new_max;
  31         }
  32
  33         void add(float dtime)
  34         {
  35                 m_pool -= dtime;
  36                 if (m_pool < 0)
  37                         m_pool = 0;
  38         }
  39
  40         void empty() { m_pool = m_max; }
  41
  42         bool grab(float dtime)
  43         {
  44                 if (dtime <= 0)
  45                         return true;
  46                 if (m_pool + dtime > m_max)
  47                         return false;
  48                 m_pool += dtime;
  49                 return true;
  50         }
  51 };
  52
  53 class RemotePlayer;
  54
  55 class PlayerSAO : public UnitSAO
  56 {
  57 public:
  58         PlayerSAO(ServerEnvironment *env_, RemotePlayer *player_, session_t peer_id_,
  59                         bool is_singleplayer);
  60
  61         ActiveObjectType getType() const override { return ACTIVEOBJECT_TYPE_PLAYER; }
  62         ActiveObjectType getSendType() const override { return ACTIVEOBJECT_TYPE_GENERIC; }
  63         std::string getDescription() override;
  64
  65         /*
  66                 Active object <-> environment interface
  67         */
  68
  69         void addedToEnvironment(u32 dtime_s) override;
  70         void removingFromEnvironment() override;
  71         bool isStaticAllowed() const override { return false; }
  72         bool shouldUnload() const override { return false; }
  73         std::string getClientInitializationData(u16 protocol_version) override;
  74         void getStaticData(std::string *result) const override;
  75         void step(float dtime, bool send_recommended) override;
  76         void setBasePosition(v3f position);
  77         void setPos(const v3f &pos) override;
  78         void addPos(const v3f &added_pos) override;
  79         void moveTo(v3f pos, bool continuous) override;
  80         void setPlayerYaw(const float yaw);
  81         // Data should not be sent at player initialization
  82         void setPlayerYawAndSend(const float yaw);
  83         void setLookPitch(const float pitch);
  84         // Data should not be sent at player initialization
  85         void setLookPitchAndSend(const float pitch);
  86         f32 getLookPitch() const { return m_pitch; }
  87         f32 getRadLookPitch() const { return m_pitch * core::DEGTORAD; }
  88         // Deprecated
  89         f32 getRadLookPitchDep() const { return -1.0 * m_pitch * core::DEGTORAD; }
  90         void setFov(const float pitch);
  91         f32 getFov() const { return m_fov; }
  92         void setWantedRange(const s16 range);
  93         s16 getWantedRange() const { return m_wanted_range; }
  94         void setCameraInverted(bool camera_inverted) { m_camera_inverted = camera_inverted; }
  95         bool getCameraInverted() const { return m_camera_inverted; }
  96
  97         /*
  98                 Interaction interface
  99         */
 100
 101         u32 punch(v3f dir, const ToolCapabilities *toolcap, ServerActiveObject *puncher,
 102                         float time_from_last_punch, u16 initial_wear = 0) override;
 103         void rightClick(ServerActiveObject *clicker) override;
 104         void setHP(s32 hp, const PlayerHPChangeReason &reason) override
 105         {
 106                 return setHP(hp, reason, false);
 107         }
 108         void setHP(s32 hp, const PlayerHPChangeReason &reason, bool from_client);
 109         void setHPRaw(u16 hp) { m_hp = hp; }
 110         u16 getBreath() const { return m_breath; }
 111         void setBreath(const u16 breath, bool send = true);
 112         void respawn();
 113
 114         /*
 115                 Inventory interface
 116         */
 117         Inventory *getInventory() const override;
 118         InventoryLocation getInventoryLocation() const override;
 119         void setInventoryModified() override {}
 120         std::string getWieldList() const override { return "main"; }
 121         u16 getWieldIndex() const override;
 122         ItemStack getWieldedItem(ItemStack *selected, ItemStack *hand = nullptr) const override;
 123         bool setWieldedItem(const ItemStack &item) override;
 124
 125         /*
 126                 PlayerSAO-specific
 127         */
 128
 129         void disconnected();
 130
 131         void setPlayer(RemotePlayer *player) { m_player = player; }
 132         RemotePlayer *getPlayer() { return m_player; }
 133         session_t getPeerID() const;
 134
 135         // Cheat prevention
 136
 137         v3f getLastGoodPosition() const { return m_last_good_position; }
 138         float resetTimeFromLastPunch()
 139         {
 140                 float r = m_time_from_last_punch;
 141                 m_time_from_last_punch = 0.0;
 142                 return r;
 143         }
 144         void noCheatDigStart(const v3s16 &p)
 145         {
 146                 m_nocheat_dig_pos = p;
 147                 m_nocheat_dig_time = 0;
 148         }
 149         v3s16 getNoCheatDigPos() { return m_nocheat_dig_pos; }
 150         float getNoCheatDigTime() { return m_nocheat_dig_time; }
 151         void noCheatDigEnd() { m_nocheat_dig_pos = v3s16(32767, 32767, 32767); }
 152         LagPool &getDigPool() { return m_dig_pool; }
 153         void setMaxSpeedOverride(const v3f &vel);
 154         // Returns true if cheated
 155         bool checkMovementCheat();
 156
 157         // Other
 158
 159         void updatePrivileges(const std::set<std::string> &privs)
 160         {
 161                 m_privs = privs;
 162         }
 163
 164         inline void setNewPlayer() { m_is_new_player = true; }
 165         inline bool isNewPlayer()  { return m_is_new_player; }
 166
 167         bool getCollisionBox(aabb3f *toset) const override;
 168         bool getSelectionBox(aabb3f *toset) const override;
 169         bool collideWithObjects() const override { return true; }
 170
 171         void finalize(RemotePlayer *player, const std::set<std::string> &privs);
 172
 173         v3f getEyePosition() const { return m_base_position + getEyeOffset(); }
 174         v3f getEyeOffset() const;
 175         float getZoomFOV() const;
 176
 177         inline SimpleMetadata &getMeta() { return m_meta; }
 178
 179 private:
 180         std::string getPropertyPacket();
 181         void unlinkPlayerSessionAndSave();
 182         std::string generateUpdatePhysicsOverrideCommand() const;
 183
 184         RemotePlayer *m_player = nullptr;
 185         session_t m_peer_id_initial = 0; ///< only used to initialize RemotePlayer
 186
 187         // Cheat prevention
 188         LagPool m_dig_pool;
 189         LagPool m_move_pool;
 190         v3f m_last_good_position;
 191         float m_time_from_last_teleport = 0.0f;
 192         float m_time_from_last_punch = 0.0f;
 193         v3s16 m_nocheat_dig_pos = v3s16(32767, 32767, 32767);
 194         float m_nocheat_dig_time = 0.0f;
 195         float m_max_speed_override_time = 0.0f;
 196         v3f m_max_speed_override = v3f(0.0f, 0.0f, 0.0f);
 197
 198         // Timers
 199         IntervalLimiter m_breathing_interval;
 200         IntervalLimiter m_drowning_interval;
 201         IntervalLimiter m_node_hurt_interval;
 202
 203         bool m_position_not_sent = false;
 204
 205         // Cached privileges for enforcement
 206         std::set<std::string> m_privs;
 207         const bool m_is_singleplayer;
 208         bool m_is_new_player = false;
 209
 210         u16 m_breath = PLAYER_MAX_BREATH_DEFAULT;
 211         f32 m_pitch = 0.0f;
 212         f32 m_fov = 0.0f;
 213         s16 m_wanted_range = 0.0f;
 214
 215         bool m_camera_inverted = false; // this is not store in the player db
 216
 217         SimpleMetadata m_meta;
 218
 219 public:
 220         struct {
 221                 bool breathing : 1;
 222                 bool drowning : 1;
 223                 bool node_damage : 1;
 224         } m_flags = {true, true, true};
 225
 226         bool m_physics_override_sent = false;
 227 };
 228
 229 struct PlayerHPChangeReason
 230 {
 231         enum Type : u8
 232         {
 233                 SET_HP,
 234                 SET_HP_MAX, // internal type to allow distinguishing hp reset and damage (for effects)
 235                 PLAYER_PUNCH,
 236                 FALL,
 237                 NODE_DAMAGE,
 238                 DROWNING,
 239                 RESPAWN
 240         };
 241
 242         Type type = SET_HP;
 243         bool from_mod = false;
 244         int lua_reference = -1;
 245
 246         // For PLAYER_PUNCH
 247         ServerActiveObject *object = nullptr;
 248         // For NODE_DAMAGE
 249         std::string node;
 250         v3s16 node_pos;
 251
 252         inline bool hasLuaReference() const { return lua_reference >= 0; }
 253
 254         bool setTypeFromString(const std::string &typestr)
 255         {
 256                 if (typestr == "set_hp")
 257                         type = SET_HP;
 258                 else if (typestr == "punch")
 259                         type = PLAYER_PUNCH;
 260                 else if (typestr == "fall")
 261                         type = FALL;
 262                 else if (typestr == "node_damage")
 263                         type = NODE_DAMAGE;
 264                 else if (typestr == "drown")
 265                         type = DROWNING;
 266                 else if (typestr == "respawn")
 267                         type = RESPAWN;
 268                 else
 269                         return false;
 270
 271                 return true;
 272         }
 273
 274         std::string getTypeAsString() const
 275         {
 276                 switch (type) {
 277                 case PlayerHPChangeReason::SET_HP:
 278                 case PlayerHPChangeReason::SET_HP_MAX:
 279                         return "set_hp";
 280                 case PlayerHPChangeReason::PLAYER_PUNCH:
 281                         return "punch";
 282                 case PlayerHPChangeReason::FALL:
 283                         return "fall";
 284                 case PlayerHPChangeReason::NODE_DAMAGE:
 285                         return "node_damage";
 286                 case PlayerHPChangeReason::DROWNING:
 287                         return "drown";
 288                 case PlayerHPChangeReason::RESPAWN:
 289                         return "respawn";
 290                 default:
 291                         return "?";
 292                 }
 293         }
 294
 295         PlayerHPChangeReason(Type type) : type(type) {}
 296
 297         PlayerHPChangeReason(Type type, ServerActiveObject *object) :
 298                         type(type), object(object)
 299         {
 300         }
 301
 302         PlayerHPChangeReason(Type type, std::string node, v3s16 node_pos) : type(type), node(node), node_pos(node_pos) {}
 303 };