player.h

Go to the documentation of this file.

// Luanti
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
#pragma once
 
#include "irrlichttypes_bloated.h"
#include "inventory.h"
#include "constants.h"
#include "util/basic_macros.h"
#include "util/string.h"
#include <mutex>
#include <functional>
#include <string>
 
#define PLAYERNAME_SIZE 20
 
#define PLAYERNAME_ALLOWED_CHARS "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_"
#define PLAYERNAME_ALLOWED_CHARS_USER_EXPL "'a' to 'z', 'A' to 'Z', '0' to '9', '-', '_'"
 
bool is_valid_player_name(std::string_view name);
 
struct PlayerFovSpec
{
        f32 fov;
 
        // Whether to multiply the client's FOV or to override it
        bool is_multiplier;
 
        // The time to be take to trasition to the new FOV value.
        // Transition is instantaneous if omitted. Omitted by default.
        f32 transition_time = 0;
 
        inline bool operator==(const PlayerFovSpec &other) const {
                // transition_time is compared here since that could be relevant
                // when aborting a running transition.
                return fov == other.fov && is_multiplier == other.is_multiplier &&
                        transition_time == other.transition_time;
        }
        inline bool operator!=(const PlayerFovSpec &other) const {
                return !(*this == other);
        }
};
 
struct PlayerControl
{
        PlayerControl() = default;
 
        PlayerControl(
                bool a_up, bool a_down, bool a_left, bool a_right,
                bool a_jump, bool a_aux1, bool a_sneak,
                bool a_zoom,
                bool a_dig, bool a_place,
                float a_pitch, float a_yaw,
                float a_movement_speed, float a_movement_direction
        )
        {
                // Encode direction keys into a single value so nobody uses it accidentally
                // as movement_{speed,direction} is supposed to be the source of truth.
                direction_keys = (a_up&1) | ((a_down&1) << 1) |
                        ((a_left&1) << 2) | ((a_right&1) << 3);
                jump = a_jump;
                aux1 = a_aux1;
                sneak = a_sneak;
                zoom = a_zoom;
                dig = a_dig;
                place = a_place;
                pitch = a_pitch;
                yaw = a_yaw;
                movement_speed = a_movement_speed;
                movement_direction = a_movement_direction;
        }
 
        // Sets movement_speed and movement_direction according to direction_keys
        // if direction_keys != 0, otherwise leaves them unchanged to preserve
        // joystick input.
        void setMovementFromKeys();
 
        // For client use
        u32 getKeysPressed() const;
        inline bool isMoving() const { return movement_speed > 0.001f; }
 
        // For server use
        void unpackKeysPressed(u32 keypress_bits);
        v2f getMovement() const;
 
        u8 direction_keys = 0;
        bool jump = false;
        bool aux1 = false;
        bool sneak = false;
        bool zoom = false;
        bool dig = false;
        bool place = false;
        // Note: These two are NOT available on the server
        float pitch = 0.0f;
        float yaw = 0.0f;
        float movement_speed = 0.0f;
        float movement_direction = 0.0f;
};
 
struct PlayerPhysicsOverride
{
        float speed = 1.f;
        float jump = 1.f;
        float gravity = 1.f;
 
        bool sneak = true;
        bool sneak_glitch = false;
        // "Temporary" option for old move code
        bool new_move = true;
 
        float speed_climb = 1.f;
        float speed_crouch = 1.f;
        float liquid_fluidity = 1.f;
        float liquid_fluidity_smooth = 1.f;
        float liquid_sink = 1.f;
        float acceleration_default = 1.f;
        float acceleration_air = 1.f;
        float speed_fast = 1.f;
        float acceleration_fast = 1.f;
        float speed_walk = 1.f;
 
        bool operator==(const PlayerPhysicsOverride &other) const;
        bool operator!=(const PlayerPhysicsOverride &other) const {
                return !(*this == other);
        }
};
 
class Map;
struct CollisionInfo;
struct HudElement;
class Environment;
 
class Player
{
public:
 
        Player(const std::string &name, IItemDefManager *idef);
        virtual ~Player() = 0;
 
        DISABLE_CLASS_COPY(Player);
 
        virtual void move(f32 dtime, Environment *env, f32 pos_max_d)
        {}
        virtual void move(f32 dtime, Environment *env, f32 pos_max_d,
                        std::vector<CollisionInfo> *collision_info)
        {}
 
        // in BS-space
        inline void setSpeed(v3f speed)
        {
                m_speed = speed;
        }
 
        // in BS-space
        v3f getSpeed() const { return m_speed; }
 
        const std::string& getName() const { return m_name; }
 
        u32 getFreeHudID()
        {
                size_t size = hud.size();
                for (size_t i = 0; i != size; i++) {
                        if (!hud[i])
                                return i;
                }
                return size;
        }
 
        v3f eye_offset_first;
        v3f eye_offset_third;
        v3f eye_offset_third_front;
 
        Inventory inventory;
 
        f32 movement_acceleration_default;
        f32 movement_acceleration_air;
        f32 movement_acceleration_fast;
        f32 movement_speed_walk;
        f32 movement_speed_crouch;
        f32 movement_speed_fast;
        f32 movement_speed_climb;
        f32 movement_speed_jump;
        f32 movement_liquid_fluidity;
        f32 movement_liquid_fluidity_smooth;
        f32 movement_liquid_sink;
        f32 movement_gravity;
 
        v2f local_animations[4];
        float local_animation_speed;
 
        std::string inventory_formspec;
        std::string formspec_prepend;
 
        PlayerControl control;
        const PlayerControl& getPlayerControl() { return control; }
 
        PlayerPhysicsOverride physics_override;
 
        // Returns non-empty `selected` ItemStack. `hand` is a fallback, if specified
        ItemStack &getWieldedItem(ItemStack *selected, ItemStack *hand) const;
        void setWieldIndex(u16 index);
        u16 getWieldIndex();
 
        bool setFov(const PlayerFovSpec &spec)
        {
                if (m_fov_override_spec == spec)
                        return false;
                m_fov_override_spec = spec;
                return true;
        }
 
        const PlayerFovSpec &getFov() const
        {
                return m_fov_override_spec;
        }
 
        HudElement* getHud(u32 id);
        void        hudApply(std::function<void(const std::vector<HudElement*>&)> f);
        u32         addHud(HudElement* hud);
        HudElement* removeHud(u32 id);
        void        clearHud();
 
        u32 hud_flags;
        s32 hud_hotbar_itemcount;
 
        // Get actual usable number of hotbar items (clamped to size of "main" list)
        u16 getMaxHotbarItemcount();
 
protected:
        std::string m_name;
        v3f m_speed; // velocity; in BS-space
        u16 m_wield_index = 0;
        PlayerFovSpec m_fov_override_spec = { 0.0f, false, 0.0f };
 
        std::vector<HudElement *> hud;
 
private:
        // Protect some critical areas
        // hud for example can be modified by EmergeThread
        // and ServerThread
        // FIXME: ^ this sounds like nonsense. should be checked.
        std::mutex m_mutex;
};