#include "content_abm.h"
#include "content_sao.h"
#include "mods.h"
-#include "sound.h" // dummySoundManager
#include "event_manager.h"
#include "serverlist.h"
#include "util/string.h"
-#include "util/mathconstants.h"
#include "rollback.h"
#include "util/serialize.h"
#include "util/thread.h"
} catch (con::ConnectionBindFailed &e) {
m_server->setAsyncFatalError(e.what());
} catch (LuaError &e) {
- m_server->setAsyncFatalError("Lua: " + std::string(e.what()));
+ m_server->setAsyncFatalError(
+ "ServerThread::run Lua: " + std::string(e.what()));
}
}
m_admin_chat(iface),
m_ignore_map_edit_events(false),
m_ignore_map_edit_events_peer_id(0),
- m_next_sound_id(0)
-
+ m_next_sound_id(0),
+ m_mod_storage_save_timer(10.0f)
{
m_liquid_transform_timer = 0.0;
m_liquid_transform_every = 1.0;
g_settings->get("kick_msg_crash"),
g_settings->getBool("ask_reconnect_on_crash"));
}
- throw ServerError(async_err);
+ throw ServerError("AsyncErr: " + async_err);
}
}
continue;
}
+ PlayerSAO *playersao = player->getPlayerSAO();
+ if (playersao == NULL)
+ continue;
+
+ s16 my_radius = MYMIN(radius, playersao->getWantedRange() * MAP_BLOCKSIZE);
+ if (my_radius <= 0) my_radius = radius;
+ //infostream << "Server: Active Radius " << my_radius << std::endl;
+
std::queue<u16> removed_objects;
std::queue<u16> added_objects;
- m_env->getRemovedActiveObjects(player, radius, player_radius,
+ m_env->getRemovedActiveObjects(playersao, my_radius, player_radius,
client->m_known_objects, removed_objects);
- m_env->getAddedActiveObjects(player, radius, player_radius,
+ m_env->getAddedActiveObjects(playersao, my_radius, player_radius,
client->m_known_objects, added_objects);
// Ignore if nothing happened
<< "packet size is " << pktSize << std::endl;
}
m_clients.unlock();
+
+ m_mod_storage_save_timer -= dtime;
+ if (m_mod_storage_save_timer <= 0.0f) {
+ infostream << "Saving registered mod storages." << std::endl;
+ m_mod_storage_save_timer = g_settings->getFloat("server_map_save_interval");
+ for (UNORDERED_MAP<std::string, ModMetadata *>::const_iterator
+ it = m_mod_storages.begin(); it != m_mod_storages.end(); ++it) {
+ if (it->second->isModified()) {
+ it->second->save(getModStoragePath());
+ }
+ }
+ }
}
/*
}
m_clients.unlock();
- RemotePlayer *player =
- static_cast<RemotePlayer*>(m_env->getPlayer(playername.c_str()));
+ RemotePlayer *player = m_env->getPlayer(playername.c_str());
// If failed, cancel
if ((playersao == NULL) || (player == NULL)) {
SendPlayerHPOrDie(playersao);
// Send Breath
- SendPlayerBreath(peer_id);
+ SendPlayerBreath(playersao);
// Show death screen if necessary
- if (player->isDead())
+ if (playersao->isDead())
SendDeathscreen(peer_id, false, v3f(0,0,0));
// Note things in chat if not in simple singleplayer mode
- if(!m_simple_singleplayer_mode) {
+ if (!m_simple_singleplayer_mode && g_settings->getBool("show_statusline_on_connect")) {
// Send information about server to player in chat
SendChatMessage(peer_id, getStatusString());
}
DSTACK(FUNCTION_NAME);
NetworkPacket pkt(TOCLIENT_SHOW_FORMSPEC, 0 , peer_id);
-
- pkt.putLongString(FORMSPEC_VERSION_STRING + formspec);
+ if (formspec == "" ){
+ //the client should close the formspec
+ pkt.putLongString("");
+ } else {
+ pkt.putLongString(FORMSPEC_VERSION_STRING + formspec);
+ }
pkt << formname;
Send(&pkt);
}
// Spawns a particle on peer with peer_id
-void Server::SendSpawnParticle(u16 peer_id, v3f pos, v3f velocity, v3f acceleration,
+void Server::SendSpawnParticle(u16 peer_id, u16 protocol_version,
+ v3f pos, v3f velocity, v3f acceleration,
float expirationtime, float size, bool collisiondetection,
bool collision_removal,
- bool vertical, const std::string &texture)
+ bool vertical, const std::string &texture,
+ const struct TileAnimationParams &animation, u8 glow)
{
DSTACK(FUNCTION_NAME);
+ if (peer_id == PEER_ID_INEXISTENT) {
+ // This sucks and should be replaced by a better solution in a refactor:
+ std::vector<u16> clients = m_clients.getClientIDs();
+ for (std::vector<u16>::iterator i = clients.begin(); i != clients.end(); ++i) {
+ RemotePlayer *player = m_env->getPlayer(*i);
+ if (!player)
+ continue;
+ SendSpawnParticle(*i, player->protocol_version,
+ pos, velocity, acceleration,
+ expirationtime, size, collisiondetection,
+ collision_removal, vertical, texture, animation, glow);
+ }
+ return;
+ }
NetworkPacket pkt(TOCLIENT_SPAWN_PARTICLE, 0, peer_id);
pkt.putLongString(texture);
pkt << vertical;
pkt << collision_removal;
+ // This is horrible but required (why are there two ways to serialize pkts?)
+ std::ostringstream os(std::ios_base::binary);
+ animation.serialize(os, protocol_version);
+ pkt.putRawString(os.str());
+ pkt << glow;
- if (peer_id != PEER_ID_INEXISTENT) {
- Send(&pkt);
- }
- else {
- m_clients.sendToAll(0, &pkt, true);
- }
+ Send(&pkt);
}
// Adds a ParticleSpawner on peer with peer_id
-void Server::SendAddParticleSpawner(u16 peer_id, u16 amount, float spawntime, v3f minpos, v3f maxpos,
+void Server::SendAddParticleSpawner(u16 peer_id, u16 protocol_version,
+ 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, bool collision_removal,
- bool vertical, const std::string &texture, u32 id)
+ u16 attached_id, bool vertical, const std::string &texture, u32 id,
+ const struct TileAnimationParams &animation, u8 glow)
{
DSTACK(FUNCTION_NAME);
+ if (peer_id == PEER_ID_INEXISTENT) {
+ // This sucks and should be replaced:
+ std::vector<u16> clients = m_clients.getClientIDs();
+ for (std::vector<u16>::iterator i = clients.begin(); i != clients.end(); ++i) {
+ RemotePlayer *player = m_env->getPlayer(*i);
+ if (!player)
+ continue;
+ SendAddParticleSpawner(*i, player->protocol_version,
+ amount, spawntime, minpos, maxpos,
+ minvel, maxvel, minacc, maxacc, minexptime, maxexptime,
+ minsize, maxsize, collisiondetection, collision_removal,
+ attached_id, vertical, texture, id, animation, glow);
+ }
+ return;
+ }
NetworkPacket pkt(TOCLIENT_ADD_PARTICLESPAWNER, 0, peer_id);
pkt << id << vertical;
pkt << collision_removal;
+ pkt << attached_id;
+ // This is horrible but required
+ std::ostringstream os(std::ios_base::binary);
+ animation.serialize(os, protocol_version);
+ pkt.putRawString(os.str());
+ pkt << glow;
- if (peer_id != PEER_ID_INEXISTENT) {
- Send(&pkt);
- }
- else {
- m_clients.sendToAll(0, &pkt, true);
- }
+ Send(&pkt);
}
void Server::SendDeleteParticleSpawner(u16 peer_id, u32 id)
playersao->m_messages_out.push(aom);
}
-void Server::SendPlayerBreath(u16 peer_id)
+void Server::SendPlayerBreath(PlayerSAO *sao)
{
DSTACK(FUNCTION_NAME);
- PlayerSAO *playersao = getPlayerSAO(peer_id);
- assert(playersao);
+ assert(sao);
- m_script->player_event(playersao, "breath_changed");
- SendBreath(peer_id, playersao->getBreath());
+ m_script->player_event(sao, "breath_changed");
+ SendBreath(sao->getPeerID(), sao->getBreath());
}
void Server::SendMovePlayer(u16 peer_id)
DSTACK(FUNCTION_NAME);
RemotePlayer *player = m_env->getPlayer(peer_id);
assert(player);
+ PlayerSAO *sao = player->getPlayerSAO();
+ assert(sao);
NetworkPacket pkt(TOCLIENT_MOVE_PLAYER, sizeof(v3f) + sizeof(f32) * 2, peer_id);
- pkt << player->getPosition() << player->getPitch() << player->getYaw();
+ pkt << sao->getBasePosition() << sao->getPitch() << sao->getYaw();
{
- v3f pos = player->getPosition();
- f32 pitch = player->getPitch();
- f32 yaw = player->getYaw();
+ v3f pos = sao->getBasePosition();
verbosestream << "Server: Sending TOCLIENT_MOVE_PLAYER"
<< " pos=(" << pos.X << "," << pos.Y << "," << pos.Z << ")"
- << " pitch=" << pitch
- << " yaw=" << yaw
+ << " pitch=" << sao->getPitch()
+ << " yaw=" << sao->getYaw()
<< std::endl;
}
if (!player)
continue;
+ PlayerSAO *sao = player->getPlayerSAO();
+ if (!sao)
+ continue;
+
if (pos_exists) {
- if(player->getPosition().getDistanceFrom(pos) >
+ if(sao->getBasePosition().getDistanceFrom(pos) >
params.max_hear_distance)
continue;
}
pkt << p;
std::vector<u16> clients = m_clients.getClientIDs();
- for(std::vector<u16>::iterator i = clients.begin();
- i != clients.end(); ++i) {
+ for (std::vector<u16>::iterator i = clients.begin(); i != clients.end(); ++i) {
if (far_players) {
// Get player
if (RemotePlayer *player = m_env->getPlayer(*i)) {
+ PlayerSAO *sao = player->getPlayerSAO();
+ if (!sao)
+ continue;
+
// If player is far away, only set modified blocks not sent
- v3f player_pos = player->getPosition();
- if(player_pos.getDistanceFrom(p_f) > maxd) {
+ v3f player_pos = sao->getBasePosition();
+ if (player_pos.getDistanceFrom(p_f) > maxd) {
far_players->push_back(*i);
continue;
}
v3f p_f = intToFloat(p, BS);
std::vector<u16> clients = m_clients.getClientIDs();
- for(std::vector<u16>::iterator i = clients.begin();
- i != clients.end(); ++i) {
-
- if(far_players) {
+ for(std::vector<u16>::iterator i = clients.begin(); i != clients.end(); ++i) {
+ if (far_players) {
// Get player
if (RemotePlayer *player = m_env->getPlayer(*i)) {
+ PlayerSAO *sao = player->getPlayerSAO();
+ if (!sao)
+ continue;
+
// If player is far away, only set modified blocks not sent
- v3f player_pos = player->getPosition();
+ v3f player_pos = sao->getBasePosition();
if(player_pos.getDistanceFrom(p_f) > maxd) {
far_players->push_back(*i);
continue;
NetworkPacket pkt(TOCLIENT_DETACHED_INVENTORY, 0, peer_id);
pkt.putRawString(s.c_str(), s.size());
- if (peer_id != PEER_ID_INEXISTENT) {
- Send(&pkt);
- }
- else {
- m_clients.sendToAll(0, &pkt, true);
+ const std::string &check = m_detached_inventories_player[name];
+ if (peer_id == PEER_ID_INEXISTENT) {
+ if (check == "")
+ return m_clients.sendToAll(0, &pkt, true);
+ RemotePlayer *p = m_env->getPlayer(check.c_str());
+ if (p)
+ m_clients.send(p->peer_id, 0, &pkt, true);
+ } else {
+ if (check == "" || getPlayerName(peer_id) == check)
+ Send(&pkt);
}
}
playersao->setHP(PLAYER_MAX_HP);
playersao->setBreath(PLAYER_MAX_BREATH);
- SendPlayerHP(peer_id);
- SendPlayerBreath(peer_id);
-
bool repositioned = m_script->on_respawnplayer(playersao);
- if(!repositioned){
+ if (!repositioned) {
v3f pos = findSpawnPos();
// setPos will send the new position to client
playersao->setPos(pos);
}
+
+ SendPlayerHP(peer_id);
}
RemotePlayer *player = m_env->getPlayer(peer_id);
/* Run scripts and remove from environment */
- if(player != NULL) {
+ if (player != NULL) {
PlayerSAO *playersao = player->getPlayerSAO();
assert(playersao);
RollbackScopeActor rollback_scope(m_rollback,
std::string("player:") + name);
- // Line to send
- std::wstring line;
- // Whether to send line to the player that sent the message, or to all players
- bool broadcast_line = true;
-
- // Run script hook
- bool ate = m_script->on_chat_message(name,
- wide_to_utf8(wmessage));
- // If script ate the message, don't proceed
- if (ate)
- return L"";
-
if (player) {
switch (player->canSendChatMessage()) {
case RPLAYER_CHATRESULT_FLOODING: {
std::wstringstream ws;
ws << L"You cannot send more messages. You are limited to "
- << g_settings->getFloat("chat_message_limit_per_10sec")
- << L" messages per 10 seconds.";
+ << g_settings->getFloat("chat_message_limit_per_10sec")
+ << L" messages per 10 seconds.";
return ws.str();
}
case RPLAYER_CHATRESULT_KICK:
- DenyAccess_Legacy(player->peer_id, L"You have been kicked due to message flooding.");
+ DenyAccess_Legacy(player->peer_id,
+ L"You have been kicked due to message flooding.");
return L"";
- case RPLAYER_CHATRESULT_OK: break;
- default: FATAL_ERROR("Unhandled chat filtering result found.");
+ case RPLAYER_CHATRESULT_OK:
+ break;
+ default:
+ FATAL_ERROR("Unhandled chat filtering result found.");
}
}
- if (m_max_chatmessage_length > 0 && wmessage.length() > m_max_chatmessage_length) {
+ if (m_max_chatmessage_length > 0
+ && wmessage.length() > m_max_chatmessage_length) {
return L"Your message exceed the maximum chat message limit set on the server. "
- L"It was refused. Send a shorter message";
+ L"It was refused. Send a shorter message";
}
+ // Run script hook, exit if script ate the chat message
+ if (m_script->on_chat_message(name, wide_to_utf8(wmessage)))
+ return L"";
+
+ // Line to send
+ std::wstring line;
+ // Whether to send line to the player that sent the message, or to all players
+ bool broadcast_line = true;
+
// Commands are implemented in Lua, so only catch invalid
// commands that were not "eaten" and send an error back
if (wmessage[0] == L'/') {
std::vector<u16> clients = m_clients.getClientIDs();
+ /*
+ Send the message back to the inital sender
+ if they are using protocol version >= 29
+ */
+
u16 peer_id_to_avoid_sending = (player ? player->peer_id : PEER_ID_INEXISTENT);
+ if (player && player->protocol_version >= 29)
+ peer_id_to_avoid_sending = PEER_ID_INEXISTENT;
+
for (u16 i = 0; i < clients.size(); i++) {
u16 cid = clients[i];
if (cid != peer_id_to_avoid_sending)
v3f velocity, v3f acceleration,
float expirationtime, float size, bool
collisiondetection, bool collision_removal,
- bool vertical, const std::string &texture)
+ bool vertical, const std::string &texture,
+ const struct TileAnimationParams &animation, u8 glow)
{
// m_env will be NULL if the server is initializing
if (!m_env)
return;
- u16 peer_id = PEER_ID_INEXISTENT;
+ u16 peer_id = PEER_ID_INEXISTENT, proto_ver = 0;
if (playername != "") {
RemotePlayer *player = m_env->getPlayer(playername.c_str());
if (!player)
return;
peer_id = player->peer_id;
+ proto_ver = player->protocol_version;
}
- SendSpawnParticle(peer_id, pos, velocity, acceleration,
+ SendSpawnParticle(peer_id, proto_ver, pos, velocity, acceleration,
expirationtime, size, collisiondetection,
- collision_removal, vertical, texture);
+ collision_removal, vertical, texture, animation, glow);
}
u32 Server::addParticleSpawner(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, bool collision_removal,
- bool vertical, const std::string &texture,
- const std::string &playername)
+ ServerActiveObject *attached, bool vertical, const std::string &texture,
+ const std::string &playername, const struct TileAnimationParams &animation,
+ u8 glow)
{
// m_env will be NULL if the server is initializing
if (!m_env)
return -1;
- u16 peer_id = PEER_ID_INEXISTENT;
+ u16 peer_id = PEER_ID_INEXISTENT, proto_ver = 0;
if (playername != "") {
RemotePlayer *player = m_env->getPlayer(playername.c_str());
if (!player)
return -1;
peer_id = player->peer_id;
+ proto_ver = player->protocol_version;
}
- u32 id = m_env->addParticleSpawner(spawntime);
- SendAddParticleSpawner(peer_id, amount, spawntime,
+ u16 attached_id = attached ? attached->getId() : 0;
+
+ u32 id;
+ if (attached_id == 0)
+ id = m_env->addParticleSpawner(spawntime);
+ else
+ id = m_env->addParticleSpawner(spawntime, attached_id);
+
+ SendAddParticleSpawner(peer_id, proto_ver, amount, spawntime,
minpos, maxpos, minvel, maxvel, minacc, maxacc,
minexptime, maxexptime, minsize, maxsize,
- collisiondetection, collision_removal, vertical, texture, id);
+ collisiondetection, collision_removal, attached_id, vertical,
+ texture, id, animation, glow);
return id;
}
SendDeleteParticleSpawner(peer_id, id);
}
-Inventory* Server::createDetachedInventory(const std::string &name)
+Inventory* Server::createDetachedInventory(const std::string &name, const std::string &player)
{
if(m_detached_inventories.count(name) > 0){
infostream<<"Server clearing detached inventory \""<<name<<"\""<<std::endl;
Inventory *inv = new Inventory(m_itemdef);
sanity_check(inv);
m_detached_inventories[name] = inv;
+ m_detached_inventories_player[name] = player;
//TODO find a better way to do this
sendDetachedInventory(name,PEER_ID_INEXISTENT);
return inv;
{
return m_craftdef;
}
-ITextureSource *Server::getTextureSource()
-{
- return NULL;
-}
-IShaderSource *Server::getShaderSource()
-{
- return NULL;
-}
-scene::ISceneManager *Server::getSceneManager()
-{
- return NULL;
-}
u16 Server::allocateUnknownNodeId(const std::string &name)
{
return m_nodedef->allocateDummy(name);
}
-ISoundManager *Server::getSoundManager()
-{
- return &dummySoundManager;
-}
-
MtEventManager *Server::getEventManager()
{
return m_event;
return porting::path_share + DIR_DELIM + "builtin";
}
+std::string Server::getModStoragePath() const
+{
+ return m_path_world + DIR_DELIM + "mod_storage";
+}
+
v3f Server::findSpawnPos()
{
ServerMap &map = m_env->getServerMap();
return NULL;
}
- // Load player if it isn't already loaded
- if (!player) {
- player = m_env->loadPlayer(name);
- }
+ // Create a new player active object
+ PlayerSAO *playersao = new PlayerSAO(m_env, peer_id, isSingleplayer());
+ player = m_env->loadPlayer(name, playersao);
// Create player if it doesn't exist
if (!player) {
// Set player position
infostream<<"Server: Finding spawn place for player \""
<<name<<"\""<<std::endl;
- v3f pos = findSpawnPos();
- player->setPosition(pos);
+ playersao->setBasePosition(findSpawnPos());
// Make sure the player is saved
player->setModified(true);
// If the player exists, ensure that they respawn inside legal bounds
// This fixes an assert crash when the player can't be added
// to the environment
- if (objectpos_over_limit(player->getPosition())) {
+ if (objectpos_over_limit(playersao->getBasePosition())) {
actionstream << "Respawn position for player \""
<< name << "\" outside limits, resetting" << std::endl;
- v3f pos = findSpawnPos();
- player->setPosition(pos);
+ playersao->setBasePosition(findSpawnPos());
}
}
- // Create a new player active object
- PlayerSAO *playersao = new PlayerSAO(m_env, player, peer_id,
- getPlayerEffectivePrivs(player->getName()),
- isSingleplayer());
+ playersao->initialize(player, getPlayerEffectivePrivs(player->getName()));
player->protocol_version = proto_version;
return playersao;
}
+bool Server::registerModStorage(ModMetadata *storage)
+{
+ if (m_mod_storages.find(storage->getModName()) != m_mod_storages.end()) {
+ errorstream << "Unable to register same mod storage twice. Storage name: "
+ << storage->getModName() << std::endl;
+ return false;
+ }
+
+ m_mod_storages[storage->getModName()] = storage;
+ return true;
+}
+
+void Server::unregisterModStorage(const std::string &name)
+{
+ UNORDERED_MAP<std::string, ModMetadata *>::const_iterator it = m_mod_storages.find(name);
+ if (it != m_mod_storages.end()) {
+ // Save unconditionaly on unregistration
+ it->second->save(getModStoragePath());
+ m_mod_storages.erase(name);
+ }
+}
+
void dedicated_server_loop(Server &server, bool &kill)
{
DSTACK(FUNCTION_NAME);
projects / dragonfireclient.git / blobdiff