src/server.h

   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 #ifndef SERVER_HEADER
  21 #define SERVER_HEADER
  22
  23 #include "connection.h"
  24 #include "environment.h"
  25 #include "irrlichttypes_bloated.h"
  26 #include <string>
  27 #include "porting.h"
  28 #include "map.h"
  29 #include "inventory.h"
  30 #include "ban.h"
  31 #include "hud.h"
  32 #include "gamedef.h"
  33 #include "serialization.h" // For SER_FMT_VER_INVALID
  34 #include "mods.h"
  35 #include "inventorymanager.h"
  36 #include "subgame.h"
  37 #include "sound.h"
  38 #include "util/thread.h"
  39 #include "util/string.h"
  40 #include "rollback_interface.h" // Needed for rollbackRevertActions()
  41 #include <list> // Needed for rollbackRevertActions()
  42 #include <algorithm>
  43
  44 #define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
  45
  46 class IWritableItemDefManager;
  47 class IWritableNodeDefManager;
  48 class IWritableCraftDefManager;
  49 class EventManager;
  50 class PlayerSAO;
  51 class IRollbackManager;
  52 class EmergeManager;
  53 //struct HudElement; ?????????
  54 class ScriptApi;
  55
  56
  57 class ServerError : public std::exception
  58 {
  59 public:
  60         ServerError(const std::string &s)
  61         {
  62                 m_s = "ServerError: ";
  63                 m_s += s;
  64         }
  65         virtual ~ServerError() throw()
  66         {}
  67         virtual const char * what() const throw()
  68         {
  69                 return m_s.c_str();
  70         }
  71         std::string m_s;
  72 };
  73
  74 /*
  75         Some random functions
  76 */
  77 v3f findSpawnPos(ServerMap &map);
  78
  79
  80 class MapEditEventIgnorer
  81 {
  82 public:
  83         MapEditEventIgnorer(bool *flag):
  84                 m_flag(flag)
  85         {
  86                 if(*m_flag == false)
  87                         *m_flag = true;
  88                 else
  89                         m_flag = NULL;
  90         }
  91
  92         ~MapEditEventIgnorer()
  93         {
  94                 if(m_flag)
  95                 {
  96                         assert(*m_flag);
  97                         *m_flag = false;
  98                 }
  99         }
 100
 101 private:
 102         bool *m_flag;
 103 };
 104
 105 class MapEditEventAreaIgnorer
 106 {
 107 public:
 108         MapEditEventAreaIgnorer(VoxelArea *ignorevariable, const VoxelArea &a):
 109                 m_ignorevariable(ignorevariable)
 110         {
 111                 if(m_ignorevariable->getVolume() == 0)
 112                         *m_ignorevariable = a;
 113                 else
 114                         m_ignorevariable = NULL;
 115         }
 116
 117         ~MapEditEventAreaIgnorer()
 118         {
 119                 if(m_ignorevariable)
 120                 {
 121                         assert(m_ignorevariable->getVolume() != 0);
 122                         *m_ignorevariable = VoxelArea();
 123                 }
 124         }
 125
 126 private:
 127         VoxelArea *m_ignorevariable;
 128 };
 129
 130 class Server;
 131
 132 class ServerThread : public SimpleThread
 133 {
 134         Server *m_server;
 135
 136 public:
 137
 138         ServerThread(Server *server):
 139                 SimpleThread(),
 140                 m_server(server)
 141         {
 142         }
 143
 144         void * Thread();
 145 };
 146
 147 struct PlayerInfo
 148 {
 149         u16 id;
 150         char name[PLAYERNAME_SIZE];
 151         v3f position;
 152         Address address;
 153         float avg_rtt;
 154
 155         PlayerInfo();
 156         void PrintLine(std::ostream *s);
 157 };
 158
 159 /*
 160         Used for queueing and sorting block transfers in containers
 161
 162         Lower priority number means higher priority.
 163 */
 164 struct PrioritySortedBlockTransfer
 165 {
 166         PrioritySortedBlockTransfer(float a_priority, v3s16 a_pos, u16 a_peer_id)
 167         {
 168                 priority = a_priority;
 169                 pos = a_pos;
 170                 peer_id = a_peer_id;
 171         }
 172         bool operator < (const PrioritySortedBlockTransfer &other) const
 173         {
 174                 return priority < other.priority;
 175         }
 176         float priority;
 177         v3s16 pos;
 178         u16 peer_id;
 179 };
 180
 181 struct MediaRequest
 182 {
 183         std::string name;
 184
 185         MediaRequest(const std::string &name_=""):
 186                 name(name_)
 187         {}
 188 };
 189
 190 struct MediaInfo
 191 {
 192         std::string path;
 193         std::string sha1_digest;
 194
 195         MediaInfo(const std::string path_="",
 196                         const std::string sha1_digest_=""):
 197                 path(path_),
 198                 sha1_digest(sha1_digest_)
 199         {
 200         }
 201 };
 202
 203 struct ServerSoundParams
 204 {
 205         float gain;
 206         std::string to_player;
 207         enum Type{
 208                 SSP_LOCAL=0,
 209                 SSP_POSITIONAL=1,
 210                 SSP_OBJECT=2
 211         } type;
 212         v3f pos;
 213         u16 object;
 214         float max_hear_distance;
 215         bool loop;
 216
 217         ServerSoundParams():
 218                 gain(1.0),
 219                 to_player(""),
 220                 type(SSP_LOCAL),
 221                 pos(0,0,0),
 222                 object(0),
 223                 max_hear_distance(32*BS),
 224                 loop(false)
 225         {}
 226
 227         v3f getPos(ServerEnvironment *env, bool *pos_exists) const;
 228 };
 229
 230 struct ServerPlayingSound
 231 {
 232         ServerSoundParams params;
 233         std::set<u16> clients; // peer ids
 234 };
 235
 236 class RemoteClient
 237 {
 238 public:
 239         // peer_id=0 means this client has no associated peer
 240         // NOTE: If client is made allowed to exist while peer doesn't,
 241         //       this has to be set to 0 when there is no peer.
 242         //       Also, the client must be moved to some other container.
 243         u16 peer_id;
 244         // The serialization version to use with the client
 245         u8 serialization_version;
 246         //
 247         u16 net_proto_version;
 248         // Version is stored in here after INIT before INIT2
 249         u8 pending_serialization_version;
 250
 251         bool definitions_sent;
 252
 253         bool denied;
 254
 255         RemoteClient():
 256                 m_time_from_building(9999),
 257                 m_excess_gotblocks(0)
 258         {
 259                 peer_id = 0;
 260                 serialization_version = SER_FMT_VER_INVALID;
 261                 net_proto_version = 0;
 262                 pending_serialization_version = SER_FMT_VER_INVALID;
 263                 definitions_sent = false;
 264                 denied = false;
 265                 m_nearest_unsent_d = 0;
 266                 m_nearest_unsent_reset_timer = 0.0;
 267                 m_nothing_to_send_counter = 0;
 268                 m_nothing_to_send_pause_timer = 0;
 269         }
 270         ~RemoteClient()
 271         {
 272         }
 273
 274         /*
 275                 Finds block that should be sent next to the client.
 276                 Environment should be locked when this is called.
 277                 dtime is used for resetting send radius at slow interval
 278         */
 279         void GetNextBlocks(Server *server, float dtime,
 280                         std::vector<PrioritySortedBlockTransfer> &dest);
 281
 282         void GotBlock(v3s16 p);
 283
 284         void SentBlock(v3s16 p);
 285
 286         void SetBlockNotSent(v3s16 p);
 287         void SetBlocksNotSent(std::map<v3s16, MapBlock*> &blocks);
 288
 289         s32 SendingCount()
 290         {
 291                 return m_blocks_sending.size();
 292         }
 293
 294         // Increments timeouts and removes timed-out blocks from list
 295         // NOTE: This doesn't fix the server-not-sending-block bug
 296         //       because it is related to emerging, not sending.
 297         //void RunSendingTimeouts(float dtime, float timeout);
 298
 299         void PrintInfo(std::ostream &o)
 300         {
 301                 o<<"RemoteClient "<<peer_id<<": "
 302                                 <<"m_blocks_sent.size()="<<m_blocks_sent.size()
 303                                 <<", m_blocks_sending.size()="<<m_blocks_sending.size()
 304                                 <<", m_nearest_unsent_d="<<m_nearest_unsent_d
 305                                 <<", m_excess_gotblocks="<<m_excess_gotblocks
 306                                 <<std::endl;
 307                 m_excess_gotblocks = 0;
 308         }
 309
 310         // Time from last placing or removing blocks
 311         float m_time_from_building;
 312
 313         /*JMutex m_dig_mutex;
 314         float m_dig_time_remaining;
 315         // -1 = not digging
 316         s16 m_dig_tool_item;
 317         v3s16 m_dig_position;*/
 318
 319         /*
 320                 List of active objects that the client knows of.
 321                 Value is dummy.
 322         */
 323         std::set<u16> m_known_objects;
 324
 325 private:
 326         /*
 327                 Blocks that have been sent to client.
 328                 - These don't have to be sent again.
 329                 - A block is cleared from here when client says it has
 330                   deleted it from it's memory
 331
 332                 Key is position, value is dummy.
 333                 No MapBlock* is stored here because the blocks can get deleted.
 334         */
 335         std::set<v3s16> m_blocks_sent;
 336         s16 m_nearest_unsent_d;
 337         v3s16 m_last_center;
 338         float m_nearest_unsent_reset_timer;
 339
 340         /*
 341                 Blocks that are currently on the line.
 342                 This is used for throttling the sending of blocks.
 343                 - The size of this list is limited to some value
 344                 Block is added when it is sent with BLOCKDATA.
 345                 Block is removed when GOTBLOCKS is received.
 346                 Value is time from sending. (not used at the moment)
 347         */
 348         std::map<v3s16, float> m_blocks_sending;
 349
 350         /*
 351                 Count of excess GotBlocks().
 352                 There is an excess amount because the client sometimes
 353                 gets a block so late that the server sends it again,
 354                 and the client then sends two GOTBLOCKs.
 355                 This is resetted by PrintInfo()
 356         */
 357         u32 m_excess_gotblocks;
 358
 359         // CPU usage optimization
 360         u32 m_nothing_to_send_counter;
 361         float m_nothing_to_send_pause_timer;
 362 };
 363
 364 class Server : public con::PeerHandler, public MapEventReceiver,
 365                 public InventoryManager, public IGameDef,
 366                 public IBackgroundBlockEmerger
 367 {
 368 public:
 369         /*
 370                 NOTE: Every public method should be thread-safe
 371         */
 372
 373         Server(
 374                 const std::string &path_world,
 375                 const std::string &path_config,
 376                 const SubgameSpec &gamespec,
 377                 bool simple_singleplayer_mode
 378         );
 379         ~Server();
 380         void start(unsigned short port);
 381         void stop();
 382         // This is mainly a way to pass the time to the server.
 383         // Actual processing is done in an another thread.
 384         void step(float dtime);
 385         // This is run by ServerThread and does the actual processing
 386         void AsyncRunStep();
 387         void Receive();
 388         void ProcessData(u8 *data, u32 datasize, u16 peer_id);
 389
 390         //std::list<PlayerInfo> getPlayerInfo();
 391
 392         // Environment must be locked when called
 393         void setTimeOfDay(u32 time)
 394         {
 395                 m_env->setTimeOfDay(time);
 396                 m_time_of_day_send_timer = 0;
 397         }
 398
 399         bool getShutdownRequested()
 400         {
 401                 return m_shutdown_requested;
 402         }
 403
 404         /*
 405                 Shall be called with the environment locked.
 406                 This is accessed by the map, which is inside the environment,
 407                 so it shouldn't be a problem.
 408         */
 409         void onMapEditEvent(MapEditEvent *event);
 410
 411         /*
 412                 Shall be called with the environment and the connection locked.
 413         */
 414         Inventory* getInventory(const InventoryLocation &loc);
 415         void setInventoryModified(const InventoryLocation &loc);
 416
 417         // Connection must be locked when called
 418         std::wstring getStatusString();
 419
 420         void requestShutdown(void)
 421         {
 422                 m_shutdown_requested = true;
 423         }
 424
 425         // Returns -1 if failed, sound handle on success
 426         // Envlock + conlock
 427         s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams &params);
 428         void stopSound(s32 handle);
 429
 430         // Envlock + conlock
 431         std::set<std::string> getPlayerEffectivePrivs(const std::string &name);
 432         bool checkPriv(const std::string &name, const std::string &priv);
 433         void reportPrivsModified(const std::string &name=""); // ""=all
 434         void reportInventoryFormspecModified(const std::string &name);
 435
 436         // Saves g_settings to configpath given at initialization
 437         void saveConfig();
 438
 439         void setIpBanned(const std::string &ip, const std::string &name)
 440         {
 441                 m_banmanager.add(ip, name);
 442                 return;
 443         }
 444
 445         void unsetIpBanned(const std::string &ip_or_name)
 446         {
 447                 m_banmanager.remove(ip_or_name);
 448                 return;
 449         }
 450
 451         std::string getBanDescription(const std::string &ip_or_name)
 452         {
 453                 return m_banmanager.getBanDescription(ip_or_name);
 454         }
 455
 456         Address getPeerAddress(u16 peer_id)
 457         {
 458                 return m_con.GetPeerAddress(peer_id);
 459         }
 460
 461         // Envlock and conlock should be locked when calling this
 462         void notifyPlayer(const char *name, const std::wstring msg, const bool prepend);
 463         void notifyPlayers(const std::wstring msg);
 464         void spawnParticle(const char *playername,
 465                 v3f pos, v3f velocity, v3f acceleration,
 466                 float expirationtime, float size,
 467                 bool collisiondetection, std::string texture);
 468
 469         void spawnParticleAll(v3f pos, v3f velocity, v3f acceleration,
 470                 float expirationtime, float size,
 471                 bool collisiondetection, std::string texture);
 472
 473         u32 addParticleSpawner(const char *playername,
 474                 u16 amount, float spawntime,
 475                 v3f minpos, v3f maxpos,
 476                 v3f minvel, v3f maxvel,
 477                 v3f minacc, v3f maxacc,
 478                 float minexptime, float maxexptime,
 479                 float minsize, float maxsize,
 480                 bool collisiondetection, std::string texture);
 481
 482         u32 addParticleSpawnerAll(u16 amount, float spawntime,
 483                 v3f minpos, v3f maxpos,
 484                 v3f minvel, v3f maxvel,
 485                 v3f minacc, v3f maxacc,
 486                 float minexptime, float maxexptime,
 487                 float minsize, float maxsize,
 488                 bool collisiondetection, std::string texture);
 489
 490         void deleteParticleSpawner(const char *playername, u32 id);
 491         void deleteParticleSpawnerAll(u32 id);
 492
 493         void queueBlockEmerge(v3s16 blockpos, bool allow_generate);
 494
 495         // Creates or resets inventory
 496         Inventory* createDetachedInventory(const std::string &name);
 497
 498         // Envlock and conlock should be locked when using scriptapi
 499         ScriptApi *getScriptIface(){ return m_script; }
 500
 501         // Envlock should be locked when using the rollback manager
 502         IRollbackManager *getRollbackManager(){ return m_rollback; }
 503
 504         //TODO: determine what (if anything) should be locked to access EmergeManager
 505         EmergeManager *getEmergeManager(){ return m_emerge; }
 506
 507         // actions: time-reversed list
 508         // Return value: success/failure
 509         bool rollbackRevertActions(const std::list<RollbackAction> &actions,
 510                         std::list<std::string> *log);
 511
 512         // IGameDef interface
 513         // Under envlock
 514         virtual IItemDefManager* getItemDefManager();
 515         virtual INodeDefManager* getNodeDefManager();
 516         virtual ICraftDefManager* getCraftDefManager();
 517         virtual ITextureSource* getTextureSource();
 518         virtual IShaderSource* getShaderSource();
 519         virtual u16 allocateUnknownNodeId(const std::string &name);
 520         virtual ISoundManager* getSoundManager();
 521         virtual MtEventManager* getEventManager();
 522         virtual IRollbackReportSink* getRollbackReportSink();
 523
 524         IWritableItemDefManager* getWritableItemDefManager();
 525         IWritableNodeDefManager* getWritableNodeDefManager();
 526         IWritableCraftDefManager* getWritableCraftDefManager();
 527
 528         const ModSpec* getModSpec(const std::string &modname);
 529         void getModNames(std::list<std::string> &modlist);
 530         std::string getBuiltinLuaPath();
 531
 532         std::string getWorldPath(){ return m_path_world; }
 533
 534         bool isSingleplayer(){ return m_simple_singleplayer_mode; }
 535
 536         void setAsyncFatalError(const std::string &error)
 537         {
 538                 m_async_fatal_error.set(error);
 539         }
 540
 541         bool showFormspec(const char *name, const std::string &formspec, const std::string &formname);
 542
 543         u32 hudAdd(Player *player, HudElement *element);
 544         bool hudRemove(Player *player, u32 id);
 545         bool hudChange(Player *player, u32 id, HudElementStat stat, void *value);
 546         bool hudSetFlags(Player *player, u32 flags, u32 mask);
 547         bool hudSetHotbarItemcount(Player *player, s32 hotbar_itemcount);
 548
 549 private:
 550
 551         // con::PeerHandler implementation.
 552         // These queue stuff to be processed by handlePeerChanges().
 553         // As of now, these create and remove clients and players.
 554         void peerAdded(con::Peer *peer);
 555         void deletingPeer(con::Peer *peer, bool timeout);
 556
 557         /*
 558                 Static send methods
 559         */
 560
 561         static void SendMovement(con::Connection &con, u16 peer_id);
 562         static void SendHP(con::Connection &con, u16 peer_id, u8 hp);
 563         static void SendBreath(con::Connection &con, u16 peer_id, u16 breath);
 564         static void SendAccessDenied(con::Connection &con, u16 peer_id,
 565                         const std::wstring &reason);
 566         static void SendDeathscreen(con::Connection &con, u16 peer_id,
 567                         bool set_camera_point_target, v3f camera_point_target);
 568         static void SendItemDef(con::Connection &con, u16 peer_id,
 569                         IItemDefManager *itemdef, u16 protocol_version);
 570         static void SendNodeDef(con::Connection &con, u16 peer_id,
 571                         INodeDefManager *nodedef, u16 protocol_version);
 572
 573         /*
 574                 Non-static send methods.
 575                 Conlock should be always used.
 576                 Envlock usage is documented badly but it's easy to figure out
 577                 which ones access the environment.
 578         */
 579
 580         // Envlock and conlock should be locked when calling these
 581         void SendInventory(u16 peer_id);
 582         void SendChatMessage(u16 peer_id, const std::wstring &message);
 583         void BroadcastChatMessage(const std::wstring &message);
 584         void SendPlayerHP(u16 peer_id);
 585         void SendPlayerBreath(u16 peer_id);
 586         void SendMovePlayer(u16 peer_id);
 587         void SendPlayerPrivileges(u16 peer_id);
 588         void SendPlayerInventoryFormspec(u16 peer_id);
 589         void SendShowFormspecMessage(u16 peer_id, const std::string formspec, const std::string formname);
 590         void SendHUDAdd(u16 peer_id, u32 id, HudElement *form);
 591         void SendHUDRemove(u16 peer_id, u32 id);
 592         void SendHUDChange(u16 peer_id, u32 id, HudElementStat stat, void *value);
 593         void SendHUDSetFlags(u16 peer_id, u32 flags, u32 mask);
 594         void SendHUDSetParam(u16 peer_id, u16 param, const std::string &value);
 595
 596         /*
 597                 Send a node removal/addition event to all clients except ignore_id.
 598                 Additionally, if far_players!=NULL, players further away than
 599                 far_d_nodes are ignored and their peer_ids are added to far_players
 600         */
 601         // Envlock and conlock should be locked when calling these
 602         void sendRemoveNode(v3s16 p, u16 ignore_id=0,
 603                         std::list<u16> *far_players=NULL, float far_d_nodes=100);
 604         void sendAddNode(v3s16 p, MapNode n, u16 ignore_id=0,
 605                         std::list<u16> *far_players=NULL, float far_d_nodes=100);
 606         void setBlockNotSent(v3s16 p);
 607
 608         // Environment and Connection must be locked when called
 609         void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto_version);
 610
 611         // Sends blocks to clients (locks env and con on its own)
 612         void SendBlocks(float dtime);
 613
 614         void fillMediaCache();
 615         void sendMediaAnnouncement(u16 peer_id);
 616         void sendRequestedMedia(u16 peer_id,
 617                         const std::list<MediaRequest> &tosend);
 618
 619         void sendDetachedInventory(const std::string &name, u16 peer_id);
 620         void sendDetachedInventoryToAll(const std::string &name);
 621         void sendDetachedInventories(u16 peer_id);
 622
 623         // Adds a ParticleSpawner on peer with peer_id
 624         void SendAddParticleSpawner(u16 peer_id, u16 amount, float spawntime,
 625                 v3f minpos, v3f maxpos,
 626                 v3f minvel, v3f maxvel,
 627                 v3f minacc, v3f maxacc,
 628                 float minexptime, float maxexptime,
 629                 float minsize, float maxsize,
 630                 bool collisiondetection, std::string texture, u32 id);
 631
 632         // Adds a ParticleSpawner on all peers
 633         void SendAddParticleSpawnerAll(u16 amount, float spawntime,
 634                 v3f minpos, v3f maxpos,
 635                 v3f minvel, v3f maxvel,
 636                 v3f minacc, v3f maxacc,
 637                 float minexptime, float maxexptime,
 638                 float minsize, float maxsize,
 639                 bool collisiondetection, std::string texture, u32 id);
 640
 641         // Deletes ParticleSpawner on a single client
 642         void SendDeleteParticleSpawner(u16 peer_id, u32 id);
 643
 644         // Deletes ParticleSpawner on all clients
 645         void SendDeleteParticleSpawnerAll(u32 id);
 646
 647         // Spawns particle on single client
 648         void SendSpawnParticle(u16 peer_id,
 649                 v3f pos, v3f velocity, v3f acceleration,
 650                 float expirationtime, float size,
 651                 bool collisiondetection, std::string texture);
 652
 653         // Spawns particle on all clients
 654         void SendSpawnParticleAll(v3f pos, v3f velocity, v3f acceleration,
 655                 float expirationtime, float size,
 656                 bool collisiondetection, std::string texture);
 657
 658         /*
 659                 Something random
 660         */
 661
 662         void DiePlayer(u16 peer_id);
 663         void RespawnPlayer(u16 peer_id);
 664         void DenyAccess(u16 peer_id, const std::wstring &reason);
 665
 666         enum ClientDeletionReason {
 667                 CDR_LEAVE,
 668                 CDR_TIMEOUT,
 669                 CDR_DENY
 670         };
 671         void DeleteClient(u16 peer_id, ClientDeletionReason reason);
 672
 673         void UpdateCrafting(u16 peer_id);
 674
 675         // When called, connection mutex should be locked
 676         RemoteClient* getClient(u16 peer_id);
 677         RemoteClient* getClientNoEx(u16 peer_id);
 678
 679         // When called, environment mutex should be locked
 680         std::string getPlayerName(u16 peer_id)
 681         {
 682                 Player *player = m_env->getPlayer(peer_id);
 683                 if(player == NULL)
 684                         return "[id="+itos(peer_id)+"]";
 685                 return player->getName();
 686         }
 687
 688         // When called, environment mutex should be locked
 689         PlayerSAO* getPlayerSAO(u16 peer_id)
 690         {
 691                 Player *player = m_env->getPlayer(peer_id);
 692                 if(player == NULL)
 693                         return NULL;
 694                 return player->getPlayerSAO();
 695         }
 696
 697         /*
 698                 Get a player from memory or creates one.
 699                 If player is already connected, return NULL
 700                 Does not verify/modify auth info and password.
 701
 702                 Call with env and con locked.
 703         */
 704         PlayerSAO *emergePlayer(const char *name, u16 peer_id);
 705
 706         // Locks environment and connection by its own
 707         struct PeerChange;
 708         void handlePeerChange(PeerChange &c);
 709         void handlePeerChanges();
 710
 711         /*
 712                 Variables
 713         */
 714
 715         // World directory
 716         std::string m_path_world;
 717         // Path to user's configuration file ("" = no configuration file)
 718         std::string m_path_config;
 719         // Subgame specification
 720         SubgameSpec m_gamespec;
 721         // If true, do not allow multiple players and hide some multiplayer
 722         // functionality
 723         bool m_simple_singleplayer_mode;
 724
 725         // Thread can set; step() will throw as ServerError
 726         MutexedVariable<std::string> m_async_fatal_error;
 727
 728         // Some timers
 729         float m_liquid_transform_timer;
 730         float m_liquid_transform_every;
 731         float m_print_info_timer;
 732         float m_masterserver_timer;
 733         float m_objectdata_timer;
 734         float m_emergethread_trigger_timer;
 735         float m_savemap_timer;
 736         IntervalLimiter m_map_timer_and_unload_interval;
 737
 738         // NOTE: If connection and environment are both to be locked,
 739         // environment shall be locked first.
 740
 741         // Environment
 742         ServerEnvironment *m_env;
 743         JMutex m_env_mutex;
 744
 745         // Connection
 746         con::Connection m_con;
 747         JMutex m_con_mutex;
 748         // Connected clients (behind the con mutex)
 749         std::map<u16, RemoteClient*> m_clients;
 750         u16 m_clients_number; //for announcing masterserver
 751
 752         // Ban checking
 753         BanManager m_banmanager;
 754
 755         // Rollback manager (behind m_env_mutex)
 756         IRollbackManager *m_rollback;
 757         bool m_rollback_sink_enabled;
 758         bool m_enable_rollback_recording; // Updated once in a while
 759
 760         // Emerge manager
 761         EmergeManager *m_emerge;
 762
 763         // Scripting
 764         // Envlock and conlock should be locked when using Lua
 765         ScriptApi *m_script;
 766
 767         // Item definition manager
 768         IWritableItemDefManager *m_itemdef;
 769
 770         // Node definition manager
 771         IWritableNodeDefManager *m_nodedef;
 772
 773         // Craft definition manager
 774         IWritableCraftDefManager *m_craftdef;
 775
 776         // Event manager
 777         EventManager *m_event;
 778
 779         // Mods
 780         std::vector<ModSpec> m_mods;
 781
 782         /*
 783                 Threads
 784         */
 785
 786         // A buffer for time steps
 787         // step() increments and AsyncRunStep() run by m_thread reads it.
 788         float m_step_dtime;
 789         JMutex m_step_dtime_mutex;
 790
 791         // The server mainly operates in this thread
 792         ServerThread m_thread;
 793
 794         /*
 795                 Time related stuff
 796         */
 797
 798         // Timer for sending time of day over network
 799         float m_time_of_day_send_timer;
 800         // Uptime of server in seconds
 801         MutexedVariable<double> m_uptime;
 802
 803         /*
 804                 Peer change queue.
 805                 Queues stuff from peerAdded() and deletingPeer() to
 806                 handlePeerChanges()
 807         */
 808         enum PeerChangeType
 809         {
 810                 PEER_ADDED,
 811                 PEER_REMOVED
 812         };
 813         struct PeerChange
 814         {
 815                 PeerChangeType type;
 816                 u16 peer_id;
 817                 bool timeout;
 818         };
 819         Queue<PeerChange> m_peer_change_queue;
 820
 821         /*
 822                 Random stuff
 823         */
 824
 825         // Mod parent directory paths
 826         std::list<std::string> m_modspaths;
 827
 828         bool m_shutdown_requested;
 829
 830         /*
 831                 Map edit event queue. Automatically receives all map edits.
 832                 The constructor of this class registers us to receive them through
 833                 onMapEditEvent
 834
 835                 NOTE: Should these be moved to actually be members of
 836                 ServerEnvironment?
 837         */
 838
 839         /*
 840                 Queue of map edits from the environment for sending to the clients
 841                 This is behind m_env_mutex
 842         */
 843         Queue<MapEditEvent*> m_unsent_map_edit_queue;
 844         /*
 845                 Set to true when the server itself is modifying the map and does
 846                 all sending of information by itself.
 847                 This is behind m_env_mutex
 848         */
 849         bool m_ignore_map_edit_events;
 850         /*
 851                 If a non-empty area, map edit events contained within are left
 852                 unsent. Done at map generation time to speed up editing of the
 853                 generated area, as it will be sent anyway.
 854                 This is behind m_env_mutex
 855         */
 856         VoxelArea m_ignore_map_edit_events_area;
 857         /*
 858                 If set to !=0, the incoming MapEditEvents are modified to have
 859                 this peed id as the disabled recipient
 860                 This is behind m_env_mutex
 861         */
 862         u16 m_ignore_map_edit_events_peer_id;
 863
 864         friend class EmergeThread;
 865         friend class RemoteClient;
 866
 867         std::map<std::string,MediaInfo> m_media;
 868
 869         /*
 870                 Sounds
 871         */
 872         std::map<s32, ServerPlayingSound> m_playing_sounds;
 873         s32 m_next_sound_id;
 874
 875         /*
 876                 Detached inventories (behind m_env_mutex)
 877         */
 878         // key = name
 879         std::map<std::string, Inventory*> m_detached_inventories;
 880
 881         /*
 882                 Particles
 883         */
 884         std::vector<u32> m_particlespawner_ids;
 885 };
 886
 887 /*
 888         Runs a simple dedicated server loop.
 889
 890         Shuts down when run is set to false.
 891 */
 892 void dedicated_server_loop(Server &server, bool &run);
 893
 894 #endif
 895