#include "inventory.h"
#include "auth.h"
#include "ban.h"
+#include "gamedef.h"
+#include "serialization.h" // For SER_FMT_VER_INVALID
+#include "serverremoteplayer.h"
+#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 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
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
+ {
+ if(pos_exists) *pos_exists = false;
+ switch(type){
+ case SSP_LOCAL:
+ return v3f(0,0,0);
+ case SSP_POSITIONAL:
+ if(pos_exists) *pos_exists = true;
+ return pos;
+ case SSP_OBJECT: {
+ if(object == 0)
+ return v3f(0,0,0);
+ ServerActiveObject *sao = env->getActiveObject(object);
+ if(!sao)
+ return v3f(0,0,0);
+ if(pos_exists) *pos_exists = true;
+ return sao->getBasePosition(); }
+ }
+ return v3f(0,0,0);
+ }
+};
+
+struct ServerPlayingSound
+{
+ ServerSoundParams params;
+ std::set<u16> clients; // peer ids
+};
+
class RemoteClient
{
public:
// 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)
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_nothing_to_send_counter = 0;
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);
};
class Server : public con::PeerHandler, public MapEventReceiver,
- public InventoryManager
+ public InventoryManager, public IGameDef,
+ public IBackgroundBlockEmerger
{
public:
/*
NOTE: Every public method should be thread-safe
*/
-
+
Server(
- std::string mapsavedir,
- std::string configpath
+ const std::string &path_world,
+ const std::string &path_config,
+ const SubgameSpec &gamespec,
+ bool simple_singleplayer_mode
);
~Server();
void start(unsigned short port);
core::list<PlayerInfo> getPlayerInfo();
- /*u32 getDayNightRatio()
- {
- return time_to_daynight_ratio(m_time_of_day.get());
- }*/
-
// Environment must be locked when called
void setTimeOfDay(u32 time)
{
/*
Shall be called with the environment and the connection locked.
*/
- Inventory* getInventory(InventoryContext *c, std::string id);
- void inventoryModified(InventoryContext *c, std::string id);
+ Inventory* getInventory(const InventoryLocation &loc);
+ std::string getInventoryOwner(const InventoryLocation &loc);
+ void setInventoryModified(const InventoryLocation &loc);
// Connection must be locked when called
std::wstring getStatusString();
m_shutdown_requested = true;
}
-
// Envlock and conlock should be locked when calling this
void SendMovePlayer(Player *player);
- u64 getPlayerAuthPrivs(const std::string &name)
- {
- try{
- return m_authmanager.getPrivs(name);
- }
- catch(AuthNotFoundException &e)
- {
- dstream<<"WARNING: Auth not found for "<<name<<std::endl;
- return 0;
- }
- }
+ // Returns -1 if failed, sound handle on success
+ // Envlock + conlock
+ s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams ¶ms);
+ void stopSound(s32 handle);
+
+ // Thread-safe
+ u64 getPlayerAuthPrivs(const std::string &name);
+ void setPlayerAuthPrivs(const std::string &name, u64 privs);
+ u64 getPlayerEffectivePrivs(const std::string &name);
- void setPlayerAuthPrivs(const std::string &name, u64 privs)
- {
- try{
- return m_authmanager.setPrivs(name, privs);
- }
- catch(AuthNotFoundException &e)
- {
- dstream<<"WARNING: Auth not found for "<<name<<std::endl;
- }
- }
+ // Changes a player's password, password must be given as plaintext
+ // If the player doesn't exist, a new entry is added to the auth manager
+ void setPlayerPassword(const std::string &name, const std::wstring &password);
// Saves g_settings to configpath given at initialization
void saveConfig();
// 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 getWorldPath(){ return m_path_world; }
+
+ void setAsyncFatalError(const std::string &error)
+ {
+ m_async_fatal_error.set(error);
+ }
private:
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
+ 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);
// send wielded item info about player to all
- void SendWieldedItem(const Player *player);
+ void SendWieldedItem(const ServerRemotePlayer *srp);
// send wielded item info about all players to all players
void SendPlayerItems();
void SendChatMessage(u16 peer_id, const std::wstring &message);
// 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 HandlePlayerHP(Player *player, s16 damage);
+ void DiePlayer(Player *player);
void RespawnPlayer(Player *player);
void UpdateCrafting(u16 peer_id);
{
Player *player = m_env->getPlayer(peer_id);
if(player == NULL)
- return "[id="+itos(peer_id);
+ return "[id="+itos(peer_id)+"]";
return player->getName();
}
/*
Get a player from memory or creates one.
If player is already connected, return NULL
- The password is not checked here - it is only used to
- set the password if a new player is created.
+ 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);
+ ServerRemotePlayer *emergePlayer(const char *name, u16 peer_id);
// Locks environment and connection by its own
struct PeerChange;
Variables
*/
+ // 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;
// 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
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
/*
Random stuff
*/
-
- // Map directory
- std::string m_mapsavedir;
-
- // Configuration path ("" = no configuration file)
- std::string m_configpath;
+
+ // 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
*/
u16 m_ignore_map_edit_events_peer_id;
- Profiler *m_profiler;
-
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;
};
/*