#include "content_mapnode.h"
#include "content_nodemeta.h"
#include "content_sao.h"
-#include "mods.h"
-#include "event_manager.h"
+#include "content/mods.h"
#include "modchannels.h"
#include "serverlist.h"
#include "util/string.h"
return v3f(0,0,0);
}
+void Server::ShutdownState::reset()
+{
+ m_timer = 0.0f;
+ message.clear();
+ should_reconnect = false;
+ is_requested = false;
+}
+
+void Server::ShutdownState::trigger(float delay, const std::string &msg, bool reconnect)
+{
+ m_timer = delay;
+ message = msg;
+ should_reconnect = reconnect;
+}
+
+void Server::ShutdownState::tick(float dtime, Server *server)
+{
+ if (m_timer <= 0.0f)
+ return;
+
+ // Timed shutdown
+ static const float shutdown_msg_times[] =
+ {
+ 1, 2, 3, 4, 5, 10, 20, 40, 60, 120, 180, 300, 600, 1200, 1800, 3600
+ };
+
+ // Automated messages
+ if (m_timer < shutdown_msg_times[ARRLEN(shutdown_msg_times) - 1]) {
+ for (float t : shutdown_msg_times) {
+ // If shutdown timer matches an automessage, shot it
+ if (m_timer > t && m_timer - dtime < t) {
+ std::wstring periodicMsg = getShutdownTimerMessage();
+
+ infostream << wide_to_utf8(periodicMsg).c_str() << std::endl;
+ server->SendChatMessage(PEER_ID_INEXISTENT, periodicMsg);
+ break;
+ }
+ }
+ }
+
+ m_timer -= dtime;
+ if (m_timer < 0.0f) {
+ m_timer = 0.0f;
+ is_requested = true;
+ }
+}
+std::wstring Server::ShutdownState::getShutdownTimerMessage() const
+{
+ std::wstringstream ws;
+ ws << L"*** Server shutting down in "
+ << duration_to_string(myround(m_timer)).c_str() << ".";
+ return ws.str();
+}
/*
Server
m_itemdef(createItemDefManager()),
m_nodedef(createNodeDefManager()),
m_craftdef(createCraftDefManager()),
- m_event(new EventManager()),
m_uptime(0),
m_clients(m_con),
m_admin_chat(iface),
{
m_lag = g_settings->getFloat("dedicated_server_step");
- if (path_world.empty())
+ if (m_path_world.empty())
throw ServerError("Supplied empty world path");
- if(!gamespec.isValid())
+ if (!gamespec.isValid())
throw ServerError("Supplied invalid gamespec");
+}
+
+Server::~Server()
+{
+ infostream << "Server destructing" << std::endl;
+
+ // Send shutdown message
+ SendChatMessage(PEER_ID_INEXISTENT, ChatMessage(CHATMESSAGE_TYPE_ANNOUNCE,
+ L"*** Server shutting down"));
+
+ if (m_env) {
+ MutexAutoLock envlock(m_env_mutex);
+
+ infostream << "Server: Saving players" << std::endl;
+ m_env->saveLoadedPlayers();
+
+ infostream << "Server: Kicking players" << std::endl;
+ std::string kick_msg;
+ bool reconnect = false;
+ if (isShutdownRequested()) {
+ reconnect = m_shutdown_state.should_reconnect;
+ kick_msg = m_shutdown_state.message;
+ }
+ if (kick_msg.empty()) {
+ kick_msg = g_settings->get("kick_msg_shutdown");
+ }
+ m_env->kickAllPlayers(SERVER_ACCESSDENIED_SHUTDOWN,
+ kick_msg, reconnect);
+ }
+
+ // Do this before stopping the server in case mapgen callbacks need to access
+ // server-controlled resources (like ModStorages). Also do them before
+ // shutdown callbacks since they may modify state that is finalized in a
+ // callback.
+ if (m_emerge)
+ m_emerge->stopThreads();
+
+ if (m_env) {
+ MutexAutoLock envlock(m_env_mutex);
+
+ // Execute script shutdown hooks
+ infostream << "Executing shutdown hooks" << std::endl;
+ m_script->on_shutdown();
+
+ infostream << "Server: Saving environment metadata" << std::endl;
+ m_env->saveMeta();
+ }
+
+ // Stop threads
+ if (m_thread) {
+ stop();
+ delete m_thread;
+ }
+
+ // Delete things in the reverse order of creation
+ delete m_emerge;
+ delete m_env;
+ delete m_rollback;
+ delete m_banmanager;
+ delete m_itemdef;
+ delete m_nodedef;
+ delete m_craftdef;
+
+ // Deinitialize scripting
+ infostream << "Server: Deinitializing scripting" << std::endl;
+ delete m_script;
+
+ // Delete detached inventories
+ for (auto &detached_inventory : m_detached_inventories) {
+ delete detached_inventory.second;
+ }
+}
- infostream<<"Server created for gameid \""<<m_gamespec.id<<"\"";
- if(m_simple_singleplayer_mode)
- infostream<<" in simple singleplayer mode"<<std::endl;
+void Server::init()
+{
+ infostream << "Server created for gameid \"" << m_gamespec.id << "\"";
+ if (m_simple_singleplayer_mode)
+ infostream << " in simple singleplayer mode" << std::endl;
else
- infostream<<std::endl;
- infostream<<"- world: "<<m_path_world<<std::endl;
- infostream<<"- game: "<<m_gamespec.path<<std::endl;
+ infostream << std::endl;
+ infostream << "- world: " << m_path_world << std::endl;
+ infostream << "- game: " << m_gamespec.path << std::endl;
// Create world if it doesn't exist
- if(!loadGameConfAndInitWorld(m_path_world, m_gamespec))
+ if (!loadGameConfAndInitWorld(m_path_world, m_gamespec))
throw ServerError("Failed to initialize world");
// Create server thread
std::string ban_path = m_path_world + DIR_DELIM "ipban.txt";
m_banmanager = new BanManager(ban_path);
- m_modmgr = std::unique_ptr<ServerModManager>(new ServerModManager(
- m_path_world));
+ m_modmgr = std::unique_ptr<ServerModManager>(new ServerModManager(m_path_world));
std::vector<ModSpec> unsatisfied_mods = m_modmgr->getUnsatisfiedMods();
// complain about mods with unsatisfied dependencies
if (!m_modmgr->isConsistent()) {
MutexAutoLock envlock(m_env_mutex);
// Create the Map (loads map_meta.txt, overriding configured mapgen params)
- ServerMap *servermap = new ServerMap(path_world, this, m_emerge);
+ ServerMap *servermap = new ServerMap(m_path_world, this, m_emerge);
// Initialize scripting
- infostream<<"Server: Initializing Lua"<<std::endl;
+ infostream << "Server: Initializing Lua" << std::endl;
m_script = new ServerScripting(this);
m_script->loadMod(getBuiltinLuaPath() + DIR_DELIM "init.lua", BUILTIN_MOD_NAME);
- m_mods = m_modmgr->getMods();
-
m_modmgr->loadMods(m_script);
// Read Textures and calculate sha1 sums
// Initialize mapgens
m_emerge->initMapgens(servermap->getMapgenParams());
- m_enable_rollback_recording = g_settings->getBool("enable_rollback_recording");
- if (m_enable_rollback_recording) {
+ if (g_settings->getBool("enable_rollback_recording")) {
// Create rollback manager
m_rollback = new RollbackManager(m_path_world, this);
}
// Register us to receive map edit events
servermap->addEventReceiver(this);
- // If file exists, load environment metadata
- if (fs::PathExists(m_path_world + DIR_DELIM "env_meta.txt")) {
- infostream << "Server: Loading environment metadata" << std::endl;
- m_env->loadMeta();
- } else {
- m_env->loadDefaultMeta();
- }
+ m_env->loadMeta();
m_liquid_transform_every = g_settings->getFloat("liquid_update");
m_max_chatmessage_length = g_settings->getU16("chat_message_max_size");
- m_csm_flavour_limits = g_settings->getU64("csm_flavour_limits");
- m_csm_noderange_limit = g_settings->getU32("csm_flavour_noderange_limit");
-}
-
-Server::~Server()
-{
- infostream << "Server destructing" << std::endl;
-
- // Send shutdown message
- SendChatMessage(PEER_ID_INEXISTENT, ChatMessage(CHATMESSAGE_TYPE_ANNOUNCE,
- L"*** Server shutting down"));
-
- {
- MutexAutoLock envlock(m_env_mutex);
-
- infostream << "Server: Saving players" << std::endl;
- m_env->saveLoadedPlayers();
-
- infostream << "Server: Kicking players" << std::endl;
- std::string kick_msg;
- bool reconnect = false;
- if (getShutdownRequested()) {
- reconnect = m_shutdown_ask_reconnect;
- kick_msg = m_shutdown_msg;
- }
- if (kick_msg.empty()) {
- kick_msg = g_settings->get("kick_msg_shutdown");
- }
- m_env->kickAllPlayers(SERVER_ACCESSDENIED_SHUTDOWN,
- kick_msg, reconnect);
- }
-
- // Do this before stopping the server in case mapgen callbacks need to access
- // server-controlled resources (like ModStorages). Also do them before
- // shutdown callbacks since they may modify state that is finalized in a
- // callback.
- m_emerge->stopThreads();
-
- {
- MutexAutoLock envlock(m_env_mutex);
-
- // Execute script shutdown hooks
- infostream << "Executing shutdown hooks" << std::endl;
- m_script->on_shutdown();
-
- infostream << "Server: Saving environment metadata" << std::endl;
- m_env->saveMeta();
- }
-
- // Stop threads
- stop();
- delete m_thread;
-
- // Delete things in the reverse order of creation
- delete m_emerge;
- delete m_env;
- delete m_rollback;
- delete m_banmanager;
- delete m_event;
- delete m_itemdef;
- delete m_nodedef;
- delete m_craftdef;
-
- // Deinitialize scripting
- infostream << "Server: Deinitializing scripting" << std::endl;
- delete m_script;
-
- // Delete detached inventories
- for (auto &detached_inventory : m_detached_inventories) {
- delete detached_inventory.second;
- }
+ m_csm_restriction_flags = g_settings->getU64("csm_restriction_flags");
+ m_csm_restriction_noderange = g_settings->getU32("csm_restriction_noderange");
}
void Server::start()
m_thread->start();
// ASCII art for the win!
- actionstream
+ std::cerr
<< " .__ __ __ " << std::endl
<< " _____ |__| ____ _____/ |_ ____ _______/ |_ " << std::endl
<< " / \\| |/ \\_/ __ \\ __\\/ __ \\ / ___/\\ __\\" << std::endl
}
}
- // 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;
- }
- }
+ m_shutdown_state.tick(dtime, this);
}
void Server::Receive()
if (playersao->isDead())
SendDeathscreen(peer_id, false, v3f(0,0,0));
else
- SendPlayerHPOrDie(playersao);
+ SendPlayerHPOrDie(playersao,
+ PlayerHPChangeReason(PlayerHPChangeReason::SET_HP));
// Send Breath
SendPlayerBreath(playersao);
void Server::onMapEditEvent(MapEditEvent *event)
{
- if(m_ignore_map_edit_events)
- return;
- if(m_ignore_map_edit_events_area.contains(event->getArea()))
+ if (m_ignore_map_edit_events_area.contains(event->getArea()))
return;
MapEditEvent *e = event->clone();
m_unsent_map_edit_queue.push(e);
Send(&pkt);
}
-void Server::SendPlayerHPOrDie(PlayerSAO *playersao)
+void Server::SendPlayerHPOrDie(PlayerSAO *playersao, const PlayerHPChangeReason &reason)
{
if (!g_settings->getBool("enable_damage"))
return;
if (is_alive)
SendPlayerHP(peer_id);
else
- DiePlayer(peer_id);
+ DiePlayer(peer_id, reason);
}
void Server::SendHP(session_t peer_id, u16 hp)
{
RemotePlayer *player = m_env->getPlayer(peer_id);
assert(player);
- if(player->getPeerId() == PEER_ID_INEXISTENT)
+ if (player->getPeerId() == PEER_ID_INEXISTENT)
return;
NetworkPacket pkt(TOCLIENT_INVENTORY_FORMSPEC, 0, peer_id);
Send(&pkt);
}
+void Server::SendPlayerFormspecPrepend(session_t peer_id)
+{
+ RemotePlayer *player = m_env->getPlayer(peer_id);
+ assert(player);
+ if (player->getPeerId() == PEER_ID_INEXISTENT)
+ return;
+
+ NetworkPacket pkt(TOCLIENT_FORMSPEC_PREPEND, 0, peer_id);
+ pkt << FORMSPEC_VERSION_STRING + player->formspec_prepend;
+ Send(&pkt);
+}
+
u32 Server::SendActiveObjectRemoveAdd(session_t peer_id, const std::string &datas)
{
NetworkPacket pkt(TOCLIENT_ACTIVE_OBJECT_REMOVE_ADD, datas.size(), peer_id);
&pkt, reliable);
}
-void Server::SendCSMFlavourLimits(session_t peer_id)
+void Server::SendCSMRestrictionFlags(session_t peer_id)
{
- NetworkPacket pkt(TOCLIENT_CSM_FLAVOUR_LIMITS,
- sizeof(m_csm_flavour_limits) + sizeof(m_csm_noderange_limit), peer_id);
- pkt << m_csm_flavour_limits << m_csm_noderange_limit;
+ NetworkPacket pkt(TOCLIENT_CSM_RESTRICTION_FLAGS,
+ sizeof(m_csm_restriction_flags) + sizeof(m_csm_restriction_noderange), peer_id);
+ pkt << m_csm_restriction_flags << m_csm_restriction_noderange;
Send(&pkt);
}
Something random
*/
-void Server::DiePlayer(session_t peer_id)
+void Server::DiePlayer(session_t peer_id, const PlayerHPChangeReason &reason)
{
PlayerSAO *playersao = getPlayerSAO(peer_id);
// In some rare cases this can be NULL -- if the player is disconnected
<< playersao->getPlayer()->getName()
<< " dies" << std::endl;
- playersao->setHP(0);
+ playersao->setHP(0, reason);
+ playersao->clearParentAttachment();
// Trigger scripted stuff
- m_script->on_dieplayer(playersao);
+ m_script->on_dieplayer(playersao, reason);
SendPlayerHP(peer_id);
SendDeathscreen(peer_id, false, v3f(0,0,0));
<< playersao->getPlayer()->getName()
<< " respawns" << std::endl;
- playersao->setHP(playersao->accessObjectProperties()->hp_max);
+ playersao->setHP(playersao->accessObjectProperties()->hp_max,
+ PlayerHPChangeReason(PlayerHPChangeReason::RESPAWN));
playersao->setBreath(playersao->accessObjectProperties()->breath_max);
bool repositioned = m_script->on_respawnplayer(playersao);
PlayerSAO *playersao = player->getPlayerSAO();
assert(playersao);
+ playersao->clearChildAttachments();
+ playersao->clearParentAttachment();
+
// inform connected clients
NetworkPacket notice(TOCLIENT_UPDATE_PLAYER_LIST, 0, PEER_ID_INEXISTENT);
// (u16) 1 + std::string represents a vector serialization representation
void Server::UpdateCrafting(RemotePlayer *player)
{
+ InventoryList *clist = player->inventory.getList("craft");
+ if (!clist || clist->getSize() == 0)
+ return;
+
// Get a preview for crafting
ItemStack preview;
InventoryLocation loc;
std::vector<ItemStack> output_replacements;
getCraftingResult(&player->inventory, preview, output_replacements, false, this);
m_env->getScriptIface()->item_CraftPredict(preview, player->getPlayerSAO(),
- (&player->inventory)->getList("craft"), loc);
+ clist, loc);
- // Put the new preview in
InventoryList *plist = player->inventory.getList("craftpreview");
- sanity_check(plist);
- sanity_check(plist->getSize() >= 1);
- plist->changeItem(0, preview);
+ if (plist && plist->getSize() >= 1) {
+ // Put the new preview in
+ plist->changeItem(0, preview);
+ }
}
void Server::handleChatInterfaceEvent(ChatEvent *evt)
SendPlayerInventoryFormspec(player->getPeerId());
}
+void Server::reportFormspecPrependModified(const std::string &name)
+{
+ RemotePlayer *player = m_env->getPlayer(name.c_str());
+ if (!player)
+ return;
+ SendPlayerFormspecPrepend(player->getPeerId());
+}
+
void Server::setIpBanned(const std::string &ip, const std::string &name)
{
m_banmanager->add(ip, name);
ServerMap *map = (ServerMap*)(&m_env->getMap());
// Fail if no actions to handle
- if(actions.empty()){
+ if (actions.empty()) {
+ assert(log);
log->push_back("Nothing to do.");
return false;
}
return m_nodedef->allocateDummy(name);
}
-MtEventManager *Server::getEventManager()
-{
- return m_event;
-}
-
IWritableItemDefManager *Server::getWritableItemDefManager()
{
return m_itemdef;
void Server::requestShutdown(const std::string &msg, bool reconnect, float delay)
{
- 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;
+ m_shutdown_state.is_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;
+ } else if (delay < 0.0f && m_shutdown_state.isTimerRunning()) {
+ // Negative delay, cancel shutdown if requested
+ m_shutdown_state.reset();
std::wstringstream ws;
ws << L"*** Server shutdown canceled.";
infostream << wide_to_utf8(ws.str()).c_str() << std::endl;
SendChatMessage(PEER_ID_INEXISTENT, ws.str());
+ // m_shutdown_* are already handled, skip.
+ return;
} 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()
+ << duration_to_string(myround(delay)).c_str()
<< ".";
infostream << wide_to_utf8(ws.str()).c_str() << std::endl;
SendChatMessage(PEER_ID_INEXISTENT, ws.str());
}
+
+ m_shutdown_state.trigger(delay, msg, reconnect);
}
PlayerSAO* Server::emergePlayer(const char *name, session_t peer_id, u16 proto_version)
}
server.step(steplen);
- if (server.getShutdownRequested() || kill)
+ if (server.isShutdownRequested() || kill)
break;
/*