Line data Source code
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 "network/connection.h"
24 : #include "irr_v3d.h"
25 : #include "map.h"
26 : #include "hud.h"
27 : #include "gamedef.h"
28 : #include "serialization.h" // For SER_FMT_VER_INVALID
29 : #include "mods.h"
30 : #include "inventorymanager.h"
31 : #include "subgame.h"
32 : #include "util/numeric.h"
33 : #include "util/thread.h"
34 : #include "environment.h"
35 : #include "clientiface.h"
36 : #include "network/networkpacket.h"
37 : #include <string>
38 : #include <list>
39 : #include <map>
40 : #include <vector>
41 :
42 : #define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
43 :
44 : class IWritableItemDefManager;
45 : class IWritableNodeDefManager;
46 : class IWritableCraftDefManager;
47 : class BanManager;
48 : class EventManager;
49 : class Inventory;
50 : class Player;
51 : class PlayerSAO;
52 : class IRollbackManager;
53 : struct RollbackAction;
54 : class EmergeManager;
55 : class GameScripting;
56 : class ServerEnvironment;
57 : struct SimpleSoundSpec;
58 : class ServerThread;
59 :
60 : enum ClientDeletionReason {
61 : CDR_LEAVE,
62 : CDR_TIMEOUT,
63 : CDR_DENY
64 : };
65 :
66 : class MapEditEventIgnorer
67 : {
68 : public:
69 : MapEditEventIgnorer(bool *flag):
70 : m_flag(flag)
71 : {
72 : if(*m_flag == false)
73 : *m_flag = true;
74 : else
75 : m_flag = NULL;
76 : }
77 :
78 : ~MapEditEventIgnorer()
79 : {
80 : if(m_flag)
81 : {
82 : assert(*m_flag);
83 : *m_flag = false;
84 : }
85 : }
86 :
87 : private:
88 : bool *m_flag;
89 : };
90 :
91 : class MapEditEventAreaIgnorer
92 : {
93 : public:
94 0 : MapEditEventAreaIgnorer(VoxelArea *ignorevariable, const VoxelArea &a):
95 0 : m_ignorevariable(ignorevariable)
96 : {
97 0 : if(m_ignorevariable->getVolume() == 0)
98 0 : *m_ignorevariable = a;
99 : else
100 0 : m_ignorevariable = NULL;
101 0 : }
102 :
103 0 : ~MapEditEventAreaIgnorer()
104 0 : {
105 0 : if(m_ignorevariable)
106 : {
107 : assert(m_ignorevariable->getVolume() != 0);
108 0 : *m_ignorevariable = VoxelArea();
109 : }
110 0 : }
111 :
112 : private:
113 : VoxelArea *m_ignorevariable;
114 : };
115 :
116 0 : struct MediaInfo
117 : {
118 : std::string path;
119 : std::string sha1_digest;
120 :
121 0 : MediaInfo(const std::string &path_="",
122 : const std::string &sha1_digest_=""):
123 : path(path_),
124 0 : sha1_digest(sha1_digest_)
125 : {
126 0 : }
127 : };
128 :
129 0 : struct ServerSoundParams
130 : {
131 : float gain;
132 : std::string to_player;
133 : enum Type{
134 : SSP_LOCAL=0,
135 : SSP_POSITIONAL=1,
136 : SSP_OBJECT=2
137 : } type;
138 : v3f pos;
139 : u16 object;
140 : float max_hear_distance;
141 : bool loop;
142 :
143 0 : ServerSoundParams():
144 : gain(1.0),
145 : to_player(""),
146 : type(SSP_LOCAL),
147 : pos(0,0,0),
148 : object(0),
149 : max_hear_distance(32*BS),
150 0 : loop(false)
151 0 : {}
152 :
153 : v3f getPos(ServerEnvironment *env, bool *pos_exists) const;
154 : };
155 :
156 0 : struct ServerPlayingSound
157 : {
158 : ServerSoundParams params;
159 : std::set<u16> clients; // peer ids
160 : };
161 :
162 : class Server : public con::PeerHandler, public MapEventReceiver,
163 : public InventoryManager, public IGameDef
164 : {
165 : public:
166 : /*
167 : NOTE: Every public method should be thread-safe
168 : */
169 :
170 : Server(
171 : const std::string &path_world,
172 : const SubgameSpec &gamespec,
173 : bool simple_singleplayer_mode,
174 : bool ipv6
175 : );
176 : ~Server();
177 : void start(Address bind_addr);
178 : void stop();
179 : // This is mainly a way to pass the time to the server.
180 : // Actual processing is done in an another thread.
181 : void step(float dtime);
182 : // This is run by ServerThread and does the actual processing
183 : void AsyncRunStep(bool initial_step=false);
184 : void Receive();
185 : PlayerSAO* StageTwoClientInit(u16 peer_id);
186 :
187 : /*
188 : * Command Handlers
189 : */
190 :
191 : void handleCommand(NetworkPacket* pkt);
192 :
193 0 : void handleCommand_Null(NetworkPacket* pkt) {};
194 : void handleCommand_Deprecated(NetworkPacket* pkt);
195 : void handleCommand_Init(NetworkPacket* pkt);
196 : void handleCommand_Init_Legacy(NetworkPacket* pkt);
197 : void handleCommand_Init2(NetworkPacket* pkt);
198 : void handleCommand_RequestMedia(NetworkPacket* pkt);
199 : void handleCommand_ReceivedMedia(NetworkPacket* pkt);
200 : void handleCommand_ClientReady(NetworkPacket* pkt);
201 : void handleCommand_GotBlocks(NetworkPacket* pkt);
202 : void handleCommand_PlayerPos(NetworkPacket* pkt);
203 : void handleCommand_DeletedBlocks(NetworkPacket* pkt);
204 : void handleCommand_InventoryAction(NetworkPacket* pkt);
205 : void handleCommand_ChatMessage(NetworkPacket* pkt);
206 : void handleCommand_Damage(NetworkPacket* pkt);
207 : void handleCommand_Breath(NetworkPacket* pkt);
208 : void handleCommand_Password(NetworkPacket* pkt);
209 : void handleCommand_PlayerItem(NetworkPacket* pkt);
210 : void handleCommand_Respawn(NetworkPacket* pkt);
211 : void handleCommand_Interact(NetworkPacket* pkt);
212 : void handleCommand_RemovedSounds(NetworkPacket* pkt);
213 : void handleCommand_NodeMetaFields(NetworkPacket* pkt);
214 : void handleCommand_InventoryFields(NetworkPacket* pkt);
215 : void handleCommand_FirstSrp(NetworkPacket* pkt);
216 : void handleCommand_SrpBytesA(NetworkPacket* pkt);
217 : void handleCommand_SrpBytesM(NetworkPacket* pkt);
218 :
219 : void ProcessData(NetworkPacket *pkt);
220 :
221 : void Send(NetworkPacket* pkt);
222 :
223 : // Environment must be locked when called
224 : void setTimeOfDay(u32 time);
225 :
226 : /*
227 : Shall be called with the environment locked.
228 : This is accessed by the map, which is inside the environment,
229 : so it shouldn't be a problem.
230 : */
231 : void onMapEditEvent(MapEditEvent *event);
232 :
233 : /*
234 : Shall be called with the environment and the connection locked.
235 : */
236 : Inventory* getInventory(const InventoryLocation &loc);
237 : void setInventoryModified(const InventoryLocation &loc, bool playerSend = true);
238 :
239 : // Connection must be locked when called
240 : std::wstring getStatusString();
241 :
242 : // read shutdown state
243 0 : inline bool getShutdownRequested()
244 0 : { return m_shutdown_requested; }
245 :
246 : // request server to shutdown
247 0 : inline void requestShutdown(void)
248 0 : { m_shutdown_requested = true; }
249 :
250 : // Returns -1 if failed, sound handle on success
251 : // Envlock
252 : s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams ¶ms);
253 : void stopSound(s32 handle);
254 :
255 : // Envlock
256 : std::set<std::string> getPlayerEffectivePrivs(const std::string &name);
257 : bool checkPriv(const std::string &name, const std::string &priv);
258 : void reportPrivsModified(const std::string &name=""); // ""=all
259 : void reportInventoryFormspecModified(const std::string &name);
260 :
261 : void setIpBanned(const std::string &ip, const std::string &name);
262 : void unsetIpBanned(const std::string &ip_or_name);
263 : std::string getBanDescription(const std::string &ip_or_name);
264 :
265 : void notifyPlayer(const char *name, const std::wstring &msg);
266 : void notifyPlayers(const std::wstring &msg);
267 : void spawnParticle(const char *playername,
268 : v3f pos, v3f velocity, v3f acceleration,
269 : float expirationtime, float size,
270 : bool collisiondetection, bool vertical, std::string texture);
271 :
272 : void spawnParticleAll(v3f pos, v3f velocity, v3f acceleration,
273 : float expirationtime, float size,
274 : bool collisiondetection, bool vertical, std::string texture);
275 :
276 : u32 addParticleSpawner(const char *playername,
277 : u16 amount, float spawntime,
278 : v3f minpos, v3f maxpos,
279 : v3f minvel, v3f maxvel,
280 : v3f minacc, v3f maxacc,
281 : float minexptime, float maxexptime,
282 : float minsize, float maxsize,
283 : bool collisiondetection, bool vertical, std::string texture);
284 :
285 : u32 addParticleSpawnerAll(u16 amount, float spawntime,
286 : v3f minpos, v3f maxpos,
287 : v3f minvel, v3f maxvel,
288 : v3f minacc, v3f maxacc,
289 : float minexptime, float maxexptime,
290 : float minsize, float maxsize,
291 : bool collisiondetection, bool vertical, std::string texture);
292 :
293 : void deleteParticleSpawner(const char *playername, u32 id);
294 : void deleteParticleSpawnerAll(u32 id);
295 :
296 : // Creates or resets inventory
297 : Inventory* createDetachedInventory(const std::string &name);
298 :
299 : // Envlock and conlock should be locked when using scriptapi
300 0 : GameScripting *getScriptIface(){ return m_script; }
301 :
302 : // actions: time-reversed list
303 : // Return value: success/failure
304 : bool rollbackRevertActions(const std::list<RollbackAction> &actions,
305 : std::list<std::string> *log);
306 :
307 : // IGameDef interface
308 : // Under envlock
309 : virtual IItemDefManager* getItemDefManager();
310 : virtual INodeDefManager* getNodeDefManager();
311 : virtual ICraftDefManager* getCraftDefManager();
312 : virtual ITextureSource* getTextureSource();
313 : virtual IShaderSource* getShaderSource();
314 : virtual u16 allocateUnknownNodeId(const std::string &name);
315 : virtual ISoundManager* getSoundManager();
316 : virtual MtEventManager* getEventManager();
317 : virtual scene::ISceneManager* getSceneManager();
318 0 : virtual IRollbackManager *getRollbackManager() { return m_rollback; }
319 0 : virtual EmergeManager *getEmergeManager() { return m_emerge; }
320 :
321 : IWritableItemDefManager* getWritableItemDefManager();
322 : IWritableNodeDefManager* getWritableNodeDefManager();
323 : IWritableCraftDefManager* getWritableCraftDefManager();
324 :
325 : const ModSpec* getModSpec(const std::string &modname) const;
326 : void getModNames(std::vector<std::string> &modlist);
327 : std::string getBuiltinLuaPath();
328 0 : inline std::string getWorldPath() const
329 0 : { return m_path_world; }
330 :
331 0 : inline bool isSingleplayer()
332 0 : { return m_simple_singleplayer_mode; }
333 :
334 0 : inline void setAsyncFatalError(const std::string &error)
335 0 : { m_async_fatal_error.set(error); }
336 :
337 : bool showFormspec(const char *name, const std::string &formspec, const std::string &formname);
338 : Map & getMap() { return m_env->getMap(); }
339 : ServerEnvironment & getEnv() { return *m_env; }
340 :
341 : u32 hudAdd(Player *player, HudElement *element);
342 : bool hudRemove(Player *player, u32 id);
343 : bool hudChange(Player *player, u32 id, HudElementStat stat, void *value);
344 : bool hudSetFlags(Player *player, u32 flags, u32 mask);
345 : bool hudSetHotbarItemcount(Player *player, s32 hotbar_itemcount);
346 : s32 hudGetHotbarItemcount(Player *player);
347 : void hudSetHotbarImage(Player *player, std::string name);
348 : std::string hudGetHotbarImage(Player *player);
349 : void hudSetHotbarSelectedImage(Player *player, std::string name);
350 : std::string hudGetHotbarSelectedImage(Player *player);
351 :
352 0 : inline Address getPeerAddress(u16 peer_id)
353 0 : { return m_con.GetPeerAddress(peer_id); }
354 :
355 : bool setLocalPlayerAnimations(Player *player, v2s32 animation_frames[4], f32 frame_speed);
356 : bool setPlayerEyeOffset(Player *player, v3f first, v3f third);
357 :
358 : bool setSky(Player *player, const video::SColor &bgcolor,
359 : const std::string &type, const std::vector<std::string> ¶ms);
360 :
361 : bool overrideDayNightRatio(Player *player, bool do_override,
362 : float brightness);
363 :
364 : /* con::PeerHandler implementation. */
365 : void peerAdded(con::Peer *peer);
366 : void deletingPeer(con::Peer *peer, bool timeout);
367 :
368 : void DenySudoAccess(u16 peer_id);
369 : void DenyAccess(u16 peer_id, AccessDeniedCode reason, const std::string &custom_reason="");
370 : void acceptAuth(u16 peer_id, bool forSudoMode);
371 : void DenyAccess_Legacy(u16 peer_id, const std::wstring &reason);
372 : bool getClientConInfo(u16 peer_id, con::rtt_stat_type type,float* retval);
373 : bool getClientInfo(u16 peer_id,ClientState* state, u32* uptime,
374 : u8* ser_vers, u16* prot_vers, u8* major, u8* minor, u8* patch,
375 : std::string* vers_string);
376 :
377 0 : void SendPlayerHPOrDie(u16 peer_id, bool die) { die ? DiePlayer(peer_id) : SendPlayerHP(peer_id); }
378 : void SendPlayerBreath(u16 peer_id);
379 : void SendInventory(PlayerSAO* playerSAO);
380 : void SendMovePlayer(u16 peer_id);
381 :
382 : // Bind address
383 : Address m_bind_addr;
384 :
385 : private:
386 :
387 : friend class EmergeThread;
388 : friend class RemoteClient;
389 :
390 : void SendMovement(u16 peer_id);
391 : void SendHP(u16 peer_id, u8 hp);
392 : void SendBreath(u16 peer_id, u16 breath);
393 : void SendAccessDenied(u16 peer_id, AccessDeniedCode reason, const std::string &custom_reason);
394 : void SendAccessDenied_Legacy(u16 peer_id, const std::wstring &reason);
395 : void SendDeathscreen(u16 peer_id,bool set_camera_point_target, v3f camera_point_target);
396 : void SendItemDef(u16 peer_id,IItemDefManager *itemdef, u16 protocol_version);
397 : void SendNodeDef(u16 peer_id,INodeDefManager *nodedef, u16 protocol_version);
398 :
399 : /* mark blocks not sent for all clients */
400 : void SetBlocksNotSent(std::map<v3s16, MapBlock *>& block);
401 :
402 :
403 : void SendChatMessage(u16 peer_id, const std::wstring &message);
404 : void SendTimeOfDay(u16 peer_id, u16 time, f32 time_speed);
405 : void SendPlayerHP(u16 peer_id);
406 :
407 : void SendLocalPlayerAnimations(u16 peer_id, v2s32 animation_frames[4], f32 animation_speed);
408 : void SendEyeOffset(u16 peer_id, v3f first, v3f third);
409 : void SendPlayerPrivileges(u16 peer_id);
410 : void SendPlayerInventoryFormspec(u16 peer_id);
411 : void SendShowFormspecMessage(u16 peer_id, const std::string &formspec, const std::string &formname);
412 : void SendHUDAdd(u16 peer_id, u32 id, HudElement *form);
413 : void SendHUDRemove(u16 peer_id, u32 id);
414 : void SendHUDChange(u16 peer_id, u32 id, HudElementStat stat, void *value);
415 : void SendHUDSetFlags(u16 peer_id, u32 flags, u32 mask);
416 : void SendHUDSetParam(u16 peer_id, u16 param, const std::string &value);
417 : void SendSetSky(u16 peer_id, const video::SColor &bgcolor,
418 : const std::string &type, const std::vector<std::string> ¶ms);
419 : void SendOverrideDayNightRatio(u16 peer_id, bool do_override, float ratio);
420 :
421 : /*
422 : Send a node removal/addition event to all clients except ignore_id.
423 : Additionally, if far_players!=NULL, players further away than
424 : far_d_nodes are ignored and their peer_ids are added to far_players
425 : */
426 : // Envlock and conlock should be locked when calling these
427 : void sendRemoveNode(v3s16 p, u16 ignore_id=0,
428 : std::vector<u16> *far_players=NULL, float far_d_nodes=100);
429 : void sendAddNode(v3s16 p, MapNode n, u16 ignore_id=0,
430 : std::vector<u16> *far_players=NULL, float far_d_nodes=100,
431 : bool remove_metadata=true);
432 : void setBlockNotSent(v3s16 p);
433 :
434 : // Environment and Connection must be locked when called
435 : void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto_version);
436 :
437 : // Sends blocks to clients (locks env and con on its own)
438 : void SendBlocks(float dtime);
439 :
440 : void fillMediaCache();
441 : void sendMediaAnnouncement(u16 peer_id);
442 : void sendRequestedMedia(u16 peer_id,
443 : const std::vector<std::string> &tosend);
444 :
445 : void sendDetachedInventory(const std::string &name, u16 peer_id);
446 : void sendDetachedInventories(u16 peer_id);
447 :
448 : // Adds a ParticleSpawner on peer with peer_id (PEER_ID_INEXISTENT == all)
449 : void SendAddParticleSpawner(u16 peer_id, u16 amount, float spawntime,
450 : v3f minpos, v3f maxpos,
451 : v3f minvel, v3f maxvel,
452 : v3f minacc, v3f maxacc,
453 : float minexptime, float maxexptime,
454 : float minsize, float maxsize,
455 : bool collisiondetection, bool vertical, std::string texture, u32 id);
456 :
457 : void SendDeleteParticleSpawner(u16 peer_id, u32 id);
458 :
459 : // Spawns particle on peer with peer_id (PEER_ID_INEXISTENT == all)
460 : void SendSpawnParticle(u16 peer_id,
461 : v3f pos, v3f velocity, v3f acceleration,
462 : float expirationtime, float size,
463 : bool collisiondetection, bool vertical, std::string texture);
464 :
465 : u32 SendActiveObjectRemoveAdd(u16 peer_id, const std::string &datas);
466 : void SendActiveObjectMessages(u16 peer_id, const std::string &datas, bool reliable = true);
467 : /*
468 : Something random
469 : */
470 :
471 : void DiePlayer(u16 peer_id);
472 : void RespawnPlayer(u16 peer_id);
473 : void DeleteClient(u16 peer_id, ClientDeletionReason reason);
474 : void UpdateCrafting(Player *player);
475 :
476 : v3f findSpawnPos();
477 :
478 : // When called, connection mutex should be locked
479 : RemoteClient* getClient(u16 peer_id,ClientState state_min=CS_Active);
480 : RemoteClient* getClientNoEx(u16 peer_id,ClientState state_min=CS_Active);
481 :
482 : // When called, environment mutex should be locked
483 : std::string getPlayerName(u16 peer_id);
484 : PlayerSAO* getPlayerSAO(u16 peer_id);
485 :
486 : /*
487 : Get a player from memory or creates one.
488 : If player is already connected, return NULL
489 : Does not verify/modify auth info and password.
490 :
491 : Call with env and con locked.
492 : */
493 : PlayerSAO *emergePlayer(const char *name, u16 peer_id);
494 :
495 : void handlePeerChanges();
496 :
497 : /*
498 : Variables
499 : */
500 :
501 : // World directory
502 : std::string m_path_world;
503 : // Subgame specification
504 : SubgameSpec m_gamespec;
505 : // If true, do not allow multiple players and hide some multiplayer
506 : // functionality
507 : bool m_simple_singleplayer_mode;
508 :
509 : // Thread can set; step() will throw as ServerError
510 : MutexedVariable<std::string> m_async_fatal_error;
511 :
512 : // Some timers
513 : float m_liquid_transform_timer;
514 : float m_liquid_transform_every;
515 : float m_print_info_timer;
516 : float m_masterserver_timer;
517 : float m_objectdata_timer;
518 : float m_emergethread_trigger_timer;
519 : float m_savemap_timer;
520 : IntervalLimiter m_map_timer_and_unload_interval;
521 :
522 : // Environment
523 : ServerEnvironment *m_env;
524 : JMutex m_env_mutex;
525 :
526 : // server connection
527 : con::Connection m_con;
528 :
529 : // Ban checking
530 : BanManager *m_banmanager;
531 :
532 : // Rollback manager (behind m_env_mutex)
533 : IRollbackManager *m_rollback;
534 : bool m_enable_rollback_recording; // Updated once in a while
535 :
536 : // Emerge manager
537 : EmergeManager *m_emerge;
538 :
539 : // Scripting
540 : // Envlock and conlock should be locked when using Lua
541 : GameScripting *m_script;
542 :
543 : // Item definition manager
544 : IWritableItemDefManager *m_itemdef;
545 :
546 : // Node definition manager
547 : IWritableNodeDefManager *m_nodedef;
548 :
549 : // Craft definition manager
550 : IWritableCraftDefManager *m_craftdef;
551 :
552 : // Event manager
553 : EventManager *m_event;
554 :
555 : // Mods
556 : std::vector<ModSpec> m_mods;
557 :
558 : /*
559 : Threads
560 : */
561 :
562 : // A buffer for time steps
563 : // step() increments and AsyncRunStep() run by m_thread reads it.
564 : float m_step_dtime;
565 : JMutex m_step_dtime_mutex;
566 :
567 : // current server step lag counter
568 : float m_lag;
569 :
570 : // The server mainly operates in this thread
571 : ServerThread *m_thread;
572 :
573 : /*
574 : Time related stuff
575 : */
576 :
577 : // Timer for sending time of day over network
578 : float m_time_of_day_send_timer;
579 : // Uptime of server in seconds
580 : MutexedVariable<double> m_uptime;
581 :
582 : /*
583 : Client interface
584 : */
585 : ClientInterface m_clients;
586 :
587 : /*
588 : Peer change queue.
589 : Queues stuff from peerAdded() and deletingPeer() to
590 : handlePeerChanges()
591 : */
592 : std::queue<con::PeerChange> m_peer_change_queue;
593 :
594 : /*
595 : Random stuff
596 : */
597 :
598 : bool m_shutdown_requested;
599 :
600 : /*
601 : Map edit event queue. Automatically receives all map edits.
602 : The constructor of this class registers us to receive them through
603 : onMapEditEvent
604 :
605 : NOTE: Should these be moved to actually be members of
606 : ServerEnvironment?
607 : */
608 :
609 : /*
610 : Queue of map edits from the environment for sending to the clients
611 : This is behind m_env_mutex
612 : */
613 : std::queue<MapEditEvent*> m_unsent_map_edit_queue;
614 : /*
615 : Set to true when the server itself is modifying the map and does
616 : all sending of information by itself.
617 : This is behind m_env_mutex
618 : */
619 : bool m_ignore_map_edit_events;
620 : /*
621 : If a non-empty area, map edit events contained within are left
622 : unsent. Done at map generation time to speed up editing of the
623 : generated area, as it will be sent anyway.
624 : This is behind m_env_mutex
625 : */
626 : VoxelArea m_ignore_map_edit_events_area;
627 : /*
628 : If set to !=0, the incoming MapEditEvents are modified to have
629 : this peed id as the disabled recipient
630 : This is behind m_env_mutex
631 : */
632 : u16 m_ignore_map_edit_events_peer_id;
633 :
634 : // media files known to server
635 : std::map<std::string,MediaInfo> m_media;
636 :
637 : /*
638 : Sounds
639 : */
640 : std::map<s32, ServerPlayingSound> m_playing_sounds;
641 : s32 m_next_sound_id;
642 :
643 : /*
644 : Detached inventories (behind m_env_mutex)
645 : */
646 : // key = name
647 : std::map<std::string, Inventory*> m_detached_inventories;
648 :
649 : /*
650 : Particles
651 : */
652 : std::vector<u32> m_particlespawner_ids;
653 : };
654 :
655 : /*
656 : Runs a simple dedicated server loop.
657 :
658 : Shuts down when run is set to false.
659 : */
660 : void dedicated_server_loop(Server &server, bool &run);
661 :
662 : #endif
663 :
|
