#define SERVER_HEADER
#include "connection.h"
-#include "environment.h"
-#include "irrlichttypes_bloated.h"
-#include <string>
-#include "porting.h"
+#include "irr_v3d.h"
#include "map.h"
-#include "inventory.h"
-#include "ban.h"
+#include "hud.h"
#include "gamedef.h"
#include "serialization.h" // For SER_FMT_VER_INVALID
#include "mods.h"
#include "inventorymanager.h"
#include "subgame.h"
-#include "sound.h"
-#include "util/thread.h"
-#include "util/string.h"
#include "rollback_interface.h" // Needed for rollbackRevertActions()
-#include <list> // Needed for rollbackRevertActions()
+#include "util/numeric.h"
+#include "util/thread.h"
+#include "environment.h"
+#include <string>
+#include <list>
+#include <map>
+#include <vector>
#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
-struct LuaState;
-typedef struct lua_State lua_State;
class IWritableItemDefManager;
class IWritableNodeDefManager;
class IWritableCraftDefManager;
+class BanManager;
class EventManager;
+class Inventory;
+class Player;
class PlayerSAO;
class IRollbackManager;
class EmergeManager;
+class GameScripting;
+class ServerEnvironment;
+struct SimpleSoundSpec;
+
class ServerError : public std::exception
{
};
class Server;
-
-class ServerThread : public SimpleThread
-{
- Server *m_server;
-
-public:
-
- ServerThread(Server *server):
- SimpleThread(),
- m_server(server)
- {
- }
-
- void * Thread();
-};
-
-struct PlayerInfo
-{
- u16 id;
- char name[PLAYERNAME_SIZE];
- v3f position;
- Address address;
- float avg_rtt;
-
- PlayerInfo();
- void PrintLine(std::ostream *s);
-};
+class ServerThread;
/*
Used for queueing and sorting block transfers in containers
pos = a_pos;
peer_id = a_peer_id;
}
- bool operator < (PrioritySortedBlockTransfer &other)
+ bool operator < (const PrioritySortedBlockTransfer &other) const
{
return priority < other.priority;
}
bool definitions_sent;
+ bool denied;
+
RemoteClient():
m_time_from_building(9999),
m_excess_gotblocks(0)
net_proto_version = 0;
pending_serialization_version = SER_FMT_VER_INVALID;
definitions_sent = false;
+ denied = false;
m_nearest_unsent_d = 0;
m_nearest_unsent_reset_timer = 0.0;
m_nothing_to_send_counter = 0;
dtime is used for resetting send radius at slow interval
*/
void GetNextBlocks(Server *server, float dtime,
-
core::array<PrioritySortedBlockTransfer> &dest);
+
std::vector<PrioritySortedBlockTransfer> &dest);
void GotBlock(v3s16 p);
void SentBlock(v3s16 p);
void SetBlockNotSent(v3s16 p);
- void SetBlocksNotSent(core::map<v3s16, MapBlock*> &blocks);
+ void SetBlocksNotSent(std::map<v3s16, MapBlock*> &blocks);
s32 SendingCount()
{
List of active objects that the client knows of.
Value is dummy.
*/
- core::map<u16, bool> m_known_objects;
+ std::set<u16> m_known_objects;
private:
/*
Key is position, value is dummy.
No MapBlock* is stored here because the blocks can get deleted.
*/
- core::map<v3s16, bool> m_blocks_sent;
+ std::set<v3s16> m_blocks_sent;
s16 m_nearest_unsent_d;
v3s16 m_last_center;
float m_nearest_unsent_reset_timer;
Block is removed when GOTBLOCKS is received.
Value is time from sending. (not used at the moment)
*/
- core::map<v3s16, float> m_blocks_sending;
+ std::map<v3s16, float> m_blocks_sending;
/*
Count of excess GotBlocks().
};
class Server : public con::PeerHandler, public MapEventReceiver,
- public InventoryManager, public IGameDef,
- public IBackgroundBlockEmerger
+ public InventoryManager, public IGameDef
{
public:
/*
Server(
const std::string &path_world,
- const std::string &path_config,
const SubgameSpec &gamespec,
bool simple_singleplayer_mode
);
void Receive();
void ProcessData(u8 *data, u32 datasize, u16 peer_id);
- core::list<PlayerInfo> getPlayerInfo();
-
// Environment must be locked when called
- void setTimeOfDay(u32 time)
- {
- m_env->setTimeOfDay(time);
- m_time_of_day_send_timer = 0;
- }
+ void setTimeOfDay(u32 time);
bool getShutdownRequested()
{
void reportPrivsModified(const std::string &name=""); // ""=all
void reportInventoryFormspecModified(const std::string &name);
- // 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);
- }
+ void setIpBanned(const std::string &ip, const std::string &name);
+ void unsetIpBanned(const std::string &ip_or_name);
+ std::string getBanDescription(const std::string &ip_or_name);
Address getPeerAddress(u16 peer_id)
{
}
// Envlock and conlock should be locked when calling this
- void notifyPlayer(const char *name, const std::wstring msg);
+ void notifyPlayer(const char *name, const std::wstring msg, const bool prepend);
void notifyPlayers(const std::wstring msg);
-
- void queueBlockEmerge(v3s16 blockpos, bool allow_generate);
+ void spawnParticle(const char *playername,
+ v3f pos, v3f velocity, v3f acceleration,
+ float expirationtime, float size,
+ bool collisiondetection, std::string texture);
+
+ void spawnParticleAll(v3f pos, v3f velocity, v3f acceleration,
+ float expirationtime, float size,
+ bool collisiondetection, std::string texture);
+
+ u32 addParticleSpawner(const char *playername,
+ u16 amount, float spawntime,
+ v3f minpos, v3f maxpos,
+ v3f minvel, v3f maxvel,
+ v3f minacc, v3f maxacc,
+ float minexptime, float maxexptime,
+ float minsize, float maxsize,
+ bool collisiondetection, std::string texture);
+
+ u32 addParticleSpawnerAll(u16 amount, float spawntime,
+ v3f minpos, v3f maxpos,
+ v3f minvel, v3f maxvel,
+ v3f minacc, v3f maxacc,
+ float minexptime, float maxexptime,
+ float minsize, float maxsize,
+ bool collisiondetection, std::string texture);
+
+ void deleteParticleSpawner(const char *playername, u32 id);
+ void deleteParticleSpawnerAll(u32 id);
// Creates or resets inventory
Inventory* createDetachedInventory(const std::string &name);
- // Envlock and conlock should be locked when using Lua
- lua_State *getLua(){ return m_lua; }
+ // Envlock and conlock should be locked when using scriptapi
+ GameScripting *getScriptIface(){ return m_script; }
// Envlock should be locked when using the rollback manager
IRollbackManager *getRollbackManager(){ return m_rollback; }
- //TODO: determine what should be locked when accessing the emerge manager
+ //TODO: determine what (if anything) should be locked to access EmergeManager
EmergeManager *getEmergeManager(){ return m_emerge; }
- BiomeDefManager *getBiomeDef(){ return m_biomedef; }
-
// actions: time-reversed list
// Return value: success/failure
bool rollbackRevertActions(const std::list<RollbackAction> &actions,
IWritableCraftDefManager* getWritableCraftDefManager();
const ModSpec* getModSpec(const std::string &modname);
- void getModNames(core::list<std::string> &modlist);
+ void getModNames(std::list<std::string> &modlist);
std::string getBuiltinLuaPath();
std::string getWorldPath(){ return m_path_world; }
}
bool showFormspec(const char *name, const std::string &formspec, const std::string &formname);
+ Map & getMap() { return m_env->getMap(); }
+ ServerEnvironment & getEnv() { return *m_env; }
+
+ u32 hudAdd(Player *player, HudElement *element);
+ bool hudRemove(Player *player, u32 id);
+ bool hudChange(Player *player, u32 id, HudElementStat stat, void *value);
+ bool hudSetFlags(Player *player, u32 flags, u32 mask);
+ bool hudSetHotbarItemcount(Player *player, s32 hotbar_itemcount);
+ void hudSetHotbarImage(Player *player, std::string name);
+ void hudSetHotbarSelectedImage(Player *player, std::string name);
+
private:
// con::PeerHandler implementation.
static void SendMovement(con::Connection &con, u16 peer_id);
static void SendHP(con::Connection &con, u16 peer_id, u8 hp);
+ static void SendBreath(con::Connection &con, u16 peer_id, u16 breath);
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);
+ IItemDefManager *itemdef, u16 protocol_version);
static void SendNodeDef(con::Connection &con, u16 peer_id,
INodeDefManager *nodedef, u16 protocol_version);
void SendInventory(u16 peer_id);
void SendChatMessage(u16 peer_id, const std::wstring &message);
void BroadcastChatMessage(const std::wstring &message);
+ void SendTimeOfDay(u16 peer_id, u16 time, f32 time_speed);
void SendPlayerHP(u16 peer_id);
+ void SendPlayerBreath(u16 peer_id);
void SendMovePlayer(u16 peer_id);
void SendPlayerPrivileges(u16 peer_id);
void SendPlayerInventoryFormspec(u16 peer_id);
void SendShowFormspecMessage(u16 peer_id, const std::string formspec, const std::string formname);
+ void SendHUDAdd(u16 peer_id, u32 id, HudElement *form);
+ void SendHUDRemove(u16 peer_id, u32 id);
+ void SendHUDChange(u16 peer_id, u32 id, HudElementStat stat, void *value);
+ void SendHUDSetFlags(u16 peer_id, u32 flags, u32 mask);
+ void SendHUDSetParam(u16 peer_id, u16 param, const std::string &value);
+
/*
Send a node removal/addition event to all clients except ignore_id.
Additionally, if far_players!=NULL, players further away than
*/
// 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);
+ std::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);
+ std::list<u16> *far_players=NULL, float far_d_nodes=100);
void setBlockNotSent(v3s16 p);
// Environment and Connection must be locked when called
- void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver);
+ void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto_version);
// 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);
+ const std::list<MediaRequest> &tosend);
void sendDetachedInventory(const std::string &name, u16 peer_id);
void sendDetachedInventoryToAll(const std::string &name);
void sendDetachedInventories(u16 peer_id);
+ // Adds a ParticleSpawner on peer with peer_id
+ void SendAddParticleSpawner(u16 peer_id, u16 amount, float spawntime,
+ v3f minpos, v3f maxpos,
+ v3f minvel, v3f maxvel,
+ v3f minacc, v3f maxacc,
+ float minexptime, float maxexptime,
+ float minsize, float maxsize,
+ bool collisiondetection, std::string texture, u32 id);
+
+ // Adds a ParticleSpawner on all peers
+ void SendAddParticleSpawnerAll(u16 amount, float spawntime,
+ v3f minpos, v3f maxpos,
+ v3f minvel, v3f maxvel,
+ v3f minacc, v3f maxacc,
+ float minexptime, float maxexptime,
+ float minsize, float maxsize,
+ bool collisiondetection, std::string texture, u32 id);
+
+ // Deletes ParticleSpawner on a single client
+ void SendDeleteParticleSpawner(u16 peer_id, u32 id);
+
+ // Deletes ParticleSpawner on all clients
+ void SendDeleteParticleSpawnerAll(u32 id);
+
+ // Spawns particle on single client
+ void SendSpawnParticle(u16 peer_id,
+ v3f pos, v3f velocity, v3f acceleration,
+ float expirationtime, float size,
+ bool collisiondetection, std::string texture);
+
+ // Spawns particle on all clients
+ void SendSpawnParticleAll(v3f pos, v3f velocity, v3f acceleration,
+ float expirationtime, float size,
+ bool collisiondetection, std::string texture);
+
/*
Something random
*/
void DiePlayer(u16 peer_id);
void RespawnPlayer(u16 peer_id);
+ void DenyAccess(u16 peer_id, const std::wstring &reason);
+
+ enum ClientDeletionReason {
+ CDR_LEAVE,
+ CDR_TIMEOUT,
+ CDR_DENY
+ };
+ void DeleteClient(u16 peer_id, ClientDeletionReason reason);
void UpdateCrafting(u16 peer_id);
// When called, connection mutex should be locked
RemoteClient* getClient(u16 peer_id);
+ RemoteClient* getClientNoEx(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();
- }
+ std::string getPlayerName(u16 peer_id);
+ PlayerSAO* getPlayerSAO(u16 peer_id);
/*
Get a player from memory or creates one.
// 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
con::Connection m_con;
JMutex m_con_mutex;
// Connected clients (behind the con mutex)
- core::map<u16, RemoteClient*> m_clients;
+ std::map<u16, RemoteClient*> m_clients;
u16 m_clients_number; //for announcing masterserver
- // Bann checking
- BanManager m_banmanager;
+ // Ban checking
+ BanManager *m_banmanager;
// Rollback manager (behind m_env_mutex)
IRollbackManager *m_rollback;
// Emerge manager
EmergeManager *m_emerge;
- // Biome Definition Manager
- BiomeDefManager *m_biomedef;
-
// Scripting
// Envlock and conlock should be locked when using Lua
- lua_State *m_lua;
+ GameScripting *m_script;
// Item definition manager
IWritableItemDefManager *m_itemdef;
JMutex m_step_dtime_mutex;
// The server mainly operates in this thread
- ServerThread m_thread;
+ ServerThread *m_thread;
/*
Time related stuff
*/
// Mod parent directory paths
- core::list<std::string> m_modspaths;
+ std::list<std::string> m_modspaths;
bool m_shutdown_requested;
*/
// key = name
std::map<std::string, Inventory*> m_detached_inventories;
+
+ /*
+ Particles
+ */
+ std::vector<u32> m_particlespawner_ids;
};
/*
projects / minetest.git / blobdiff