src/clientenvironment.h

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2017 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 #pragma once
  21
  22 #include "environment.h"
  23 #include <ISceneManager.h>
  24 #include "clientobject.h"
  25 #include "util/numeric.h"
  26
  27 class ClientSimpleObject;
  28 class ClientMap;
  29 class ClientScripting;
  30 class ClientActiveObject;
  31 class GenericCAO;
  32 class LocalPlayer;
  33
  34 /*
  35         The client-side environment.
  36
  37         This is not thread-safe.
  38         Must be called from main (irrlicht) thread (uses the SceneManager)
  39         Client uses an environment mutex.
  40 */
  41
  42 enum ClientEnvEventType
  43 {
  44         CEE_NONE,
  45         CEE_PLAYER_DAMAGE,
  46         CEE_PLAYER_BREATH
  47 };
  48
  49 struct ClientEnvEvent
  50 {
  51         ClientEnvEventType type;
  52         union {
  53                 //struct{
  54                 //} none;
  55                 struct{
  56                         u8 amount;
  57                         bool send_to_server;
  58                 } player_damage;
  59                 struct{
  60                         u16 amount;
  61                 } player_breath;
  62         };
  63 };
  64
  65 typedef std::unordered_map<u16, ClientActiveObject*> ClientActiveObjectMap;
  66 class ClientEnvironment : public Environment
  67 {
  68 public:
  69         ClientEnvironment(ClientMap *map, ITextureSource *texturesource, Client *client);
  70         ~ClientEnvironment();
  71
  72         Map & getMap();
  73         ClientMap & getClientMap();
  74
  75         Client *getGameDef() { return m_client; }
  76         void setScript(ClientScripting *script) { m_script = script; }
  77
  78         void step(f32 dtime);
  79
  80         virtual void setLocalPlayer(LocalPlayer *player);
  81         LocalPlayer *getLocalPlayer() { return m_local_player; }
  82
  83         /*
  84                 ClientSimpleObjects
  85         */
  86
  87         void addSimpleObject(ClientSimpleObject *simple);
  88
  89         /*
  90                 ActiveObjects
  91         */
  92
  93         GenericCAO* getGenericCAO(u16 id);
  94         ClientActiveObject* getActiveObject(u16 id);
  95
  96         /*
  97                 Adds an active object to the environment.
  98                 Environment handles deletion of object.
  99                 Object may be deleted by environment immediately.
 100                 If id of object is 0, assigns a free id to it.
 101                 Returns the id of the object.
 102                 Returns 0 if not added and thus deleted.
 103         */
 104         u16 addActiveObject(ClientActiveObject *object);
 105
 106         void addActiveObject(u16 id, u8 type, const std::string &init_data);
 107         void removeActiveObject(u16 id);
 108
 109         void processActiveObjectMessage(u16 id, const std::string &data);
 110
 111         /*
 112                 Callbacks for activeobjects
 113         */
 114
 115         void damageLocalPlayer(u8 damage, bool handle_hp=true);
 116         void updateLocalPlayerBreath(u16 breath);
 117
 118         /*
 119                 Client likes to call these
 120         */
 121
 122         // Get all nearby objects
 123         void getActiveObjects(v3f origin, f32 max_d,
 124                 std::vector<DistanceSortedActiveObject> &dest);
 125
 126         bool hasClientEnvEvents() const { return !m_client_event_queue.empty(); }
 127
 128         // Get event from queue. If queue is empty, it triggers an assertion failure.
 129         ClientEnvEvent getClientEnvEvent();
 130
 131         virtual void getSelectedActiveObjects(
 132                 const core::line3d<f32> &shootline_on_map,
 133                 std::vector<PointedThing> &objects
 134         );
 135
 136         u16 attachement_parent_ids[USHRT_MAX + 1];
 137
 138         const std::list<std::string> &getPlayerNames() { return m_player_names; }
 139         void addPlayerName(const std::string &name) { m_player_names.push_back(name); }
 140         void removePlayerName(const std::string &name) { m_player_names.remove(name); }
 141         void updateCameraOffset(const v3s16 &camera_offset)
 142         { m_camera_offset = camera_offset; }
 143         v3s16 getCameraOffset() const { return m_camera_offset; }
 144 private:
 145         ClientMap *m_map;
 146         LocalPlayer *m_local_player = nullptr;
 147         ITextureSource *m_texturesource;
 148         Client *m_client;
 149         ClientScripting *m_script = nullptr;
 150         ClientActiveObjectMap m_active_objects;
 151         std::vector<ClientSimpleObject*> m_simple_objects;
 152         std::queue<ClientEnvEvent> m_client_event_queue;
 153         IntervalLimiter m_active_object_light_update_interval;
 154         IntervalLimiter m_lava_hurt_interval;
 155         IntervalLimiter m_drowning_interval;
 156         IntervalLimiter m_breathing_interval;
 157         std::list<std::string> m_player_names;
 158         v3s16 m_camera_offset;
 159 };