#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"
void *ServerThread::run()
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
BEGIN_DEBUG_EXCEPTION_HANDLER
m_server->AsyncRunStep(true);
} 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()));
}
}
- END_DEBUG_EXCEPTION_HANDLER(errorstream)
+ END_DEBUG_EXCEPTION_HANDLER
return NULL;
}
const std::string &path_world,
const SubgameSpec &gamespec,
bool simple_singleplayer_mode,
- bool ipv6
+ bool ipv6,
+ ChatInterface *iface
):
m_path_world(path_world),
m_gamespec(gamespec),
m_clients(&m_con),
m_shutdown_requested(false),
m_shutdown_ask_reconnect(false),
+ m_admin_chat(iface),
m_ignore_map_edit_events(false),
m_ignore_map_edit_events_peer_id(0),
m_next_sound_id(0)
{
m_liquid_transform_timer = 0.0;
m_liquid_transform_every = 1.0;
- m_print_info_timer = 0.0;
m_masterserver_timer = 0.0;
- m_objectdata_timer = 0.0;
m_emergethread_trigger_timer = 0.0;
m_savemap_timer = 0.0;
//lock environment
MutexAutoLock envlock(m_env_mutex);
- // Load mapgen params from Settings
- m_emerge->loadMapgenParams();
-
// Create the Map (loads map_meta.txt, overriding configured mapgen params)
ServerMap *servermap = new ServerMap(path_world, this, m_emerge);
m_script = new GameScripting(this);
std::string script_path = getBuiltinLuaPath() + DIR_DELIM "init.lua";
- std::string error_msg;
- if (!m_script->loadMod(script_path, BUILTIN_MOD_NAME, &error_msg))
- throw ModError("Failed to load and run " + script_path
- + "\nError from Lua:\n" + error_msg);
+ m_script->loadMod(script_path, BUILTIN_MOD_NAME);
// Print mods
infostream << "Server: Loading mods: ";
}
infostream << std::endl;
// Load and run "mod" scripts
- for (std::vector<ModSpec>::iterator i = m_mods.begin();
- i != m_mods.end(); ++i) {
- const ModSpec &mod = *i;
+ for (std::vector<ModSpec>::iterator it = m_mods.begin();
+ it != m_mods.end(); ++it) {
+ const ModSpec &mod = *it;
if (!string_allowed(mod.name, MODNAME_ALLOWED_CHARS)) {
- std::ostringstream err;
- err << "Error loading mod \"" << mod.name
- << "\": mod_name does not follow naming conventions: "
- << "Only chararacters [a-z0-9_] are allowed." << std::endl;
- errorstream << err.str().c_str();
- throw ModError(err.str());
+ throw ModError("Error loading mod \"" + mod.name +
+ "\": Mod name does not follow naming conventions: "
+ "Only chararacters [a-z0-9_] are allowed.");
}
- std::string script_path = mod.path + DIR_DELIM "init.lua";
+ std::string script_path = mod.path + DIR_DELIM + "init.lua";
infostream << " [" << padStringRight(mod.name, 12) << "] [\""
<< script_path << "\"]" << std::endl;
- if (!m_script->loadMod(script_path, mod.name, &error_msg)) {
- errorstream << "Server: Failed to load and run "
- << script_path << std::endl;
- throw ModError("Failed to load and run " + script_path
- + "\nError from Lua:\n" + error_msg);
- }
+ m_script->loadMod(script_path, mod.name);
}
// Read Textures and calculate sha1 sums
// Perform pending node name resolutions
m_nodedef->runNodeResolveCallbacks();
+ // unmap node names for connected nodeboxes
+ m_nodedef->mapNodeboxConnections();
+
// init the recipe hashes to speed up crafting
m_craftdef->initHashes(this);
m_clients.setEnv(m_env);
+ if (!servermap->settings_mgr.makeMapgenParams())
+ FATAL_ERROR("Couldn't create any mapgen type");
+
// Initialize mapgens
- m_emerge->initMapgens();
+ m_emerge->initMapgens(servermap->getMapgenParams());
m_enable_rollback_recording = g_settings->getBool("enable_rollback_recording");
if (m_enable_rollback_recording) {
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;
+ 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();
}
// Add some test ActiveBlockModifiers to environment
add_legacy_abms(m_env, m_nodedef);
m_liquid_transform_every = g_settings->getFloat("liquid_update");
+ m_max_chatmessage_length = g_settings->getU16("chat_message_max_size");
}
Server::~Server()
m_emerge->stopThreads();
// Delete things in the reverse order of creation
- delete m_env;
-
- // N.B. the EmergeManager should be deleted after the Environment since Map
- // depends on EmergeManager to write its current params to the map meta
delete m_emerge;
+ delete m_env;
delete m_rollback;
delete m_banmanager;
delete m_event;
void Server::start(Address bind_addr)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
m_bind_addr = bind_addr;
void Server::stop()
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
infostream<<"Server: Stopping and waiting threads"<<std::endl;
void Server::step(float dtime)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
// Limit a bit
- if(dtime > 2.0)
+ if (dtime > 2.0)
dtime = 2.0;
{
MutexAutoLock lock(m_step_dtime_mutex);
}
// Throw if fatal error occurred in thread
std::string async_err = m_async_fatal_error.get();
- if(async_err != "") {
- if (m_simple_singleplayer_mode) {
- throw ServerError(async_err);
- }
- else {
+ if (!async_err.empty()) {
+ if (!m_simple_singleplayer_mode) {
m_env->kickAllPlayers(SERVER_ACCESSDENIED_CRASH,
g_settings->get("kick_msg_crash"),
g_settings->getBool("ask_reconnect_on_crash"));
- errorstream << "UNRECOVERABLE error occurred. Stopping server. "
- << "Please fix the following error:" << std::endl
- << async_err << std::endl;
- FATAL_ERROR(async_err.c_str());
}
+ throw ServerError("AsyncErr: " + async_err);
}
}
void Server::AsyncRunStep(bool initial_step)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
g_profiler->add("Server::AsyncRunStep (num)", 1);
U32_MAX);
}
+ /*
+ Listen to the admin chat, if available
+ */
+ if (m_admin_chat) {
+ if (!m_admin_chat->command_queue.empty()) {
+ MutexAutoLock lock(m_env_mutex);
+ while (!m_admin_chat->command_queue.empty()) {
+ ChatEvent *evt = m_admin_chat->command_queue.pop_frontNoEx();
+ handleChatInterfaceEvent(evt);
+ delete evt;
+ }
+ }
+ m_admin_chat->outgoing_queue.push_back(
+ new ChatEventTimeInfo(m_env->getGameTime(), m_env->getTimeOfDay()));
+ }
+
/*
Do background stuff
*/
m_env->getGameTime(),
m_lag,
m_gamespec.id,
- m_emerge->params.mg_name,
+ Mapgen::getMapgenName(m_emerge->mgparams->mgtype),
m_mods);
counter = 0.01;
}
MutexAutoLock envlock(m_env_mutex);
m_clients.lock();
- std::map<u16, RemoteClient*> clients = m_clients.getClientList();
+ UNORDERED_MAP<u16, RemoteClient*> clients = m_clients.getClientList();
ScopeProfiler sp(g_profiler, "Server: checking added and deleted objs");
// Radius inside which objects are active
- s16 radius = g_settings->getS16("active_object_send_range_blocks");
- s16 player_radius = g_settings->getS16("player_transfer_distance");
-
- if (player_radius == 0 && g_settings->exists("unlimited_player_transfer_distance") &&
- !g_settings->getBool("unlimited_player_transfer_distance"))
+ static const s16 radius =
+ g_settings->getS16("active_object_send_range_blocks") * MAP_BLOCKSIZE;
+
+ // Radius inside which players are active
+ static const bool is_transfer_limited =
+ g_settings->exists("unlimited_player_transfer_distance") &&
+ !g_settings->getBool("unlimited_player_transfer_distance");
+ static const s16 player_transfer_dist = g_settings->getS16("player_transfer_distance") * MAP_BLOCKSIZE;
+ s16 player_radius = player_transfer_dist;
+ if (player_radius == 0 && is_transfer_limited)
player_radius = radius;
- radius *= MAP_BLOCKSIZE;
- player_radius *= MAP_BLOCKSIZE;
-
- for (std::map<u16, RemoteClient*>::iterator
- i = clients.begin();
+ for (UNORDERED_MAP<u16, RemoteClient*>::iterator i = clients.begin();
i != clients.end(); ++i) {
RemoteClient *client = i->second;
if (client->getState() < CS_DefinitionsSent)
continue;
- Player *player = m_env->getPlayer(client->peer_id);
- if(player == NULL) {
+ RemotePlayer *player = m_env->getPlayer(client->peer_id);
+ if (player == NULL) {
// This can happen if the client timeouts somehow
- /*infostream<<"WARNING: "<<__FUNCTION_NAME<<": Client "
+ /*warningstream<<FUNCTION_NAME<<": Client "
<<client->peer_id
<<" has no associated player"<<std::endl;*/
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
// Get object type
u8 type = ACTIVEOBJECT_TYPE_INVALID;
if(obj == NULL)
- infostream<<"WARNING: "<<__FUNCTION_NAME
+ warningstream<<FUNCTION_NAME
<<": NULL object"<<std::endl;
else
type = obj->getSendType();
// Key = object id
// Value = data sent by object
-
std::map<u16, std::vector<ActiveObjectMessage>* > buffered_messages;
+
UNORDERED_MAP<u16, std::vector<ActiveObjectMessage>* > buffered_messages;
// Get active object messages from environment
for(;;) {
break;
std::vector<ActiveObjectMessage>* message_list = NULL;
-
std::map<u16, std::vector<ActiveObjectMessage>* >::iterator n;
+
UNORDERED_MAP<u16, std::vector<ActiveObjectMessage>* >::iterator n;
n = buffered_messages.find(aom.id);
if (n == buffered_messages.end()) {
message_list = new std::vector<ActiveObjectMessage>;
}
m_clients.lock();
- std::map<u16, RemoteClient*> clients = m_clients.getClientList();
+ UNORDERED_MAP<u16, RemoteClient*> clients = m_clients.getClientList();
// Route data to every client
- for (std::map<u16, RemoteClient*>::iterator
- i = clients.begin();
+ for (UNORDERED_MAP<u16, RemoteClient*>::iterator i = clients.begin();
i != clients.end(); ++i) {
RemoteClient *client = i->second;
std::string reliable_data;
std::string unreliable_data;
// Go through all objects in message buffer
- for (
std::map<u16, std::vector<ActiveObjectMessage>* >::iterator
+ for (
UNORDERED_MAP<u16, std::vector<ActiveObjectMessage>* >::iterator
j = buffered_messages.begin();
j != buffered_messages.end(); ++j) {
// If object is not known by client, skip it
m_clients.unlock();
// Clear buffered_messages
- for
(std::map<u16, std::vector<ActiveObjectMessage>* >::iterator
+ for
(UNORDERED_MAP<u16, std::vector<ActiveObjectMessage>* >::iterator
i = buffered_messages.begin();
i != buffered_messages.end(); ++i) {
delete i->second;
break;
default:
prof.add("unknown", 1);
- infostream << "WARNING: Server: Unknown MapEditEvent "
+ warningstream << "Server: Unknown MapEditEvent "
<< ((u32)event->type) << std::endl;
break;
}
{
float &counter = m_emergethread_trigger_timer;
counter += dtime;
- if(counter >= 2.0)
- {
+ if (counter >= 2.0) {
counter = 0.0;
m_emerge->startThreads();
{
float &counter = m_savemap_timer;
counter += dtime;
- if(counter >= g_settings->getFloat("server_map_save_interval"))
- {
+ static const float save_interval =
+ g_settings->getFloat("server_map_save_interval");
+ if (counter >= save_interval) {
counter = 0.0;
MutexAutoLock lock(m_env_mutex);
void Server::Receive()
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
SharedBuffer<u8> data;
u16 peer_id;
try {
}
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) {
// Send information about server to player in chat
SendChatMessage(peer_id, getStatusString());
-
- // Send information about joining in chat
- {
- std::wstring name = L"unknown";
- Player *player = m_env->getPlayer(peer_id);
- if(player != NULL)
- name = narrow_to_wide(player->getName());
-
- std::wstring message;
- message += L"*** ";
- message += name;
- message += L" joined the game.";
- SendChatMessage(PEER_ID_INEXISTENT,message);
- }
}
Address addr = getPeerAddress(player->peer_id);
std::string ip_str = addr.serializeString();
Print out action
*/
{
- std::vector<std::string> names = m_clients.getPlayerNames();
+ const std::vector<std::string> &names = m_clients.getPlayerNames();
- actionstream<<player->getName() <<" joins game. List of players: ";
+ actionstream << player->getName() << " joins game. List of players: ";
- for (std::vector<std::string>::iterator i = names.begin();
+ for (std::vector<std::string>::const_iterator i = names.begin();
i != names.end(); ++i) {
actionstream << *i << " ";
}
void Server::ProcessData(NetworkPacket *pkt)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
// Environment is locked first.
MutexAutoLock envlock(m_env_mutex);
break;
case InventoryLocation::PLAYER:
{
- Player *player = m_env->getPlayer(loc.name.c_str());
+ RemotePlayer *player = dynamic_cast<RemotePlayer *>(m_env->getPlayer(loc.name.c_str()));
if(!player)
return NULL;
PlayerSAO *playersao = player->getPlayerSAO();
if (!playerSend)
return;
- Player *player = m_env->getPlayer(loc.name.c_str());
- if(!player)
+ RemotePlayer *player =
+ dynamic_cast<RemotePlayer *>(m_env->getPlayer(loc.name.c_str()));
+
+ if (!player)
return;
+
PlayerSAO *playersao = player->getPlayerSAO();
if(!playersao)
return;
void Server::peerAdded(con::Peer *peer)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
verbosestream<<"Server::peerAdded(): peer->id="
<<peer->id<<std::endl;
void Server::deletingPeer(con::Peer *peer, bool timeout)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
verbosestream<<"Server::deletingPeer(): peer->id="
<<peer->id<<", timeout="<<timeout<<std::endl;
}
}
+void Server::printToConsoleOnly(const std::string &text)
+{
+ if (m_admin_chat) {
+ m_admin_chat->outgoing_queue.push_back(
+ new ChatEventChat("", utf8_to_wide(text)));
+ } else {
+ std::cout << text << std::endl;
+ }
+}
+
void Server::Send(NetworkPacket* pkt)
{
m_clients.send(pkt->getPeerId(),
void Server::SendMovement(u16 peer_id)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
std::ostringstream os(std::ios_base::binary);
NetworkPacket pkt(TOCLIENT_MOVEMENT, 12 * sizeof(float), peer_id);
void Server::SendHP(u16 peer_id, u8 hp)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
NetworkPacket pkt(TOCLIENT_HP, 1, peer_id);
pkt << hp;
void Server::SendBreath(u16 peer_id, u16 breath)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
NetworkPacket pkt(TOCLIENT_BREATH, 2, peer_id);
pkt << (u16) breath;
void Server::SendAccessDenied_Legacy(u16 peer_id,const std::wstring &reason)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
NetworkPacket pkt(TOCLIENT_ACCESS_DENIED_LEGACY, 0, peer_id);
pkt << reason;
void Server::SendDeathscreen(u16 peer_id,bool set_camera_point_target,
v3f camera_point_target)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
NetworkPacket pkt(TOCLIENT_DEATHSCREEN, 1 + sizeof(v3f), peer_id);
pkt << set_camera_point_target << camera_point_target;
void Server::SendItemDef(u16 peer_id,
IItemDefManager *itemdef, u16 protocol_version)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
NetworkPacket pkt(TOCLIENT_ITEMDEF, 0, peer_id);
void Server::SendNodeDef(u16 peer_id,
INodeDefManager *nodedef, u16 protocol_version)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
NetworkPacket pkt(TOCLIENT_NODEDEF, 0, peer_id);
void Server::SendInventory(PlayerSAO* playerSAO)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
UpdateCrafting(playerSAO->getPlayer());
void Server::SendChatMessage(u16 peer_id, const std::wstring &message)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
NetworkPacket pkt(TOCLIENT_CHAT_MESSAGE, 0, peer_id);
pkt << message;
void Server::SendShowFormspecMessage(u16 peer_id, const std::string &formspec,
const std::string &formname)
{
- DSTACK(__FUNCTION_NAME);
+ 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 vertical, std::string texture)
+ bool collision_removal,
+ bool vertical, const std::string &texture,
+ const struct TileAnimationParams &animation, u8 glow)
{
- DSTACK(__FUNCTION_NAME);
+ 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);
<< size << collisiondetection;
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 vertical, std::string texture, u32 id)
+ float minsize, float maxsize, bool collisiondetection, bool collision_removal,
+ u16 attached_id, bool vertical, const std::string &texture, u32 id,
+ const struct TileAnimationParams &animation, u8 glow)
{
- DSTACK(__FUNCTION_NAME);
+ 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.putLongString(texture);
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)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
NetworkPacket pkt(TOCLIENT_DELETE_PARTICLESPAWNER_LEGACY, 2, peer_id);
void Server::SendTimeOfDay(u16 peer_id, u16 time, f32 time_speed)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
NetworkPacket pkt(TOCLIENT_TIME_OF_DAY, 0, peer_id);
pkt << time << time_speed;
void Server::SendPlayerHP(u16 peer_id)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
PlayerSAO *playersao = getPlayerSAO(peer_id);
- // In some rare case, if the player is disconnected
+ // In some rare case if the player is disconnected
// while Lua call l_punch, for example, this can be NULL
if (!playersao)
return;
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);
+ DSTACK(FUNCTION_NAME);
+ 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);
- Player *player = m_env->getPlayer(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;
}
}
void Server::SendPlayerPrivileges(u16 peer_id)
{
- Player *player = m_env->getPlayer(peer_id);
+ RemotePlayer *player = m_env->getPlayer(peer_id);
assert(player);
if(player->peer_id == PEER_ID_INEXISTENT)
return;
void Server::SendPlayerInventoryFormspec(u16 peer_id)
{
- Player *player = m_env->getPlayer(peer_id);
+ RemotePlayer *player = m_env->getPlayer(peer_id);
assert(player);
if(player->peer_id == PEER_ID_INEXISTENT)
return;
std::vector<u16> dst_clients;
if(params.to_player != "")
{
- Player *player = m_env->getPlayer(params.to_player.c_str());
+ RemotePlayer *player = m_env->getPlayer(params.to_player.c_str());
if(!player){
infostream<<"Server::playSound: Player \""<<params.to_player
<<"\" not found"<<std::endl;
else {
std::vector<u16> clients = m_clients.getClientIDs();
- for(std::vector<u16>::iterator
- i = clients.begin(); i != clients.end(); ++i) {
- Player *player = m_env->getPlayer(*i);
- if(!player)
+ for (std::vector<u16>::iterator i = clients.begin(); i != clients.end(); ++i) {
+ RemotePlayer *player = m_env->getPlayer(*i);
+ if (!player)
continue;
- if(pos_exists) {
- if(player->getPosition().getDistanceFrom(pos) >
+ PlayerSAO *sao = player->getPlayerSAO();
+ if (!sao)
+ continue;
+
+ if (pos_exists) {
+ if(sao->getBasePosition().getDistanceFrom(pos) >
params.max_hear_distance)
continue;
}
void Server::stopSound(s32 handle)
{
// Get sound reference
- std::map<s32, ServerPlayingSound>::iterator i =
- m_playing_sounds.find(handle);
- if(i == m_playing_sounds.end())
+ UNORDERED_MAP<s32, ServerPlayingSound>::iterator i = m_playing_sounds.find(handle);
+ if (i == m_playing_sounds.end())
return;
ServerPlayingSound &psound = i->second;
NetworkPacket pkt(TOCLIENT_STOP_SOUND, 4);
pkt << handle;
- for(std::set<u16>::iterator i = psound.clients.begin();
+ for (UNORDERED_SET<u16>::iterator i = psound.clients.begin();
i != psound.clients.end(); ++i) {
// Send as reliable
m_clients.send(*i, 0, &pkt, true);
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(Player *player = m_env->getPlayer(*i)) {
+ 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(Player *player = m_env->getPlayer(*i)) {
+ 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;
void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto_version)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
v3s16 p = block->getPos();
void Server::SendBlocks(float dtime)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
MutexAutoLock envlock(m_env_mutex);
//TODO check if one big lock could be faster then multiple small ones
void Server::fillMediaCache()
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
infostream<<"Server: Calculating media file checksums"<<std::endl;
void Server::sendMediaAnnouncement(u16 peer_id)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
verbosestream << "Server: Announcing files to id(" << peer_id << ")"
<< std::endl;
NetworkPacket pkt(TOCLIENT_ANNOUNCE_MEDIA, 0, peer_id);
pkt << (u16) m_media.size();
- for (std::map<std::string, MediaInfo>::iterator i = m_media.begin();
+ for (UNORDERED_MAP<std::string, MediaInfo>::iterator i = m_media.begin();
i != m_media.end(); ++i) {
pkt << i->first << i->second.sha1_digest;
}
void Server::sendRequestedMedia(u16 peer_id,
const std::vector<std::string> &tosend)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
verbosestream<<"Server::sendRequestedMedia(): "
<<"Sending files to client"<<std::endl;
i != tosend.end(); ++i) {
const std::string &name = *i;
- if(m_media.find(name) == m_media.end()) {
+ if (m_media.find(name) == m_media.end()) {
errorstream<<"Server::sendRequestedMedia(): Client asked for "
<<"unknown file \""<<(name)<<"\""<<std::endl;
continue;
void Server::sendDetachedInventory(const std::string &name, u16 peer_id)
{
if(m_detached_inventories.count(name) == 0) {
- errorstream<<__FUNCTION_NAME<<": \""<<name<<"\" not found"<<std::endl;
+ errorstream<<FUNCTION_NAME<<": \""<<name<<"\" not found"<<std::endl;
return;
}
Inventory *inv = m_detached_inventories[name];
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);
}
}
void Server::sendDetachedInventories(u16 peer_id)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
for(std::map<std::string, Inventory*>::iterator
i = m_detached_inventories.begin();
void Server::DiePlayer(u16 peer_id)
{
- DSTACK(__FUNCTION_NAME);
-
+ DSTACK(FUNCTION_NAME);
PlayerSAO *playersao = getPlayerSAO(peer_id);
- assert(playersao);
+ // In some rare cases this can be NULL -- if the player is disconnected
+ // when a Lua function modifies l_punch, for example
+ if (!playersao)
+ return;
infostream << "Server::DiePlayer(): Player "
<< playersao->getPlayer()->getName()
void Server::RespawnPlayer(u16 peer_id)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
PlayerSAO *playersao = getPlayerSAO(peer_id);
assert(playersao);
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);
}
void Server::DenySudoAccess(u16 peer_id)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
NetworkPacket pkt(TOCLIENT_DENY_SUDO_MODE, 0, peer_id);
Send(&pkt);
const std::string &str_reason, bool reconnect)
{
if (proto_ver >= 25) {
- SendAccessDenied(peer_id, reason, str_reason);
+ SendAccessDenied(peer_id, reason, str_reason, reconnect);
} else {
std::wstring wreason = utf8_to_wide(
reason == SERVER_ACCESSDENIED_CUSTOM_STRING ? str_reason :
void Server::DenyAccess(u16 peer_id, AccessDeniedCode reason, const std::string &custom_reason)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
SendAccessDenied(peer_id, reason, custom_reason);
m_clients.event(peer_id, CSE_SetDenied);
// the minimum version for MT users, maybe in 1 year
void Server::DenyAccess_Legacy(u16 peer_id, const std::wstring &reason)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
SendAccessDenied_Legacy(peer_id, reason);
m_clients.event(peer_id, CSE_SetDenied);
void Server::acceptAuth(u16 peer_id, bool forSudoMode)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
if (!forSudoMode) {
RemoteClient* client = getClient(peer_id, CS_Invalid);
void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
std::wstring message;
{
/*
Clear references to playing sounds
*/
- for(std::map<s32, ServerPlayingSound>::iterator
- i = m_playing_sounds.begin();
- i != m_playing_sounds.end();)
- {
+ for (UNORDERED_MAP<s32, ServerPlayingSound>::iterator
+ i = m_playing_sounds.begin(); i != m_playing_sounds.end();) {
ServerPlayingSound &psound = i->second;
psound.clients.erase(peer_id);
- if(psound.clients.empty())
+ if (psound.clients.empty())
m_playing_sounds.erase(i++);
else
++i;
}
- Player *player = m_env->getPlayer(peer_id);
-
- // Collect information about leaving in chat
- {
- if(player != NULL && reason != CDR_DENY)
- {
- std::wstring name = narrow_to_wide(player->getName());
- message += L"*** ";
- message += name;
- message += L" left the game.";
- if(reason == CDR_TIMEOUT)
- message += L" (timed out)";
- }
- }
+ RemotePlayer *player = m_env->getPlayer(peer_id);
/* Run scripts and remove from environment */
- {
- if(player != NULL)
- {
- PlayerSAO *playersao = player->getPlayerSAO();
- assert(playersao);
+ if (player != NULL) {
+ PlayerSAO *playersao = player->getPlayerSAO();
+ assert(playersao);
- m_script->on_leaveplayer(playersao);
+ m_script->on_leaveplayer(playersao, reason == CDR_TIMEOUT);
- playersao->disconnected();
- }
+ playersao->disconnected();
}
/*
for(std::vector<u16>::iterator i = clients.begin();
i != clients.end(); ++i) {
// Get player
- Player *player = m_env->getPlayer(*i);
- if(!player)
+ RemotePlayer *player = m_env->getPlayer(*i);
+ if (!player)
continue;
// Get name of player
os << player->getName() << " ";
}
- actionstream << player->getName() << " "
+ std::string name = player->getName();
+ actionstream << name << " "
<< (reason == CDR_TIMEOUT ? "times out." : "leaves game.")
<< " List of players: " << os.str() << std::endl;
+ if (m_admin_chat)
+ m_admin_chat->outgoing_queue.push_back(
+ new ChatEventNick(CET_NICK_REMOVE, name));
}
}
{
SendChatMessage(PEER_ID_INEXISTENT,message);
}
-void Server::UpdateCrafting(Player* player)
+void Server::UpdateCrafting(RemotePlayer *player)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
// Get a preview for crafting
ItemStack preview;
loc.setPlayer(player->getName());
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);
+ m_env->getScriptIface()->item_CraftPredict(preview, player->getPlayerSAO(),
+ (&player->inventory)->getList("craft"), loc);
// Put the new preview in
InventoryList *plist = player->inventory.getList("craftpreview");
plist->changeItem(0, preview);
}
+void Server::handleChatInterfaceEvent(ChatEvent *evt)
+{
+ if (evt->type == CET_NICK_ADD) {
+ // The terminal informed us of its nick choice
+ m_admin_nick = ((ChatEventNick *)evt)->nick;
+ if (!m_script->getAuth(m_admin_nick, NULL, NULL)) {
+ errorstream << "You haven't set up an account." << std::endl
+ << "Please log in using the client as '"
+ << m_admin_nick << "' with a secure password." << std::endl
+ << "Until then, you can't execute admin tasks via the console," << std::endl
+ << "and everybody can claim the user account instead of you," << std::endl
+ << "giving them full control over this server." << std::endl;
+ }
+ } else {
+ assert(evt->type == CET_CHAT);
+ handleAdminChat((ChatEventChat *)evt);
+ }
+}
+
+std::wstring Server::handleChat(const std::string &name, const std::wstring &wname,
+ const std::wstring &wmessage, bool check_shout_priv, RemotePlayer *player)
+{
+ // If something goes wrong, this player is to blame
+ 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.";
+ return ws.str();
+ }
+ case RPLAYER_CHATRESULT_KICK:
+ 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.");
+ }
+ }
+
+ 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";
+ }
+
+ // 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);
+ 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;
+ }
+ }
+
+ /*
+ Tell calling method to send the message to sender
+ */
+ if (!broadcast_line) {
+ return line;
+ } else {
+ /*
+ Send the message to others
+ */
+ actionstream << "CHAT: " << wide_to_narrow(line) << std::endl;
+
+ 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->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)
+ SendChatMessage(cid, line);
+ }
+ }
+ return L"";
+}
+
+void Server::handleAdminChat(const ChatEventChat *evt)
+{
+ std::string name = evt->nick;
+ std::wstring wname = utf8_to_wide(name);
+ std::wstring wmessage = evt->evt_msg;
+
+ std::wstring answer = handleChat(name, wname, wmessage);
+
+ // If asked to send answer to sender
+ if (!answer.empty()) {
+ m_admin_chat->outgoing_queue.push_back(new ChatEventChat("", answer));
+ }
+}
+
RemoteClient* Server::getClient(u16 peer_id, ClientState state_min)
{
RemoteClient *client = getClientNoEx(peer_id,state_min);
std::string Server::getPlayerName(u16 peer_id)
{
- Player *player = m_env->getPlayer(peer_id);
- if(player == NULL)
+ RemotePlayer *player = m_env->getPlayer(peer_id);
+ if (player == NULL)
return "[id="+itos(peer_id)+"]";
return player->getName();
}
PlayerSAO* Server::getPlayerSAO(u16 peer_id)
{
- Player *player = m_env->getPlayer(peer_id);
- if(player == NULL)
+ RemotePlayer *player = m_env->getPlayer(peer_id);
+ if (player == NULL)
return NULL;
return player->getPlayerSAO();
}
bool first = true;
os<<L", clients={";
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) {
// Get player
- Player *player = m_env->getPlayer(*i);
+ RemotePlayer *player = m_env->getPlayer(*i);
// Get name of player
std::wstring name = L"unknown";
- if(player != NULL)
+ if (player != NULL)
name = narrow_to_wide(player->getName());
// Add name to information string
if(!first)
std::vector<u16> clients = m_clients.getClientIDs();
for(std::vector<u16>::iterator i = clients.begin();
i != clients.end(); ++i) {
- Player *player = m_env->getPlayer(*i);
+ RemotePlayer *player = m_env->getPlayer(*i);
reportPrivsModified(player->getName());
}
} else {
- Player *player = m_env->getPlayer(name.c_str());
- if(!player)
+ RemotePlayer *player = m_env->getPlayer(name.c_str());
+ if (!player)
return;
SendPlayerPrivileges(player->peer_id);
PlayerSAO *sao = player->getPlayerSAO();
void Server::reportInventoryFormspecModified(const std::string &name)
{
- Player *player = m_env->getPlayer(name.c_str());
- if(!player)
+ RemotePlayer *player = m_env->getPlayer(name.c_str());
+ if (!player)
return;
SendPlayerInventoryFormspec(player->peer_id);
}
if (!m_env)
return;
- Player *player = m_env->getPlayer(name);
- if (!player)
+ if (m_admin_nick == name && !m_admin_nick.empty()) {
+ m_admin_chat->outgoing_queue.push_back(new ChatEventChat("", msg));
+ }
+
+ RemotePlayer *player = m_env->getPlayer(name);
+ if (!player) {
return;
+ }
if (player->peer_id == PEER_ID_INEXISTENT)
return;
if (!m_env)
return false;
- Player *player = m_env->getPlayer(playername);
+ RemotePlayer *player = m_env->getPlayer(playername);
if (!player)
return false;
return true;
}
-u32 Server::hudAdd(Player *player, HudElement *form)
+u32 Server::hudAdd(RemotePlayer *player, HudElement *form)
{
if (!player)
return -1;
return id;
}
-bool Server::hudRemove(Player *player, u32 id) {
+bool Server::hudRemove(RemotePlayer *player, u32 id) {
if (!player)
return false;
return true;
}
-bool Server::hudChange(Player *player, u32 id, HudElementStat stat, void *data)
+bool Server::hudChange(RemotePlayer *player, u32 id, HudElementStat stat, void *data)
{
if (!player)
return false;
return true;
}
-bool Server::hudSetFlags(Player *player, u32 flags, u32 mask)
+bool Server::hudSetFlags(RemotePlayer *player, u32 flags, u32 mask)
{
if (!player)
return false;
SendHUDSetFlags(player->peer_id, flags, mask);
- player->hud_flags = flags;
+ player->hud_flags &= ~mask;
+ player->hud_flags |= flags;
PlayerSAO* playersao = player->getPlayerSAO();
return true;
}
-bool Server::hudSetHotbarItemcount(Player *player, s32 hotbar_itemcount)
+bool Server::hudSetHotbarItemcount(RemotePlayer *player, s32 hotbar_itemcount)
{
if (!player)
return false;
+
if (hotbar_itemcount <= 0 || hotbar_itemcount > HUD_HOTBAR_ITEMCOUNT_MAX)
return false;
return true;
}
-s32 Server::hudGetHotbarItemcount(Player *player)
-{
- if (!player)
- return 0;
- return player->getHotbarItemcount();
-}
-
-void Server::hudSetHotbarImage(Player *player, std::string name)
+void Server::hudSetHotbarImage(RemotePlayer *player, std::string name)
{
if (!player)
return;
SendHUDSetParam(player->peer_id, HUD_PARAM_HOTBAR_IMAGE, name);
}
-std::string Server::hudGetHotbarImage(Player *player)
+std::string Server::hudGetHotbarImage(RemotePlayer *player)
{
if (!player)
return "";
return player->getHotbarImage();
}
-void Server::hudSetHotbarSelectedImage(Player *player, std::string name)
+void Server::hudSetHotbarSelectedImage(RemotePlayer *player, std::string name)
{
if (!player)
return;
SendHUDSetParam(player->peer_id, HUD_PARAM_HOTBAR_SELECTED_IMAGE, name);
}
-std::string Server::hudGetHotbarSelectedImage(Player *player)
-{
- if (!player)
- return "";
-
- return player->getHotbarSelectedImage();
-}
-
-bool Server::setLocalPlayerAnimations(Player *player,
- v2s32 animation_frames[4], f32 frame_speed)
+bool Server::setLocalPlayerAnimations(RemotePlayer *player,
+ v2s32 animation_frames[4], f32 frame_speed)
{
if (!player)
return false;
return true;
}
-bool Server::setPlayerEyeOffset(Player *player, v3f first, v3f third)
+bool Server::setPlayerEyeOffset(RemotePlayer *player, v3f first, v3f third)
{
if (!player)
return false;
return true;
}
-bool Server::setSky(Player *player, const video::SColor &bgcolor,
+bool Server::setSky(RemotePlayer *player, const video::SColor &bgcolor,
const std::string &type, const std::vector<std::string> ¶ms)
{
if (!player)
return true;
}
-bool Server::overrideDayNightRatio(Player *player, bool do_override,
+bool Server::overrideDayNightRatio(RemotePlayer *player, bool do_override,
float ratio)
{
if (!player)
void Server::spawnParticle(const std::string &playername, v3f pos,
v3f velocity, v3f acceleration,
float expirationtime, float size, bool
- collisiondetection, bool vertical, const std::string &texture)
+ collisiondetection, bool collision_removal,
+ 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 != "") {
- Player* player = m_env->getPlayer(playername.c_str());
+ 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,
- expirationtime, size, collisiondetection, vertical, texture);
+ SendSpawnParticle(peer_id, proto_ver, pos, velocity, acceleration,
+ expirationtime, size, collisiondetection,
+ 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 vertical, const std::string &texture,
- const std::string &playername)
+ bool collisiondetection, bool collision_removal,
+ 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 != "") {
- Player* player = m_env->getPlayer(playername.c_str());
+ RemotePlayer *player = m_env->getPlayer(playername.c_str());
if (!player)
return -1;
peer_id = player->peer_id;
+ proto_ver = player->protocol_version;
}
- u32 id = 0;
- for(;;) // look for unused particlespawner id
- {
- id++;
- if (std::find(m_particlespawner_ids.begin(),
- m_particlespawner_ids.end(), id)
- == m_particlespawner_ids.end())
- {
- m_particlespawner_ids.push_back(id);
- break;
- }
- }
+ 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, amount, spawntime,
+ SendAddParticleSpawner(peer_id, proto_ver, amount, spawntime,
minpos, maxpos, minvel, maxvel, minacc, maxacc,
minexptime, maxexptime, minsize, maxsize,
- collisiondetection, vertical, texture, id);
+ collisiondetection, collision_removal, attached_id, vertical,
+ texture, id, animation, glow);
return id;
}
u16 peer_id = PEER_ID_INEXISTENT;
if (playername != "") {
- Player* player = m_env->getPlayer(playername.c_str());
+ RemotePlayer *player = m_env->getPlayer(playername.c_str());
if (!player)
return;
peer_id = player->peer_id;
}
- m_particlespawner_ids.erase(
- std::remove(m_particlespawner_ids.begin(),
- m_particlespawner_ids.end(), id),
- m_particlespawner_ids.end());
+ m_env->deleteParticleSpawner(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 nodeposf * BS;
}
- s16 water_level = map.getWaterLevel();
-
bool is_good = false;
// Try to find a good place a few times
- for(s32 i = 0; i < 1000 && !is_good; i++) {
+ for(s32 i = 0; i < 4000 && !is_good; i++) {
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)));
- // Get ground height at point
- s16 groundheight = map.findGroundLevel(nodepos2d);
- if (groundheight <= water_level) // Don't go underwater
- continue;
- if (groundheight > water_level + 6) // Don't go to high places
+ // Get spawn level at point
+ s16 spawn_level = m_emerge->getSpawnLevelAtPoint(nodepos2d);
+ // Continue if MAX_MAP_GENERATION_LIMIT was returned by
+ // the mapgen to signify an unsuitable spawn position
+ if (spawn_level == MAX_MAP_GENERATION_LIMIT)
continue;
- v3s16 nodepos(nodepos2d.X, groundheight, nodepos2d.Y);
+ v3s16 nodepos(nodepos2d.X, spawn_level, nodepos2d.Y);
s32 air_count = 0;
for (s32 i = 0; i < 10; i++) {
/*
Try to get an existing player
*/
- RemotePlayer *player = static_cast<RemotePlayer*>(m_env->getPlayer(name));
+ RemotePlayer *player = m_env->getPlayer(name);
// If player is already connected, cancel
- if(player != NULL && player->peer_id != 0)
- {
+ if (player != NULL && player->peer_id != 0) {
infostream<<"emergePlayer(): Player already connected"<<std::endl;
return NULL;
}
/*
If player with the wanted peer_id already exists, cancel.
*/
- if(m_env->getPlayer(peer_id) != NULL)
- {
+ if (m_env->getPlayer(peer_id) != NULL) {
infostream<<"emergePlayer(): Player with wrong name but same"
" peer_id already exists"<<std::endl;
return NULL;
}
- // Load player if it isn't already loaded
- if (!player) {
- player = static_cast<RemotePlayer*>(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) {
newplayer = true;
- player = new RemotePlayer(this, name);
+ player = new RemotePlayer(name, this->idef());
// 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;
void dedicated_server_loop(Server &server, bool &kill)
{
- DSTACK(__FUNCTION_NAME);
+ DSTACK(FUNCTION_NAME);
verbosestream<<"dedicated_server_loop()"<<std::endl;
IntervalLimiter m_profiler_interval;
- for(;;)
- {
- float steplen = g_settings->getFloat("dedicated_server_step");
+ static const float steplen = g_settings->getFloat("dedicated_server_step");
+ static const float profiler_print_interval =
+ g_settings->getFloat("profiler_print_interval");
+
+ for(;;) {
// This is kind of a hack but can be done like this
// because server.step() is very light
{
/*
Profiler
*/
- float profiler_print_interval =
- g_settings->getFloat("profiler_print_interval");
- if(profiler_print_interval != 0)
- {
+ if (profiler_print_interval != 0) {
if(m_profiler_interval.step(steplen, profiler_print_interval))
{
infostream<<"Profiler:"<<std::endl;
projects / dragonfireclient.git / blobdiff