#include "settings.h"
#include "profiler.h"
#include "log.h"
-#include "serverscripting.h"
+#include "scripting_server.h"
#include "nodedef.h"
#include "itemdef.h"
#include "craftdef.h"
#include "util/base64.h"
#include "util/sha1.h"
#include "util/hex.h"
+#include "database.h"
class ClientNotFoundException : public BaseException
{
m_clients(&m_con),
m_shutdown_requested(false),
m_shutdown_ask_reconnect(false),
+ m_shutdown_timer(0.0f),
m_admin_chat(iface),
m_ignore_map_edit_events(false),
m_ignore_map_edit_events_peer_id(0),
if (!string_allowed(mod.name, MODNAME_ALLOWED_CHARS)) {
throw ModError("Error loading mod \"" + mod.name +
"\": Mod name does not follow naming conventions: "
- "Only chararacters [a-z0-9_] are allowed.");
+ "Only characters [a-z0-9_] are allowed.");
}
std::string script_path = mod.path + DIR_DELIM + "init.lua";
infostream << " [" << padStringRight(mod.name, 12) << "] [\""
ScopeProfiler sp(g_profiler, "Server: liquid transform");
std::map<v3s16, MapBlock*> modified_blocks;
- m_env->getMap().transformLiquids(modified_blocks);
+ m_env->getMap().transformLiquids(modified_blocks, m_env);
#if 0
/*
Update lighting
m_env->saveMeta();
}
}
+
+ // Timed shutdown
+ static const float shutdown_msg_times[] =
+ {
+ 1, 2, 3, 4, 5, 10, 15, 20, 25, 30, 45, 60, 120, 180, 300, 600, 1200, 1800, 3600
+ };
+
+ if (m_shutdown_timer > 0.0f) {
+ // Automated messages
+ if (m_shutdown_timer < shutdown_msg_times[ARRLEN(shutdown_msg_times) - 1]) {
+ for (u16 i = 0; i < ARRLEN(shutdown_msg_times) - 1; i++) {
+ // If shutdown timer matches an automessage, shot it
+ if (m_shutdown_timer > shutdown_msg_times[i] &&
+ m_shutdown_timer - dtime < shutdown_msg_times[i]) {
+ std::wstringstream ws;
+
+ ws << L"*** Server shutting down in "
+ << duration_to_string(myround(m_shutdown_timer - dtime)).c_str()
+ << ".";
+
+ infostream << wide_to_utf8(ws.str()).c_str() << std::endl;
+ SendChatMessage(PEER_ID_INEXISTENT, ws.str());
+ break;
+ }
+ }
+ }
+
+ m_shutdown_timer -= dtime;
+ if (m_shutdown_timer < 0.0f) {
+ m_shutdown_timer = 0.0f;
+ m_shutdown_requested = true;
+ }
+ }
}
void Server::Receive()
// Send inventory
SendInventory(playersao);
- // Send HP
- SendPlayerHPOrDie(playersao);
+ // Send HP or death screen
+ if (playersao->isDead())
+ SendDeathscreen(peer_id, false, v3f(0,0,0));
+ else
+ SendPlayerHPOrDie(playersao);
// Send Breath
SendPlayerBreath(playersao);
- // Show death screen if necessary
- 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 && g_settings->getBool("show_statusline_on_connect")) {
// Send information about server to player in chat
Send(&pkt);
}
else {
- m_clients.sendToAll(0, &pkt, true);
+ m_clients.sendToAll(&pkt);
}
}
const struct TileAnimationParams &animation, u8 glow)
{
DSTACK(FUNCTION_NAME);
+ static const float radius =
+ g_settings->getS16("max_block_send_distance") * MAP_BLOCKSIZE * BS;
+
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;
+
+ PlayerSAO *sao = player->getPlayerSAO();
+ if (!sao)
+ continue;
+
+ // Do not send to distant clients
+ if (sao->getBasePosition().getDistanceFrom(pos * BS) > radius)
+ continue;
+
SendSpawnParticle(*i, player->protocol_version,
pos, velocity, acceleration,
expirationtime, size, collisiondetection,
Send(&pkt);
}
else {
- m_clients.sendToAll(0, &pkt, true);
+ m_clients.sendToAll(&pkt);
}
}
}
void Server::SendSetSky(u16 peer_id, const video::SColor &bgcolor,
- const std::string &type, const std::vector<std::string> ¶ms)
+ const std::string &type, const std::vector<std::string> ¶ms,
+ bool &clouds)
{
NetworkPacket pkt(TOCLIENT_SET_SKY, 0, peer_id);
pkt << bgcolor << type << (u16) params.size();
for(size_t i=0; i<params.size(); i++)
pkt << params[i];
+ pkt << clouds;
+
+ Send(&pkt);
+}
+
+void Server::SendCloudParams(u16 peer_id, float density,
+ const video::SColor &color_bright,
+ const video::SColor &color_ambient,
+ float height,
+ float thickness,
+ const v2f &speed)
+{
+ NetworkPacket pkt(TOCLIENT_CLOUD_PARAMS, 0, peer_id);
+ pkt << density << color_bright << color_ambient
+ << height << thickness << speed;
+
Send(&pkt);
}
pkt << time << time_speed;
if (peer_id == PEER_ID_INEXISTENT) {
- m_clients.sendToAll(0, &pkt, true);
+ m_clients.sendToAll(&pkt);
}
else {
Send(&pkt);
m_playing_sounds[id] = ServerPlayingSound();
ServerPlayingSound &psound = m_playing_sounds[id];
psound.params = params;
+ psound.spec = spec;
+ float gain = params.gain * spec.gain;
NetworkPacket pkt(TOCLIENT_PLAY_SOUND, 0);
- pkt << id << spec.name << (float) (spec.gain * params.gain)
- << (u8) params.type << pos << params.object << params.loop;
+ pkt << id << spec.name << gain
+ << (u8) params.type << pos << params.object
+ << params.loop << params.fade;
+
+ // Backwards compability
+ bool play_sound = gain > 0;
- for(std::vector<u16>::iterator i = dst_clients.begin();
+ for (std::vector<u16>::iterator i = dst_clients.begin();
i != dst_clients.end(); ++i) {
- psound.clients.insert(*i);
- m_clients.send(*i, 0, &pkt, true);
+ if (play_sound || m_clients.getProtocolVersion(*i) >= 32) {
+ psound.clients.insert(*i);
+ m_clients.send(*i, 0, &pkt, true);
+ }
}
return id;
}
m_playing_sounds.erase(i);
}
+void Server::fadeSound(s32 handle, float step, float gain)
+{
+ // Get sound reference
+ UNORDERED_MAP<s32, ServerPlayingSound>::iterator i =
+ m_playing_sounds.find(handle);
+ if (i == m_playing_sounds.end())
+ return;
+
+ ServerPlayingSound &psound = i->second;
+ psound.params.gain = gain;
+
+ NetworkPacket pkt(TOCLIENT_FADE_SOUND, 4);
+ pkt << handle << step << gain;
+
+ // Backwards compability
+ bool play_sound = gain > 0;
+ ServerPlayingSound compat_psound = psound;
+ compat_psound.clients.clear();
+
+ NetworkPacket compat_pkt(TOCLIENT_STOP_SOUND, 4);
+ compat_pkt << handle;
+
+ for (UNORDERED_SET<u16>::iterator it = psound.clients.begin();
+ it != psound.clients.end();) {
+ if (m_clients.getProtocolVersion(*it) >= 32) {
+ // Send as reliable
+ m_clients.send(*it, 0, &pkt, true);
+ ++it;
+ } else {
+ compat_psound.clients.insert(*it);
+ // Stop old sound
+ m_clients.send(*it, 0, &compat_pkt, true);
+ psound.clients.erase(it++);
+ }
+ }
+
+ // Remove sound reference
+ if (!play_sound || psound.clients.size() == 0)
+ m_playing_sounds.erase(i);
+
+ if (play_sound && compat_psound.clients.size() > 0) {
+ // Play new sound volume on older clients
+ playSound(compat_psound.spec, compat_psound.params);
+ }
+}
+
void Server::sendRemoveNode(v3s16 p, u16 ignore_id,
std::vector<u16> *far_players, float far_d_nodes)
{
const std::string &check = m_detached_inventories_player[name];
if (peer_id == PEER_ID_INEXISTENT) {
if (check == "")
- return m_clients.sendToAll(0, &pkt, true);
+ return m_clients.sendToAll(&pkt);
RemotePlayer *p = m_env->getPlayer(check.c_str());
if (p)
m_clients.send(p->peer_id, 0, &pkt, true);
bool repositioned = m_script->on_respawnplayer(playersao);
if (!repositioned) {
- v3f pos = findSpawnPos();
// setPos will send the new position to client
- playersao->setPos(pos);
+ playersao->setPos(findSpawnPos());
}
SendPlayerHP(peer_id);
// 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::wstring wcmd = wmessage.substr(1);
+ if (check_shout_priv && !checkPriv(name, "shout")) {
+ line += L"-!- You don't have permission to shout.";
broadcast_line = false;
- if (wcmd.length() == 0)
- line += L"-!- Empty command";
- else
- line += L"-!- Invalid command: " + str_split(wcmd, L' ')[0];
} else {
- if (check_shout_priv && !checkPriv(name, "shout")) {
- line += L"-!- You don't have permission to shout.";
- broadcast_line = false;
- } else {
- line += L"<";
- line += wname;
- line += L"> ";
- line += wmessage;
- }
+ line += L"<";
+ line += wname;
+ line += L"> ";
+ line += wmessage;
}
/*
}
bool Server::setSky(RemotePlayer *player, const video::SColor &bgcolor,
- const std::string &type, const std::vector<std::string> ¶ms)
+ const std::string &type, const std::vector<std::string> ¶ms,
+ bool &clouds)
+{
+ if (!player)
+ return false;
+
+ player->setSky(bgcolor, type, params, clouds);
+ SendSetSky(player->peer_id, bgcolor, type, params, clouds);
+ return true;
+}
+
+bool Server::setClouds(RemotePlayer *player, float density,
+ const video::SColor &color_bright,
+ const video::SColor &color_ambient,
+ float height,
+ float thickness,
+ const v2f &speed)
{
if (!player)
return false;
- player->setSky(bgcolor, type, params);
- SendSetSky(player->peer_id, bgcolor, type, params);
+ SendCloudParams(player->peer_id, density,
+ color_bright, color_ambient, height,
+ thickness, speed);
return true;
}
s32 range = 1 + i;
// We're going to try to throw the player to this position
v2s16 nodepos2d = v2s16(
- -range + (myrand() % (range * 2)),
- -range + (myrand() % (range * 2)));
+ -range + (myrand() % (range * 2)),
+ -range + (myrand() % (range * 2)));
// Get spawn level at point
s16 spawn_level = m_emerge->getSpawnLevelAtPoint(nodepos2d);
return nodeposf;
}
-PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id, u16 proto_version)
+void Server::requestShutdown(const std::string &msg, bool reconnect, float delay)
{
- bool newplayer = false;
+ m_shutdown_timer = delay;
+ m_shutdown_msg = msg;
+ m_shutdown_ask_reconnect = reconnect;
+
+ if (delay == 0.0f) {
+ // No delay, shutdown immediately
+ m_shutdown_requested = true;
+ // only print to the infostream, a chat message saying
+ // "Server Shutting Down" is sent when the server destructs.
+ infostream << "*** Immediate Server shutdown requested." << std::endl;
+ } else if (delay < 0.0f && m_shutdown_timer > 0.0f) {
+ // Negative delay, cancel shutdown if requested
+ m_shutdown_timer = 0.0f;
+ m_shutdown_msg = "";
+ m_shutdown_ask_reconnect = false;
+ m_shutdown_requested = false;
+ std::wstringstream ws;
+
+ ws << L"*** Server shutdown canceled.";
+
+ infostream << wide_to_utf8(ws.str()).c_str() << std::endl;
+ SendChatMessage(PEER_ID_INEXISTENT, ws.str());
+ } else if (delay > 0.0f) {
+ // Positive delay, tell the clients when the server will shut down
+ std::wstringstream ws;
+
+ ws << L"*** Server shutting down in "
+ << duration_to_string(myround(m_shutdown_timer)).c_str()
+ << ".";
+
+ infostream << wide_to_utf8(ws.str()).c_str() << std::endl;
+ SendChatMessage(PEER_ID_INEXISTENT, ws.str());
+ }
+}
+PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id, u16 proto_version)
+{
/*
Try to get an existing player
*/
return NULL;
}
- // 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) {
- newplayer = true;
- player = new RemotePlayer(name, this->idef());
- // Set player position
- infostream<<"Server: Finding spawn place for player \""
- <<name<<"\""<<std::endl;
- playersao->setBasePosition(findSpawnPos());
-
- // Make sure the player is saved
- player->setModified(true);
-
- // Add player to environment
- m_env->addPlayer(player);
- } else {
- // 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(playersao->getBasePosition())) {
- actionstream << "Respawn position for player \""
- << name << "\" outside limits, resetting" << std::endl;
- playersao->setBasePosition(findSpawnPos());
- }
+ player = new RemotePlayer(name, idef());
}
- playersao->initialize(player, getPlayerEffectivePrivs(player->getName()));
-
- player->protocol_version = proto_version;
+ bool newplayer = false;
- /* Clean up old HUD elements from previous sessions */
- player->clearHud();
+ // Load player
+ PlayerSAO *playersao = m_env->loadPlayer(player, &newplayer, peer_id, isSingleplayer());
- /* Add object to environment */
- m_env->addActiveObject(playersao);
+ // Complete init with server parts
+ playersao->finalize(player, getPlayerEffectivePrivs(player->getName()));
+ player->protocol_version = proto_version;
/* Run scripts */
if (newplayer) {
projects / minetest.git / blobdiff