/*
Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-/*
-(c) 2010 Perttu Ahola <celeron55@gmail.com>
-*/
-
#ifndef SERVER_HEADER
#define SERVER_HEADER
#include "environment.h"
#include "common_irrlicht.h"
#include <string>
-#include "utility.h"
#include "porting.h"
+#include "map.h"
+#include "inventory.h"
+#include "ban.h"
+#include "gamedef.h"
+#include "serialization.h" // For SER_FMT_VER_INVALID
+#include "mods.h"
+#include "inventorymanager.h"
+#include "subgame.h"
+#include "sound.h"
+struct LuaState;
+typedef struct lua_State lua_State;
+class IWritableItemDefManager;
+class IWritableNodeDefManager;
+class IWritableCraftDefManager;
+class EventManager;
+class PlayerSAO;
+
+class ServerError : public std::exception
+{
+public:
+ ServerError(const std::string &s)
+ {
+ m_s = "ServerError: ";
+ m_s += s;
+ }
+ virtual ~ServerError() throw()
+ {}
+ virtual const char * what() const throw()
+ {
+ return m_s.c_str();
+ }
+ std::string m_s;
+};
+
+/*
+ Some random functions
+*/
+v3f findSpawnPos(ServerMap &map);
+/*
+ A structure containing the data needed for queueing the fetching
+ of blocks.
+*/
struct QueuedBlockEmerge
{
v3s16 pos;
void PrintLine(std::ostream *s);
};
-u32 PIChecksum(core::list<PlayerInfo> &l);
-
/*
Used for queueing and sorting block transfers in containers
u16 peer_id;
};
+struct MediaRequest
+{
+ std::string name;
+
+ MediaRequest(const std::string &name_=""):
+ name(name_)
+ {}
+};
+
+struct MediaInfo
+{
+ std::string path;
+ std::string sha1_digest;
+
+ MediaInfo(const std::string path_="",
+ const std::string sha1_digest_=""):
+ path(path_),
+ sha1_digest(sha1_digest_)
+ {
+ }
+};
+
+struct ServerSoundParams
+{
+ float gain;
+ std::string to_player;
+ enum Type{
+ SSP_LOCAL=0,
+ SSP_POSITIONAL=1,
+ SSP_OBJECT=2
+ } type;
+ v3f pos;
+ u16 object;
+ float max_hear_distance;
+ bool loop;
+
+ ServerSoundParams():
+ gain(1.0),
+ to_player(""),
+ type(SSP_LOCAL),
+ pos(0,0,0),
+ object(0),
+ max_hear_distance(32*BS),
+ loop(false)
+ {}
+
+ v3f getPos(ServerEnvironment *env, bool *pos_exists) const;
+};
+
+struct ServerPlayingSound
+{
+ ServerSoundParams params;
+ std::set<u16> clients; // peer ids
+};
+
class RemoteClient
{
public:
u16 peer_id;
// The serialization version to use with the client
u8 serialization_version;
+ //
+ u16 net_proto_version;
// Version is stored in here after INIT before INIT2
u8 pending_serialization_version;
+ bool definitions_sent;
+
RemoteClient():
m_time_from_building(9999),
m_excess_gotblocks(0)
{
peer_id = 0;
serialization_version = SER_FMT_VER_INVALID;
+ net_proto_version = 0;
pending_serialization_version = SER_FMT_VER_INVALID;
+ definitions_sent = false;
m_nearest_unsent_d = 0;
m_nearest_unsent_reset_timer = 0.0;
-
- m_blocks_sent_mutex.Init();
- m_blocks_sending_mutex.Init();
-
- /*m_dig_mutex.Init();
- m_dig_time_remaining = 0;
- m_dig_tool_item = -1;*/
+ m_nothing_to_send_counter = 0;
+ m_nothing_to_send_pause_timer = 0;
}
~RemoteClient()
{
void GetNextBlocks(Server *server, float dtime,
core::array<PrioritySortedBlockTransfer> &dest);
- /*
- Connection and environment should be locked when this is called.
- steps() objects of blocks not found in active_blocks, then
- adds those blocks to active_blocks
- */
- void SendObjectData(
- Server *server,
- float dtime,
- core::map<v3s16, bool> &stepped_blocks
- );
-
void GotBlock(v3s16 p);
void SentBlock(v3s16 p);
s32 SendingCount()
{
- JMutexAutoLock lock(m_blocks_sending_mutex);
return m_blocks_sending.size();
}
void PrintInfo(std::ostream &o)
{
- JMutexAutoLock l2(m_blocks_sent_mutex);
- JMutexAutoLock l3(m_blocks_sending_mutex);
o<<"RemoteClient "<<peer_id<<": "
- <<", m_blocks_sent.size()="<<m_blocks_sent.size()
+ <<"m_blocks_sent.size()="<<m_blocks_sent.size()
<<", m_blocks_sending.size()="<<m_blocks_sending.size()
<<", m_nearest_unsent_d="<<m_nearest_unsent_d
<<", m_excess_gotblocks="<<m_excess_gotblocks
}
// Time from last placing or removing blocks
- MutexedVariable<float> m_time_from_building;
+ float m_time_from_building;
/*JMutex m_dig_mutex;
float m_dig_time_remaining;
// -1 = not digging
s16 m_dig_tool_item;
v3s16 m_dig_position;*/
-
-private:
+
/*
- All members that are accessed by many threads should
- obviously be behind a mutex. The threads include:
- - main thread (calls step())
- - server thread (calls AsyncRunStep() and Receive())
- - emerge thread
+ List of active objects that the client knows of.
+ Value is dummy.
*/
-
- //TODO: core::map<v3s16, MapBlock*> m_active_blocks
- //NOTE: Not here, it should be server-wide!
-
- // Number of blocks in the emerge queue that have this client as
- // a receiver. Used for throttling network usage.
- //MutexedVariable<s16> m_num_blocks_in_emerge_queue;
+ core::map<u16, bool> m_known_objects;
+private:
/*
Blocks that have been sent to client.
- These don't have to be sent again.
s16 m_nearest_unsent_d;
v3s16 m_last_center;
float m_nearest_unsent_reset_timer;
- JMutex m_blocks_sent_mutex;
+
/*
Blocks that are currently on the line.
This is used for throttling the sending of blocks.
Value is time from sending. (not used at the moment)
*/
core::map<v3s16, float> m_blocks_sending;
- JMutex m_blocks_sending_mutex;
/*
Count of excess GotBlocks().
This is resetted by PrintInfo()
*/
u32 m_excess_gotblocks;
+
+ // CPU usage optimization
+ u32 m_nothing_to_send_counter;
+ float m_nothing_to_send_pause_timer;
};
-/*struct ServerSettings
-{
- ServerSettings()
- {
- creative_mode = false;
- }
- bool creative_mode;
-};*/
-
-class Server : public con::PeerHandler
+class Server : public con::PeerHandler, public MapEventReceiver,
+ public InventoryManager, public IGameDef,
+ public IBackgroundBlockEmerger
{
public:
/*
NOTE: Every public method should be thread-safe
*/
+
Server(
- std::string mapsavedir,
- HMParams hm_params,
- MapParams map_params
+ const std::string &path_world,
+ const std::string &path_config,
+ const SubgameSpec &gamespec,
+ bool simple_singleplayer_mode
);
~Server();
void start(unsigned short port);
void Receive();
void ProcessData(u8 *data, u32 datasize, u16 peer_id);
- /*void Send(u16 peer_id, u16 channelnum,
- SharedBuffer<u8> data, bool reliable);*/
+ core::list<PlayerInfo> getPlayerInfo();
- // Environment and Connection must be locked when called
- void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver);
+ // Environment must be locked when called
+ void setTimeOfDay(u32 time)
+ {
+ m_env->setTimeOfDay(time);
+ m_time_of_day_send_timer = 0;
+ }
+
+ bool getShutdownRequested()
+ {
+ return m_shutdown_requested;
+ }
- // Environment and Connection must be locked when called
- //void SendSectorMeta(u16 peer_id, core::list<v2s16> ps, u8 ver);
+ /*
+ Shall be called with the environment locked.
+ This is accessed by the map, which is inside the environment,
+ so it shouldn't be a problem.
+ */
+ void onMapEditEvent(MapEditEvent *event);
- core::list<PlayerInfo> getPlayerInfo();
+ /*
+ Shall be called with the environment and the connection locked.
+ */
+ Inventory* getInventory(const InventoryLocation &loc);
+ std::string getInventoryOwner(const InventoryLocation &loc);
+ void setInventoryModified(const InventoryLocation &loc);
- u32 getDayNightRatio()
+ // Connection must be locked when called
+ std::wstring getStatusString();
+
+ void requestShutdown(void)
{
- s32 d = 8;
- s32 t = (((m_time_of_day.get() + 24000/d/2)%24000)/(24000/d));
- if(t == d/4 || t == (d-d/4))
- return 600;
- else if(t < d/4 || t > (d-d/4))
- return 300;
- else
- return 1000;
+ m_shutdown_requested = true;
}
+
+ // Returns -1 if failed, sound handle on success
+ // Envlock + conlock
+ s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams ¶ms);
+ void stopSound(s32 handle);
+
+ // Envlock + conlock
+ std::set<std::string> getPlayerEffectivePrivs(const std::string &name);
+ bool checkPriv(const std::string &name, const std::string &priv);
+ void reportPrivsModified(const std::string &name=""); // ""=all
+
+ // Saves g_settings to configpath given at initialization
+ void saveConfig();
+
+ void setIpBanned(const std::string &ip, const std::string &name)
+ {
+ m_banmanager.add(ip, name);
+ return;
+ }
+
+ void unsetIpBanned(const std::string &ip_or_name)
+ {
+ m_banmanager.remove(ip_or_name);
+ return;
+ }
+
+ std::string getBanDescription(const std::string &ip_or_name)
+ {
+ return m_banmanager.getBanDescription(ip_or_name);
+ }
+
+ Address getPeerAddress(u16 peer_id)
+ {
+ return m_con.GetPeerAddress(peer_id);
+ }
+
+ // Envlock and conlock should be locked when calling this
+ void notifyPlayer(const char *name, const std::wstring msg);
+ void notifyPlayers(const std::wstring msg);
+
+ void queueBlockEmerge(v3s16 blockpos, bool allow_generate);
+
+ // Envlock and conlock should be locked when using Lua
+ lua_State *getLua(){ return m_lua; }
+
+ // IGameDef interface
+ // Under envlock
+ virtual IItemDefManager* getItemDefManager();
+ virtual INodeDefManager* getNodeDefManager();
+ virtual ICraftDefManager* getCraftDefManager();
+ virtual ITextureSource* getTextureSource();
+ virtual u16 allocateUnknownNodeId(const std::string &name);
+ virtual ISoundManager* getSoundManager();
+ virtual MtEventManager* getEventManager();
+
+ IWritableItemDefManager* getWritableItemDefManager();
+ IWritableNodeDefManager* getWritableNodeDefManager();
+ IWritableCraftDefManager* getWritableCraftDefManager();
+
+ const ModSpec* getModSpec(const std::string &modname);
+ std::string getBuiltinLuaPath();
+ std::string getWorldPath(){ return m_path_world; }
+
+ bool isSingleplayer(){ return m_simple_singleplayer_mode; }
+
+ void setAsyncFatalError(const std::string &error)
+ {
+ m_async_fatal_error.set(error);
+ }
+
private:
- // Virtual methods from con::PeerHandler.
+ // con::PeerHandler implementation.
+ // These queue stuff to be processed by handlePeerChanges().
// As of now, these create and remove clients and players.
void peerAdded(con::Peer *peer);
void deletingPeer(con::Peer *peer, bool timeout);
+ /*
+ Static send methods
+ */
+
+ static void SendHP(con::Connection &con, u16 peer_id, u8 hp);
+ static void SendAccessDenied(con::Connection &con, u16 peer_id,
+ const std::wstring &reason);
+ static void SendDeathscreen(con::Connection &con, u16 peer_id,
+ bool set_camera_point_target, v3f camera_point_target);
+ static void SendItemDef(con::Connection &con, u16 peer_id,
+ IItemDefManager *itemdef);
+ static void SendNodeDef(con::Connection &con, u16 peer_id,
+ INodeDefManager *nodedef);
+
+ /*
+ Non-static send methods.
+ Conlock should be always used.
+ Envlock usage is documented badly but it's easy to figure out
+ which ones access the environment.
+ */
+
// Envlock and conlock should be locked when calling these
- void SendObjectData(float dtime);
- void SendPlayerInfos();
void SendInventory(u16 peer_id);
void SendChatMessage(u16 peer_id, const std::wstring &message);
void BroadcastChatMessage(const std::wstring &message);
+ void SendPlayerHP(u16 peer_id);
+ void SendMovePlayer(u16 peer_id);
+ void SendPlayerPrivileges(u16 peer_id);
+ /*
+ Send a node removal/addition event to all clients except ignore_id.
+ Additionally, if far_players!=NULL, players further away than
+ far_d_nodes are ignored and their peer_ids are added to far_players
+ */
+ // Envlock and conlock should be locked when calling these
+ void sendRemoveNode(v3s16 p, u16 ignore_id=0,
+ core::list<u16> *far_players=NULL, float far_d_nodes=100);
+ void sendAddNode(v3s16 p, MapNode n, u16 ignore_id=0,
+ core::list<u16> *far_players=NULL, float far_d_nodes=100);
+ void setBlockNotSent(v3s16 p);
- // Sends blocks to clients
+ // Environment and Connection must be locked when called
+ void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver);
+
+ // Sends blocks to clients (locks env and con on its own)
void SendBlocks(float dtime);
+ void fillMediaCache();
+ void sendMediaAnnouncement(u16 peer_id);
+ void sendRequestedMedia(u16 peer_id,
+ const core::list<MediaRequest> &tosend);
+
+ /*
+ Something random
+ */
+
+ void DiePlayer(u16 peer_id);
+ void RespawnPlayer(u16 peer_id);
+
+ void UpdateCrafting(u16 peer_id);
+
// When called, connection mutex should be locked
RemoteClient* getClient(u16 peer_id);
+
+ // When called, environment mutex should be locked
+ std::string getPlayerName(u16 peer_id)
+ {
+ Player *player = m_env->getPlayer(peer_id);
+ if(player == NULL)
+ return "[id="+itos(peer_id)+"]";
+ return player->getName();
+ }
+
+ // When called, environment mutex should be locked
+ PlayerSAO* getPlayerSAO(u16 peer_id)
+ {
+ Player *player = m_env->getPlayer(peer_id);
+ if(player == NULL)
+ return NULL;
+ return player->getPlayerSAO();
+ }
/*
Get a player from memory or creates one.
If player is already connected, return NULL
+ Does not verify/modify auth info and password.
Call with env and con locked.
*/
- Player *emergePlayer(const char *name, const char *password,
- u16 peer_id);
-
- /*
- Update water pressure.
- This also adds suitable nodes to active_nodes.
-
- environment has to be locked when calling.
- */
- /*void UpdateBlockWaterPressure(MapBlock *block,
- core::map<v3s16, MapBlock*> &modified_blocks);*/
+ PlayerSAO *emergePlayer(const char *name, u16 peer_id);
// Locks environment and connection by its own
struct PeerChange;
void handlePeerChange(PeerChange &c);
void handlePeerChanges();
+
+ /*
+ Variables
+ */
- //float m_flowwater_timer;
+ // World directory
+ std::string m_path_world;
+ // Path to user's configuration file ("" = no configuration file)
+ std::string m_path_config;
+ // Subgame specification
+ SubgameSpec m_gamespec;
+ // If true, do not allow multiple players and hide some multiplayer
+ // functionality
+ bool m_simple_singleplayer_mode;
+
+ // Thread can set; step() will throw as ServerError
+ MutexedVariable<std::string> m_async_fatal_error;
+
+ // Some timers
float m_liquid_transform_timer;
float m_print_info_timer;
float m_objectdata_timer;
float m_emergethread_trigger_timer;
float m_savemap_timer;
+ IntervalLimiter m_map_timer_and_unload_interval;
// NOTE: If connection and environment are both to be locked,
// environment shall be locked first.
- JMutex m_env_mutex;
- Environment m_env;
- JMutex m_con_mutex;
+ // Environment
+ ServerEnvironment *m_env;
+ JMutex m_env_mutex;
+
+ // Connection
con::Connection m_con;
- core::map<u16, RemoteClient*> m_clients; // Behind the con mutex
+ JMutex m_con_mutex;
+ // Connected clients (behind the con mutex)
+ core::map<u16, RemoteClient*> m_clients;
+
+ // Bann checking
+ BanManager m_banmanager;
+
+ // Scripting
+ // Envlock and conlock should be locked when using Lua
+ lua_State *m_lua;
+ // Item definition manager
+ IWritableItemDefManager *m_itemdef;
+
+ // Node definition manager
+ IWritableNodeDefManager *m_nodedef;
+
+ // Craft definition manager
+ IWritableCraftDefManager *m_craftdef;
+
+ // Event manager
+ EventManager *m_event;
+
+ // Mods
+ core::list<ModSpec> m_mods;
+
+ /*
+ Threads
+ */
+
+ // A buffer for time steps
+ // step() increments and AsyncRunStep() run by m_thread reads it.
float m_step_dtime;
JMutex m_step_dtime_mutex;
+ // The server mainly operates in this thread
ServerThread m_thread;
+ // This thread fetches and generates map
EmergeThread m_emergethread;
-
+ // Queue of block coordinates to be processed by the emerge thread
BlockEmergeQueue m_emerge_queue;
- // Nodes that are destinations of flowing liquid at the moment
- //core::map<v3s16, u8> m_flow_active_nodes;
+ /*
+ Time related stuff
+ */
- // 0-23999
- MutexedVariable<u32> m_time_of_day;
- // Used to buffer dtime for adding to m_time_of_day
- float m_time_counter;
+ // Timer for sending time of day over network
float m_time_of_day_send_timer;
-
+ // Uptime of server in seconds
MutexedVariable<double> m_uptime;
-
+
+ /*
+ Peer change queue.
+ Queues stuff from peerAdded() and deletingPeer() to
+ handlePeerChanges()
+ */
enum PeerChangeType
{
PEER_ADDED,
PEER_REMOVED
};
-
struct PeerChange
{
PeerChangeType type;
u16 peer_id;
bool timeout;
};
-
Queue<PeerChange> m_peer_change_queue;
- std::string m_mapsavedir;
+ /*
+ Random stuff
+ */
+
+ // Mod parent directory paths
+ core::list<std::string> m_modspaths;
+
+ bool m_shutdown_requested;
+
+ /*
+ Map edit event queue. Automatically receives all map edits.
+ The constructor of this class registers us to receive them through
+ onMapEditEvent
+
+ NOTE: Should these be moved to actually be members of
+ ServerEnvironment?
+ */
+
+ /*
+ Queue of map edits from the environment for sending to the clients
+ This is behind m_env_mutex
+ */
+ Queue<MapEditEvent*> m_unsent_map_edit_queue;
+ /*
+ Set to true when the server itself is modifying the map and does
+ all sending of information by itself.
+ This is behind m_env_mutex
+ */
+ bool m_ignore_map_edit_events;
+ /*
+ If a non-empty area, map edit events contained within are left
+ unsent. Done at map generation time to speed up editing of the
+ generated area, as it will be sent anyway.
+ This is behind m_env_mutex
+ */
+ VoxelArea m_ignore_map_edit_events_area;
+ /*
+ If set to !=0, the incoming MapEditEvents are modified to have
+ this peed id as the disabled recipient
+ This is behind m_env_mutex
+ */
+ u16 m_ignore_map_edit_events_peer_id;
friend class EmergeThread;
friend class RemoteClient;
+
+ std::map<std::string,MediaInfo> m_media;
+
+ /*
+ Sounds
+ */
+ std::map<s32, ServerPlayingSound> m_playing_sounds;
+ s32 m_next_sound_id;
};
/*
- Runs a simple dedicated server loop
+ Runs a simple dedicated server loop.
+
+ Shuts down when run is set to false.
*/
-void dedicated_server_loop(Server &server);
+void dedicated_server_loop(Server &server, bool &run);
#endif
projects / oweals / minetest.git / blobdiff