#include <iostream>
#include <queue>
#include <algorithm>
+#include "network/connection.h"
#include "network/networkprotocol.h"
#include "network/serveropcodes.h"
#include "ban.h"
#include "util/hex.h"
#include "database.h"
#include "chatmessage.h"
+#include "chat_interface.h"
+#include "remoteplayer.h"
class ClientNotFoundException : public BaseException
{
while (!stopRequested()) {
try {
- //TimeTaker timer("AsyncRunStep() + Receive()");
-
m_server->AsyncRunStep();
m_server->Receive();
END_DEBUG_EXCEPTION_HANDLER
- return NULL;
+ return nullptr;
}
v3f ServerSoundParams::getPos(ServerEnvironment *env, bool *pos_exists) const
m_simple_singleplayer_mode(simple_singleplayer_mode),
m_dedicated(dedicated),
m_async_fatal_error(""),
- m_con(PROTOCOL_ID,
+ m_con(std::make_shared<con::Connection>(PROTOCOL_ID,
512,
CONNECTION_TIMEOUT,
ipv6,
- this),
+ this)),
m_itemdef(createItemDefManager()),
m_nodedef(createNodeDefManager()),
m_craftdef(createCraftDefManager()),
m_event(new EventManager()),
m_uptime(0),
- m_clients(&m_con),
+ m_clients(m_con),
m_admin_chat(iface)
{
m_lag = g_settings->getFloat("dedicated_server_step");
- if(path_world == "")
+ if (path_world.empty())
throw ServerError("Supplied empty world path");
if(!gamespec.isValid())
// Apply texture overrides from texturepack/override.txt
std::string texture_path = g_settings->get("texture_path");
- if (texture_path != "" && fs::IsDir(texture_path))
+ if (!texture_path.empty() && fs::IsDir(texture_path))
m_nodedef->applyTextureOverrides(texture_path + DIR_DELIM + "override.txt");
m_nodedef->setNodeRegistrationStatus(true);
reconnect = m_shutdown_ask_reconnect;
kick_msg = m_shutdown_msg;
}
- if (kick_msg == "") {
+ if (kick_msg.empty()) {
kick_msg = g_settings->get("kick_msg_shutdown");
}
m_env->kickAllPlayers(SERVER_ACCESSDENIED_SHUTDOWN,
delete m_script;
// Delete detached inventories
- for (std::map<std::string, Inventory*>::iterator
- i = m_detached_inventories.begin();
- i != m_detached_inventories.end(); ++i) {
- delete i->second;
+ for (auto &detached_inventory : m_detached_inventories) {
+ delete detached_inventory.second;
}
}
m_thread->stop();
// Initialize connection
- m_con.SetTimeoutMs(30);
- m_con.Serve(bind_addr);
+ m_con->SetTimeoutMs(30);
+ m_con->Serve(bind_addr);
// Start thread
m_thread->start();
SendBlocks(dtime);
}
- if((dtime < 0.001) && (initial_step == false))
+ if((dtime < 0.001) && !initial_step)
return;
g_profiler->add("Server::AsyncRunStep with dtime (num)", 1);
std::map<v3s16, MapBlock*> modified_blocks;
m_env->getMap().transformLiquids(modified_blocks, m_env);
-#if 0
- /*
- Update lighting
- */
- core::map<v3s16, MapBlock*> lighting_modified_blocks;
- ServerMap &map = ((ServerMap&)m_env->getMap());
- map.updateLighting(modified_blocks, lighting_modified_blocks);
-
- // Add blocks modified by lighting to modified_blocks
- for(core::map<v3s16, MapBlock*>::Iterator
- i = lighting_modified_blocks.getIterator();
- i.atEnd() == false; i++)
- {
- MapBlock *block = i.getNode()->getValue();
- modified_blocks.insert(block->getPos(), block);
- }
-#endif
+
/*
Set the modified blocks unsent for all the clients
*/
MutexAutoLock envlock(m_env_mutex);
m_clients.lock();
- RemoteClientMap clients = m_clients.getClientList();
+ const RemoteClientMap &clients = m_clients.getClientList();
ScopeProfiler sp(g_profiler, "Server: checking added and deleted objs");
// Radius inside which objects are active
if (player_radius == 0 && is_transfer_limited)
player_radius = radius;
- for (RemoteClientMap::iterator i = clients.begin();
- i != clients.end(); ++i) {
- RemoteClient *client = i->second;
+ for (const auto &client_it : clients) {
+ RemoteClient *client = client_it.second;
// If definitions and textures have not been sent, don't
// send objects either
continue;
RemotePlayer *player = m_env->getPlayer(client->peer_id);
- if (player == NULL) {
+ if (!player) {
// This can happen if the client timeouts somehow
- /*warningstream<<FUNCTION_NAME<<": Client "
- <<client->peer_id
- <<" has no associated player"<<std::endl;*/
continue;
}
PlayerSAO *playersao = player->getPlayerSAO();
- if (playersao == NULL)
+ if (!playersao)
continue;
s16 my_radius = MYMIN(radius, playersao->getWantedRange() * MAP_BLOCKSIZE);
// Get object type
u8 type = ACTIVEOBJECT_TYPE_INVALID;
- if(obj == NULL)
- warningstream<<FUNCTION_NAME
- <<": NULL object"<<std::endl;
+ if (!obj)
+ warningstream << FUNCTION_NAME << ": NULL object" << std::endl;
else
type = obj->getSendType();
if (aom.id == 0)
break;
- std::vector<ActiveObjectMessage>* message_list = NULL;
+ std::vector<ActiveObjectMessage>* message_list = nullptr;
std::unordered_map<u16, std::vector<ActiveObjectMessage>* >::iterator n;
n = buffered_messages.find(aom.id);
if (n == buffered_messages.end()) {
}
m_clients.lock();
- RemoteClientMap clients = m_clients.getClientList();
+ const RemoteClientMap &clients = m_clients.getClientList();
// Route data to every client
- for (std::unordered_map<u16, RemoteClient*>::iterator i = clients.begin();
- i != clients.end(); ++i) {
- RemoteClient *client = i->second;
+ for (const auto &client_it : clients) {
+ RemoteClient *client = client_it.second;
std::string reliable_data;
std::string unreliable_data;
// Go through all objects in message buffer
- for (std::unordered_map<u16, std::vector<ActiveObjectMessage>* >::iterator
- j = buffered_messages.begin();
- j != buffered_messages.end(); ++j) {
+ for (const auto &buffered_message : buffered_messages) {
// If object is not known by client, skip it
- u16 id = j->first;
+ u16 id = buffered_message.first;
if (client->m_known_objects.find(id) == client->m_known_objects.end())
continue;
// Get message list of object
- std::vector<ActiveObjectMessage>* list = j->second;
+ std::vector<ActiveObjectMessage>* list = buffered_message.second;
// Go through every message
- for (std::vector<ActiveObjectMessage>::iterator
- k = list->begin(); k != list->end(); ++k) {
+ for (const ActiveObjectMessage &aom : *list) {
// Compose the full new data with header
- ActiveObjectMessage aom = *k;
std::string new_data;
// Add object id
char buf[2];
// Add data
new_data += serializeString(aom.datastring);
// Add data to buffer
- if(aom.reliable)
+ if (aom.reliable)
reliable_data += new_data;
else
unreliable_data += new_data;
reliable_data and unreliable_data are now ready.
Send them.
*/
- if(reliable_data.size() > 0) {
+ if (!reliable_data.empty()) {
SendActiveObjectMessages(client->peer_id, reliable_data);
}
- if(unreliable_data.size() > 0) {
+ if (!unreliable_data.empty()) {
SendActiveObjectMessages(client->peer_id, unreliable_data, false);
}
}
m_clients.unlock();
// Clear buffered_messages
- for (std::unordered_map<u16, std::vector<ActiveObjectMessage>* >::iterator
- i = buffered_messages.begin();
- i != buffered_messages.end(); ++i) {
- delete i->second;
+ for (auto &buffered_message : buffered_messages) {
+ delete buffered_message.second;
}
}
// We'll log the amount of each
Profiler prof;
- while(m_unsent_map_edit_queue.size() != 0)
- {
+ while (!m_unsent_map_edit_queue.empty()) {
MapEditEvent* event = m_unsent_map_edit_queue.front();
m_unsent_map_edit_queue.pop();
case MEET_OTHER:
infostream << "Server: MEET_OTHER" << std::endl;
prof.add("MEET_OTHER", 1);
- for(std::set<v3s16>::iterator
- i = event->modified_blocks.begin();
- i != event->modified_blocks.end(); ++i) {
- setBlockNotSent(*i);
+ for (const v3s16 &modified_block : event->modified_blocks) {
+ setBlockNotSent(modified_block);
}
break;
default:
/*
Set blocks not sent to far players
*/
- if(!far_players.empty()) {
+ if (!far_players.empty()) {
// Convert list format to that wanted by SetBlocksNotSent
std::map<v3s16, MapBlock*> modified_blocks2;
- for(std::set<v3s16>::iterator
- i = event->modified_blocks.begin();
- i != event->modified_blocks.end(); ++i) {
- modified_blocks2[*i] =
- m_env->getMap().getBlockNoCreateNoEx(*i);
+ for (const v3s16 &modified_block : event->modified_blocks) {
+ modified_blocks2[modified_block] =
+ m_env->getMap().getBlockNoCreateNoEx(modified_block);
}
// Set blocks not sent
- for(std::vector<u16>::iterator
- i = far_players.begin();
- i != far_players.end(); ++i) {
- if(RemoteClient *client = getClient(*i))
+ for (const u16 far_player : far_players) {
+ if (RemoteClient *client = getClient(far_player))
client->SetBlocksNotSent(modified_blocks2);
}
}
delete event;
-
- /*// Don't send too many at a time
- count++;
- if(count >= 1 && m_unsent_map_edit_queue.size() < 100)
- break;*/
}
- if(event_count >= 5){
- infostream<<"Server: MapEditEvents:"<<std::endl;
+ if (event_count >= 5) {
+ infostream << "Server: MapEditEvents:" << std::endl;
prof.print(infostream);
- } else if(event_count != 0){
- verbosestream<<"Server: MapEditEvents:"<<std::endl;
+ } else if (event_count != 0) {
+ verbosestream << "Server: MapEditEvents:" << std::endl;
prof.print(verbosestream);
}
u16 peer_id;
try {
NetworkPacket pkt;
- m_con.Receive(&pkt);
+ m_con->Receive(&pkt);
peer_id = pkt.getPeerId();
ProcessData(&pkt);
- }
- catch(con::InvalidIncomingDataException &e) {
- infostream<<"Server::Receive(): "
- "InvalidIncomingDataException: what()="
- <<e.what()<<std::endl;
- }
- catch(SerializationError &e) {
- infostream<<"Server::Receive(): "
- "SerializationError: what()="
- <<e.what()<<std::endl;
- }
- catch(ClientStateError &e) {
- errorstream << "ProcessData: peer=" << peer_id << e.what() << std::endl;
+ } catch (const con::InvalidIncomingDataException &e) {
+ infostream << "Server::Receive(): InvalidIncomingDataException: what()="
+ << e.what() << std::endl;
+ } catch (const SerializationError &e) {
+ infostream << "Server::Receive(): SerializationError: what()="
+ << e.what() << std::endl;
+ } catch (const ClientStateError &e) {
+ errorstream << "ProcessData: peer=" << peer_id << e.what() << std::endl;
DenyAccess_Legacy(peer_id, L"Your client sent something server didn't expect."
L"Try reconnecting or updating your client");
- }
- catch(con::PeerNotFoundException &e) {
+ } catch (const con::PeerNotFoundException &e) {
// Do nothing
}
}
PlayerSAO* Server::StageTwoClientInit(u16 peer_id)
{
- std::string playername = "";
+ std::string playername;
PlayerSAO *playersao = NULL;
m_clients.lock();
try {
RemoteClient* client = m_clients.lockedGetClientNoEx(peer_id, CS_InitDone);
- if (client != NULL) {
+ if (client) {
playername = client->getName();
playersao = emergePlayer(playername.c_str(), peer_id, client->net_proto_version);
}
RemotePlayer *player = m_env->getPlayer(playername.c_str());
// If failed, cancel
- if ((playersao == NULL) || (player == NULL)) {
+ if (!playersao || !player) {
if (player && player->peer_id != 0) {
actionstream << "Server: Failed to emerge player \"" << playername
<< "\" (player allocated to an another client)" << std::endl;
actionstream << player->getName() << " joins game. List of players: ";
- for (std::vector<std::string>::const_iterator i = names.begin();
- i != names.end(); ++i) {
- actionstream << *i << " ";
+ for (const std::string &name : names) {
+ actionstream << name << " ";
}
actionstream << player->getName() <<std::endl;
break;
case InventoryLocation::PLAYER:
{
- RemotePlayer *player = dynamic_cast<RemotePlayer *>(m_env->getPlayer(loc.name.c_str()));
+ RemotePlayer *player = m_env->getPlayer(loc.name.c_str());
if(!player)
return NULL;
PlayerSAO *playersao = player->getPlayerSAO();
if (!playerSend)
return;
- RemotePlayer *player =
- dynamic_cast<RemotePlayer *>(m_env->getPlayer(loc.name.c_str()));
+ RemotePlayer *player = m_env->getPlayer(loc.name.c_str());
if (!player)
return;
v3s16 blockpos = getNodeBlockPos(loc.p);
MapBlock *block = m_env->getMap().getBlockNoCreateNoEx(blockpos);
- if(block)
+ if (block)
block->raiseModified(MOD_STATE_WRITE_NEEDED);
setBlockNotSent(blockpos);
std::vector<u16> clients = m_clients.getClientIDs();
m_clients.lock();
// Set the modified blocks unsent for all the clients
- for (std::vector<u16>::iterator i = clients.begin();
- i != clients.end(); ++i) {
- if (RemoteClient *client = m_clients.lockedGetClientNoEx(*i))
+ for (const u16 client_id : clients) {
+ if (RemoteClient *client = m_clients.lockedGetClientNoEx(client_id))
client->SetBlocksNotSent(block);
}
m_clients.unlock();
verbosestream<<"Server::peerAdded(): peer->id="
<<peer->id<<std::endl;
- con::PeerChange c;
- c.type = con::PEER_ADDED;
- c.peer_id = peer->id;
- c.timeout = false;
- m_peer_change_queue.push(c);
+ m_peer_change_queue.push(con::PeerChange(con::PEER_ADDED, peer->id, false));
}
void Server::deletingPeer(con::Peer *peer, bool timeout)
<<peer->id<<", timeout="<<timeout<<std::endl;
m_clients.event(peer->id, CSE_Disconnect);
- con::PeerChange c;
- c.type = con::PEER_REMOVED;
- c.peer_id = peer->id;
- c.timeout = timeout;
- m_peer_change_queue.push(c);
+ m_peer_change_queue.push(con::PeerChange(con::PEER_REMOVED, peer->id, timeout));
}
bool Server::getClientConInfo(u16 peer_id, con::rtt_stat_type type, float* retval)
{
- *retval = m_con.getPeerStat(peer_id,type);
- if (*retval == -1) return false;
- return true;
+ *retval = m_con->getPeerStat(peer_id,type);
+ return *retval != -1;
}
bool Server::getClientInfo(
m_clients.lock();
RemoteClient* client = m_clients.lockedGetClientNoEx(peer_id, CS_Invalid);
- if (client == NULL) {
+ if (!client) {
m_clients.unlock();
return false;
}
void Server::handlePeerChanges()
{
- while(m_peer_change_queue.size() > 0)
+ while(!m_peer_change_queue.empty())
{
con::PeerChange c = m_peer_change_queue.front();
m_peer_change_queue.pop();
DSTACK(FUNCTION_NAME);
NetworkPacket pkt(TOCLIENT_SHOW_FORMSPEC, 0 , peer_id);
- if (formspec == "" ){
+ if (formspec.empty()){
//the client should close the formspec
pkt.putLongString("");
} else {
if (peer_id == PEER_ID_INEXISTENT) {
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);
+ for (const u16 client_id : clients) {
+ RemotePlayer *player = m_env->getPlayer(client_id);
if (!player)
continue;
if (sao->getBasePosition().getDistanceFrom(pos * BS) > radius)
continue;
- SendSpawnParticle(*i, player->protocol_version,
+ SendSpawnParticle(client_id, player->protocol_version,
pos, velocity, acceleration,
expirationtime, size, collisiondetection,
collision_removal, vertical, texture, animation, glow);
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);
+ for (const u16 client_id : clients) {
+ RemotePlayer *player = m_env->getPlayer(client_id);
if (!player)
continue;
- SendAddParticleSpawner(*i, player->protocol_version,
+ SendAddParticleSpawner(client_id, player->protocol_version,
amount, spawntime, minpos, maxpos,
minvel, maxvel, minacc, maxacc, minexptime, maxexptime,
minsize, maxsize, collisiondetection, collision_removal,
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];
+ for (const std::string ¶m : params)
+ pkt << param;
pkt << clouds;
NetworkPacket pkt(TOCLIENT_PRIVILEGES, 0, peer_id);
pkt << (u16) privs.size();
- for(std::set<std::string>::const_iterator i = privs.begin();
- i != privs.end(); ++i) {
- pkt << (*i);
+ for (const std::string &priv : privs) {
+ pkt << priv;
}
Send(&pkt);
// Filter destination clients
std::vector<u16> dst_clients;
- if(params.to_player != "")
- {
+ if(!params.to_player.empty()) {
RemotePlayer *player = m_env->getPlayer(params.to_player.c_str());
if(!player){
infostream<<"Server::playSound: Player \""<<params.to_player
return -1;
}
dst_clients.push_back(player->peer_id);
- }
- else {
+ } else {
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);
+ for (const u16 client_id : clients) {
+ RemotePlayer *player = m_env->getPlayer(client_id);
if (!player)
continue;
params.max_hear_distance)
continue;
}
- dst_clients.push_back(*i);
+ dst_clients.push_back(client_id);
}
}
// Backwards compability
bool play_sound = gain > 0;
- for (std::vector<u16>::iterator i = dst_clients.begin();
- i != dst_clients.end(); ++i) {
- if (play_sound || m_clients.getProtocolVersion(*i) >= 32) {
- psound.clients.insert(*i);
- m_clients.send(*i, 0, &pkt, true);
+ for (const u16 dst_client : dst_clients) {
+ if (play_sound || m_clients.getProtocolVersion(dst_client) >= 32) {
+ psound.clients.insert(dst_client);
+ m_clients.send(dst_client, 0, &pkt, true);
}
}
return id;
}
// Remove sound reference
- if (!play_sound || psound.clients.size() == 0)
+ if (!play_sound || psound.clients.empty())
m_playing_sounds.erase(i);
- if (play_sound && compat_psound.clients.size() > 0) {
+ if (play_sound && !compat_psound.clients.empty()) {
// Play new sound volume on older clients
playSound(compat_psound.spec, compat_psound.params);
}
pkt << p;
std::vector<u16> clients = m_clients.getClientIDs();
- for (std::vector<u16>::iterator i = clients.begin(); i != clients.end(); ++i) {
+ for (u16 client_id : clients) {
if (far_players) {
// Get player
- if (RemotePlayer *player = m_env->getPlayer(*i)) {
+ if (RemotePlayer *player = m_env->getPlayer(client_id)) {
PlayerSAO *sao = player->getPlayerSAO();
if (!sao)
continue;
// If player is far away, only set modified blocks not sent
v3f player_pos = sao->getBasePosition();
if (player_pos.getDistanceFrom(p_f) > maxd) {
- far_players->push_back(*i);
+ far_players->push_back(client_id);
continue;
}
}
}
// Send as reliable
- m_clients.send(*i, 0, &pkt, true);
+ m_clients.send(client_id, 0, &pkt, true);
}
}
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) {
+ for (const u16 client_id : clients) {
if (far_players) {
// Get player
- if (RemotePlayer *player = m_env->getPlayer(*i)) {
+ if (RemotePlayer *player = m_env->getPlayer(client_id)) {
PlayerSAO *sao = player->getPlayerSAO();
if (!sao)
continue;
// If player is far away, only set modified blocks not sent
v3f player_pos = sao->getBasePosition();
if(player_pos.getDistanceFrom(p_f) > maxd) {
- far_players->push_back(*i);
+ far_players->push_back(client_id);
continue;
}
}
NetworkPacket pkt(TOCLIENT_ADDNODE, 6 + 2 + 1 + 1 + 1);
m_clients.lock();
- RemoteClient* client = m_clients.lockedGetClientNoEx(*i);
- if (client != 0) {
+ RemoteClient* client = m_clients.lockedGetClientNoEx(client_id);
+ if (client) {
pkt << p << n.param0 << n.param1 << n.param2
<< (u8) (remove_metadata ? 0 : 1);
}
// Send as reliable
if (pkt.getSize() > 0)
- m_clients.send(*i, 0, &pkt, true);
+ m_clients.send(client_id, 0, &pkt, true);
}
}
{
std::vector<u16> clients = m_clients.getClientIDs();
m_clients.lock();
- for(std::vector<u16>::iterator i = clients.begin();
- i != clients.end(); ++i) {
- RemoteClient *client = m_clients.lockedGetClientNoEx(*i);
+ for (const u16 i : clients) {
+ RemoteClient *client = m_clients.lockedGetClientNoEx(i);
client->SetBlockNotSent(p);
}
m_clients.unlock();
s32 total_sending = 0;
{
- ScopeProfiler sp(g_profiler, "Server: selecting blocks for sending");
+ ScopeProfiler sp2(g_profiler, "Server: selecting blocks for sending");
std::vector<u16> clients = m_clients.getClientIDs();
m_clients.lock();
- for(std::vector<u16>::iterator i = clients.begin();
- i != clients.end(); ++i) {
- RemoteClient *client = m_clients.lockedGetClientNoEx(*i, CS_Active);
+ for (const u16 client_id : clients) {
+ RemoteClient *client = m_clients.lockedGetClientNoEx(client_id, CS_Active);
- if (client == NULL)
+ if (!client)
continue;
total_sending += client->SendingCount();
std::sort(queue.begin(), queue.end());
m_clients.lock();
- for(u32 i=0; i<queue.size(); i++)
- {
+ s32 max_blocks_to_send =
+ g_settings->getS32("max_simultaneous_block_sends_server_total");
+
+ for (const PrioritySortedBlockTransfer &block_to_send : queue) {
//TODO: Calculate limit dynamically
- if(total_sending >= g_settings->getS32
- ("max_simultaneous_block_sends_server_total"))
+ if (total_sending >= max_blocks_to_send)
break;
- PrioritySortedBlockTransfer q = queue[i];
-
- MapBlock *block = NULL;
- try
- {
- block = m_env->getMap().getBlockNoCreate(q.pos);
- }
- catch(InvalidPositionException &e)
- {
+ MapBlock *block = nullptr;
+ try {
+ block = m_env->getMap().getBlockNoCreate(block_to_send.pos);
+ } catch (const InvalidPositionException &e) {
continue;
}
- RemoteClient *client = m_clients.lockedGetClientNoEx(q.peer_id, CS_Active);
-
- if(!client)
+ RemoteClient *client = m_clients.lockedGetClientNoEx(block_to_send.peer_id,
+ CS_Active);
+ if (!client)
continue;
- SendBlockNoLock(q.peer_id, block, client->serialization_version, client->net_proto_version);
+ SendBlockNoLock(block_to_send.peer_id, block, client->serialization_version,
+ client->net_proto_version);
- client->SentBlock(q.pos);
+ client->SentBlock(block_to_send.pos);
total_sending++;
}
m_clients.unlock();
// Collect all media file paths
std::vector<std::string> paths;
- for(std::vector<ModSpec>::iterator i = m_mods.begin();
- i != m_mods.end(); ++i) {
- const ModSpec &mod = *i;
+ for (const ModSpec &mod : m_mods) {
paths.push_back(mod.path + DIR_DELIM + "textures");
paths.push_back(mod.path + DIR_DELIM + "sounds");
paths.push_back(mod.path + DIR_DELIM + "media");
paths.push_back(mod.path + DIR_DELIM + "models");
+ paths.push_back(mod.path + DIR_DELIM + "locale");
}
paths.push_back(porting::path_user + DIR_DELIM + "textures" + DIR_DELIM + "server");
// Collect media file information from paths into cache
- for(std::vector<std::string>::iterator i = paths.begin();
- i != paths.end(); ++i) {
- std::string mediapath = *i;
+ for (const std::string &mediapath : paths) {
std::vector<fs::DirListNode> dirlist = fs::GetDirListing(mediapath);
- for (u32 j = 0; j < dirlist.size(); j++) {
- if (dirlist[j].dir) // Ignode dirs
+ for (const fs::DirListNode &dln : dirlist) {
+ if (dln.dir) // Ignode dirs
continue;
- std::string filename = dirlist[j].name;
+ std::string filename = dln.name;
// If name contains illegal characters, ignore the file
if (!string_allowed(filename, TEXTURENAME_ALLOWED_CHARS)) {
infostream<<"Server: ignoring illegal file name: \""
".pcx", ".ppm", ".psd", ".wal", ".rgb",
".ogg",
".x", ".b3d", ".md2", ".obj",
+ // Custom translation file format
+ ".tr",
NULL
};
- if (removeStringEnd(filename, supported_ext) == ""){
+ if (removeStringEnd(filename, supported_ext).empty()){
infostream << "Server: ignoring unsupported file extension: \""
<< filename << "\"" << std::endl;
continue;
}
// Ok, attempt to load the file and add to cache
- std::string filepath = mediapath + DIR_DELIM + filename;
+ std::string filepath;
+ filepath.append(mediapath).append(DIR_DELIM).append(filename);
+
// Read data
std::ifstream fis(filepath.c_str(), std::ios_base::binary);
if (!fis.good()) {
}
}
-void Server::sendMediaAnnouncement(u16 peer_id)
+void Server::sendMediaAnnouncement(u16 peer_id, const std::string &lang_code)
{
DSTACK(FUNCTION_NAME);
<< std::endl;
// Make packet
- std::ostringstream os(std::ios_base::binary);
-
NetworkPacket pkt(TOCLIENT_ANNOUNCE_MEDIA, 0, peer_id);
- pkt << (u16) m_media.size();
- for (std::unordered_map<std::string, MediaInfo>::iterator i = m_media.begin();
- i != m_media.end(); ++i) {
- pkt << i->first << i->second.sha1_digest;
+ u16 media_sent = 0;
+ std::string lang_suffix;
+ lang_suffix.append(".").append(lang_code).append(".tr");
+ for (const auto &i : m_media) {
+ if (str_ends_with(i.first, ".tr") && !str_ends_with(i.first, lang_suffix))
+ continue;
+ media_sent++;
+ }
+
+ pkt << media_sent;
+
+ for (const auto &i : m_media) {
+ if (str_ends_with(i.first, ".tr") && !str_ends_with(i.first, lang_suffix))
+ continue;
+ pkt << i.first << i.second.sha1_digest;
}
pkt << g_settings->get("remote_media");
u32 bytes_per_bunch = 5000;
std::vector< std::vector<SendableMedia> > file_bunches;
- file_bunches.push_back(std::vector<SendableMedia>());
+ file_bunches.emplace_back();
u32 file_size_bunch_total = 0;
- for(std::vector<std::string>::const_iterator i = tosend.begin();
- i != tosend.end(); ++i) {
- const std::string &name = *i;
-
+ for (const std::string &name : tosend) {
if (m_media.find(name) == m_media.end()) {
errorstream<<"Server::sendRequestedMedia(): Client asked for "
<<"unknown file \""<<(name)<<"\""<<std::endl;
// Read data
std::ifstream fis(tpath.c_str(), std::ios_base::binary);
- if(fis.good() == false){
+ if(!fis.good()){
errorstream<<"Server::sendRequestedMedia(): Could not open \""
<<tpath<<"\" for reading"<<std::endl;
continue;
break;
}
}
- if(bad) {
+ if (bad) {
errorstream<<"Server::sendRequestedMedia(): Failed to read \""
<<name<<"\""<<std::endl;
continue;
/*infostream<<"Server::sendRequestedMedia(): Loaded \""
<<tname<<"\""<<std::endl;*/
// Put in list
- file_bunches[file_bunches.size()-1].push_back(
- SendableMedia(name, tpath, tmp_os.str()));
+ file_bunches[file_bunches.size()-1].emplace_back(name, tpath, tmp_os.str());
// Start next bunch if got enough data
if(file_size_bunch_total >= bytes_per_bunch) {
- file_bunches.push_back(std::vector<SendableMedia>());
+ file_bunches.emplace_back();
file_size_bunch_total = 0;
}
/* Create and send packets */
u16 num_bunches = file_bunches.size();
- for(u16 i = 0; i < num_bunches; i++) {
+ for (u16 i = 0; i < num_bunches; i++) {
/*
u16 command
u16 total number of texture bunches
NetworkPacket pkt(TOCLIENT_MEDIA, 4 + 0, peer_id);
pkt << num_bunches << i << (u32) file_bunches[i].size();
- for(std::vector<SendableMedia>::iterator
- j = file_bunches[i].begin();
- j != file_bunches[i].end(); ++j) {
- pkt << j->name;
- pkt.putLongString(j->data);
+ for (const SendableMedia &j : file_bunches[i]) {
+ pkt << j.name;
+ pkt.putLongString(j.data);
}
verbosestream << "Server::sendRequestedMedia(): bunch "
const std::string &check = m_detached_inventories_player[name];
if (peer_id == PEER_ID_INEXISTENT) {
- if (check == "")
+ if (check.empty())
return m_clients.sendToAll(&pkt);
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)
+ if (check.empty() || getPlayerName(peer_id) == check)
Send(&pkt);
}
}
{
DSTACK(FUNCTION_NAME);
- for(std::map<std::string, Inventory*>::iterator
- i = m_detached_inventories.begin();
- i != m_detached_inventories.end(); ++i) {
- const std::string &name = i->first;
+ for (const auto &detached_inventory : m_detached_inventories) {
+ const std::string &name = detached_inventory.first;
//Inventory *inv = i->second;
sendDetachedInventory(name, peer_id);
}
<< playersao->getPlayer()->getName()
<< " respawns" << std::endl;
- playersao->setHP(PLAYER_MAX_HP);
+ playersao->setHP(playersao->accessObjectProperties()->hp_max);
playersao->setBreath(PLAYER_MAX_BREATH);
bool repositioned = m_script->on_respawnplayer(playersao);
}
m_clients.event(peer_id, CSE_SetDenied);
- m_con.DisconnectPeer(peer_id);
+ m_con->DisconnectPeer(peer_id);
}
SendAccessDenied(peer_id, reason, custom_reason);
m_clients.event(peer_id, CSE_SetDenied);
- m_con.DisconnectPeer(peer_id);
+ m_con->DisconnectPeer(peer_id);
}
// 13/03/15: remove this function when protocol version 25 will become
SendAccessDenied_Legacy(peer_id, reason);
m_clients.event(peer_id, CSE_SetDenied);
- m_con.DisconnectPeer(peer_id);
+ m_con->DisconnectPeer(peer_id);
}
void Server::acceptAuth(u16 peer_id, bool forSudoMode)
RemotePlayer *player = m_env->getPlayer(peer_id);
/* Run scripts and remove from environment */
- if (player != NULL) {
+ if (player) {
PlayerSAO *playersao = player->getPlayerSAO();
assert(playersao);
Print out action
*/
{
- if(player != NULL && reason != CDR_DENY) {
+ if (player && reason != CDR_DENY) {
std::ostringstream os(std::ios_base::binary);
std::vector<u16> clients = m_clients.getClientIDs();
- for(std::vector<u16>::iterator i = clients.begin();
- i != clients.end(); ++i) {
+ for (const u16 client_id : clients) {
// Get player
- RemotePlayer *player = m_env->getPlayer(*i);
+ RemotePlayer *player = m_env->getPlayer(client_id);
if (!player)
continue;
/*
Tell calling method to send the message to sender
*/
- if (!broadcast_line) {
+ if (!broadcast_line)
return line;
- } else {
- /*
- Send the message to others
- */
- actionstream << "CHAT: " << wide_to_narrow(unescape_enriched(line)) << std::endl;
- std::vector<u16> clients = m_clients.getClientIDs();
+ /*
+ Send the message to others
+ */
+ actionstream << "CHAT: " << wide_to_narrow(unescape_enriched(line)) << std::endl;
- /*
- Send the message back to the inital sender
- if they are using protocol version >= 29
- */
+ std::vector<u16> clients = m_clients.getClientIDs();
- 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;
+ /*
+ Send the message back to the inital sender
+ if they are using protocol version >= 29
+ */
- for (u16 i = 0; i < clients.size(); i++) {
- u16 cid = clients[i];
- if (cid != peer_id_to_avoid_sending)
- SendChatMessage(cid, ChatMessage(line));
- }
+ 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 cid : clients) {
+ if (cid != peer_id_to_avoid_sending)
+ SendChatMessage(cid, ChatMessage(line));
}
return L"";
}
std::string Server::getPlayerName(u16 peer_id)
{
RemotePlayer *player = m_env->getPlayer(peer_id);
- if (player == NULL)
+ if (!player)
return "[id="+itos(peer_id)+"]";
return player->getName();
}
PlayerSAO* Server::getPlayerSAO(u16 peer_id)
{
RemotePlayer *player = m_env->getPlayer(peer_id);
- if (player == NULL)
+ if (!player)
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 (u16 client_id : clients) {
// Get player
- RemotePlayer *player = m_env->getPlayer(*i);
+ RemotePlayer *player = m_env->getPlayer(client_id);
// Get name of player
std::wstring name = L"unknown";
- if (player != NULL)
+ if (player)
name = narrow_to_wide(player->getName());
// Add name to information string
if(!first)
os << name;
}
os << L"}";
- if(((ServerMap*)(&m_env->getMap()))->isSavingEnabled() == false)
+
+ if (!((ServerMap*)(&m_env->getMap()))->isSavingEnabled())
os<<std::endl<<L"# Server: "<<" WARNING: Map saving is disabled.";
- if(g_settings->get("motd") != "")
+
+ if (!g_settings->get("motd").empty())
os<<std::endl<<L"# Server: "<<narrow_to_wide(g_settings->get("motd"));
return os.str();
}
void Server::reportPrivsModified(const std::string &name)
{
- if(name == "") {
+ if (name.empty()) {
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);
+ for (const u16 client_id : clients) {
+ RemotePlayer *player = m_env->getPlayer(client_id);
reportPrivsModified(player->getName());
}
} else {
PlayerSAO* playersao = player->getPlayerSAO();
- if (playersao == NULL)
+ if (!playersao)
return false;
m_script->player_event(playersao, "hud_changed");
return true;
}
+s32 Server::hudGetHotbarItemcount(RemotePlayer *player) const
+{
+ return player->getHotbarItemcount();
+}
+
void Server::hudSetHotbarImage(RemotePlayer *player, std::string name)
{
if (!player)
SendHUDSetParam(player->peer_id, HUD_PARAM_HOTBAR_SELECTED_IMAGE, name);
}
+const std::string& Server::hudGetHotbarSelectedImage(RemotePlayer *player) const
+{
+ return player->getHotbarSelectedImage();
+}
+
+Address Server::getPeerAddress(u16 peer_id)
+{
+ return m_con->GetPeerAddress(peer_id);
+}
+
bool Server::setLocalPlayerAnimations(RemotePlayer *player,
v2s32 animation_frames[4], f32 frame_speed)
{
return;
u16 peer_id = PEER_ID_INEXISTENT, proto_ver = 0;
- if (playername != "") {
+ if (!playername.empty()) {
RemotePlayer *player = m_env->getPlayer(playername.c_str());
if (!player)
return;
return -1;
u16 peer_id = PEER_ID_INEXISTENT, proto_ver = 0;
- if (playername != "") {
+ if (!playername.empty()) {
RemotePlayer *player = m_env->getPlayer(playername.c_str());
if (!player)
return -1;
throw ServerError("Can't delete particle spawners during initialisation!");
u16 peer_id = PEER_ID_INEXISTENT;
- if (playername != "") {
+ if (!playername.empty()) {
RemotePlayer *player = m_env->getPlayer(playername.c_str());
if (!player)
return;
int num_tried = 0;
int num_failed = 0;
- for(std::list<RollbackAction>::const_iterator
- i = actions.begin();
- i != actions.end(); ++i)
- {
- const RollbackAction &action = *i;
+ for (const RollbackAction &action : actions) {
num_tried++;
bool success = action.applyRevert(map, this, this);
if(!success){
std::ostringstream os;
os<<"Revert of step ("<<num_tried<<") "<<action.toString()<<" failed";
infostream<<"Map::rollbackRevertActions(): "<<os.str()<<std::endl;
- if(log)
+ if (log)
log->push_back(os.str());
}else{
std::ostringstream os;
os<<"Successfully reverted step ("<<num_tried<<") "<<action.toString();
infostream<<"Map::rollbackRevertActions(): "<<os.str()<<std::endl;
- if(log)
+ if (log)
log->push_back(os.str());
}
}
RemotePlayer *player = m_env->getPlayer(name);
// If player is already connected, cancel
- if (player != NULL && player->peer_id != 0) {
+ if (player && 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)) {
infostream<<"emergePlayer(): Player with wrong name but same"
" peer_id already exists"<<std::endl;
return NULL;
projects / dragonfireclient.git / blobdiff