2010-11-29 13:13:04 -05:00
|
|
|
/*
|
2013-02-24 12:40:43 -05:00
|
|
|
Minetest
|
2013-02-24 13:38:45 -05:00
|
|
|
Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
|
2010-11-29 13:13:04 -05:00
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
2012-06-05 10:56:56 -04:00
|
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
2010-11-29 13:13:04 -05:00
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2012-06-05 10:56:56 -04:00
|
|
|
GNU Lesser General Public License for more details.
|
2010-11-29 13:13:04 -05:00
|
|
|
|
2012-06-05 10:56:56 -04:00
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
2010-11-29 13:13:04 -05:00
|
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
2010-11-26 18:02:21 -05:00
|
|
|
#include "server.h"
|
|
|
|
#include <iostream>
|
2011-11-27 04:44:05 -05:00
|
|
|
#include <queue>
|
2013-01-23 12:32:02 -05:00
|
|
|
#include <algorithm>
|
2015-01-12 11:01:41 -05:00
|
|
|
#include "network/networkprotocol.h"
|
|
|
|
#include "network/serveropcodes.h"
|
2013-08-10 22:09:45 -04:00
|
|
|
#include "ban.h"
|
|
|
|
#include "environment.h"
|
2010-11-26 18:02:21 -05:00
|
|
|
#include "map.h"
|
2015-04-07 06:13:12 -04:00
|
|
|
#include "threading/mutex_auto_lock.h"
|
2010-11-26 18:02:21 -05:00
|
|
|
#include "constants.h"
|
2010-12-11 11:11:03 -05:00
|
|
|
#include "voxel.h"
|
2011-04-24 17:31:22 -04:00
|
|
|
#include "config.h"
|
2013-09-24 22:29:07 -04:00
|
|
|
#include "version.h"
|
2011-05-22 10:00:09 -04:00
|
|
|
#include "filesys.h"
|
2011-06-25 19:34:36 -04:00
|
|
|
#include "mapblock.h"
|
2011-06-26 08:48:56 -04:00
|
|
|
#include "serverobject.h"
|
2013-08-13 17:06:39 -04:00
|
|
|
#include "genericobject.h"
|
2011-10-12 06:53:38 -04:00
|
|
|
#include "settings.h"
|
|
|
|
#include "profiler.h"
|
2011-10-16 07:57:53 -04:00
|
|
|
#include "log.h"
|
2013-08-10 22:09:45 -04:00
|
|
|
#include "scripting_game.h"
|
2011-11-14 14:41:30 -05:00
|
|
|
#include "nodedef.h"
|
2012-01-12 00:10:39 -05:00
|
|
|
#include "itemdef.h"
|
2011-11-16 19:28:46 -05:00
|
|
|
#include "craftdef.h"
|
2013-02-13 22:43:15 -05:00
|
|
|
#include "emerge.h"
|
2011-11-26 08:53:52 -05:00
|
|
|
#include "mapgen.h"
|
2014-11-01 13:16:23 -04:00
|
|
|
#include "mg_biome.h"
|
2012-03-18 22:04:16 -04:00
|
|
|
#include "content_mapnode.h"
|
|
|
|
#include "content_nodemeta.h"
|
2011-11-27 17:45:34 -05:00
|
|
|
#include "content_abm.h"
|
2012-03-18 22:04:16 -04:00
|
|
|
#include "content_sao.h"
|
2011-12-02 20:23:14 -05:00
|
|
|
#include "mods.h"
|
2012-03-23 06:05:17 -04:00
|
|
|
#include "sound.h" // dummySoundManager
|
2012-03-23 14:23:03 -04:00
|
|
|
#include "event_manager.h"
|
2013-02-21 17:00:44 -05:00
|
|
|
#include "serverlist.h"
|
2012-06-16 19:40:36 -04:00
|
|
|
#include "util/string.h"
|
2012-06-23 09:06:03 -04:00
|
|
|
#include "util/mathconstants.h"
|
2012-07-26 15:06:45 -04:00
|
|
|
#include "rollback.h"
|
2012-11-26 04:18:34 -05:00
|
|
|
#include "util/serialize.h"
|
2013-08-10 22:09:45 -04:00
|
|
|
#include "util/thread.h"
|
2013-03-21 15:42:23 -04:00
|
|
|
#include "defaultsettings.h"
|
2015-02-21 08:17:36 -05:00
|
|
|
#include "util/base64.h"
|
|
|
|
#include "util/sha1.h"
|
|
|
|
#include "util/hex.h"
|
2011-10-16 07:57:53 -04:00
|
|
|
|
2013-08-04 01:17:07 -04:00
|
|
|
class ClientNotFoundException : public BaseException
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
ClientNotFoundException(const char *s):
|
|
|
|
BaseException(s)
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
2015-04-07 06:13:12 -04:00
|
|
|
class ServerThread : public Thread
|
2013-08-10 22:09:45 -04:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
|
|
|
ServerThread(Server *server):
|
2015-04-07 06:13:12 -04:00
|
|
|
Thread("Server"),
|
2013-08-10 22:09:45 -04:00
|
|
|
m_server(server)
|
2015-04-07 06:13:12 -04:00
|
|
|
{}
|
2013-08-10 22:09:45 -04:00
|
|
|
|
2015-04-07 06:13:12 -04:00
|
|
|
void *run();
|
|
|
|
|
|
|
|
private:
|
|
|
|
Server *m_server;
|
2013-08-10 22:09:45 -04:00
|
|
|
};
|
|
|
|
|
2015-04-07 06:13:12 -04:00
|
|
|
void *ServerThread::run()
|
2010-11-26 18:02:21 -05:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2010-12-27 07:34:17 -05:00
|
|
|
BEGIN_DEBUG_EXCEPTION_HANDLER
|
|
|
|
|
2014-01-06 14:05:28 -05:00
|
|
|
m_server->AsyncRunStep(true);
|
|
|
|
|
2015-04-07 06:13:12 -04:00
|
|
|
while (!stopRequested()) {
|
2015-08-01 16:52:28 -04:00
|
|
|
try {
|
2011-02-15 09:11:24 -05:00
|
|
|
//TimeTaker timer("AsyncRunStep() + Receive()");
|
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
m_server->AsyncRunStep();
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2010-11-26 18:02:21 -05:00
|
|
|
m_server->Receive();
|
2014-01-30 18:24:00 -05:00
|
|
|
|
2015-08-01 16:52:28 -04:00
|
|
|
} catch (con::NoIncomingDataException &e) {
|
|
|
|
} catch (con::PeerNotFoundException &e) {
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Server: PeerNotFoundException"<<std::endl;
|
2015-08-01 16:52:28 -04:00
|
|
|
} catch (ClientNotFoundException &e) {
|
|
|
|
} catch (con::ConnectionBindFailed &e) {
|
2012-03-30 11:42:18 -04:00
|
|
|
m_server->setAsyncFatalError(e.what());
|
2015-08-01 16:52:28 -04:00
|
|
|
} catch (LuaError &e) {
|
|
|
|
m_server->setAsyncFatalError("Lua: " + std::string(e.what()));
|
2012-03-30 11:42:18 -04:00
|
|
|
}
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2015-10-14 02:33:04 -04:00
|
|
|
END_DEBUG_EXCEPTION_HANDLER
|
2010-11-26 18:02:21 -05:00
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-03-18 22:04:16 -04:00
|
|
|
v3f ServerSoundParams::getPos(ServerEnvironment *env, bool *pos_exists) const
|
|
|
|
{
|
|
|
|
if(pos_exists) *pos_exists = false;
|
|
|
|
switch(type){
|
|
|
|
case SSP_LOCAL:
|
|
|
|
return v3f(0,0,0);
|
|
|
|
case SSP_POSITIONAL:
|
|
|
|
if(pos_exists) *pos_exists = true;
|
|
|
|
return pos;
|
|
|
|
case SSP_OBJECT: {
|
|
|
|
if(object == 0)
|
|
|
|
return v3f(0,0,0);
|
|
|
|
ServerActiveObject *sao = env->getActiveObject(object);
|
|
|
|
if(!sao)
|
|
|
|
return v3f(0,0,0);
|
|
|
|
if(pos_exists) *pos_exists = true;
|
|
|
|
return sao->getBasePosition(); }
|
|
|
|
}
|
|
|
|
return v3f(0,0,0);
|
|
|
|
}
|
|
|
|
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2010-11-26 18:02:21 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
Server
|
|
|
|
*/
|
|
|
|
|
|
|
|
Server::Server(
|
2012-03-11 08:54:23 -04:00
|
|
|
const std::string &path_world,
|
2012-03-15 09:20:20 -04:00
|
|
|
const SubgameSpec &gamespec,
|
2014-03-06 19:00:03 -05:00
|
|
|
bool simple_singleplayer_mode,
|
2015-07-25 01:43:32 -04:00
|
|
|
bool ipv6,
|
|
|
|
ChatInterface *iface
|
2010-11-26 18:02:21 -05:00
|
|
|
):
|
2012-03-10 08:56:24 -05:00
|
|
|
m_path_world(path_world),
|
2012-03-11 08:54:23 -04:00
|
|
|
m_gamespec(gamespec),
|
2012-03-15 09:20:20 -04:00
|
|
|
m_simple_singleplayer_mode(simple_singleplayer_mode),
|
2012-03-11 14:45:43 -04:00
|
|
|
m_async_fatal_error(""),
|
2011-11-11 12:33:17 -05:00
|
|
|
m_env(NULL),
|
2014-01-30 18:24:00 -05:00
|
|
|
m_con(PROTOCOL_ID,
|
|
|
|
512,
|
|
|
|
CONNECTION_TIMEOUT,
|
2014-03-06 19:00:03 -05:00
|
|
|
ipv6,
|
2014-01-30 18:24:00 -05:00
|
|
|
this),
|
2013-08-10 22:09:45 -04:00
|
|
|
m_banmanager(NULL),
|
2012-07-26 15:06:45 -04:00
|
|
|
m_rollback(NULL),
|
2012-07-27 20:08:09 -04:00
|
|
|
m_enable_rollback_recording(false),
|
2012-11-25 21:16:48 -05:00
|
|
|
m_emerge(NULL),
|
2013-05-24 18:51:02 -04:00
|
|
|
m_script(NULL),
|
2012-01-12 00:10:39 -05:00
|
|
|
m_itemdef(createItemDefManager()),
|
2011-11-16 07:08:31 -05:00
|
|
|
m_nodedef(createNodeDefManager()),
|
2011-11-16 19:28:46 -05:00
|
|
|
m_craftdef(createCraftDefManager()),
|
2012-03-23 14:23:03 -04:00
|
|
|
m_event(new EventManager()),
|
2013-08-10 22:09:45 -04:00
|
|
|
m_thread(NULL),
|
2010-12-24 10:08:50 -05:00
|
|
|
m_time_of_day_send_timer(0),
|
2011-01-27 18:38:16 -05:00
|
|
|
m_uptime(0),
|
2014-01-30 18:24:00 -05:00
|
|
|
m_clients(&m_con),
|
2011-02-22 19:49:57 -05:00
|
|
|
m_shutdown_requested(false),
|
2015-07-17 10:40:41 -04:00
|
|
|
m_shutdown_ask_reconnect(false),
|
2015-07-25 01:43:32 -04:00
|
|
|
m_admin_chat(iface),
|
2011-02-22 19:49:57 -05:00
|
|
|
m_ignore_map_edit_events(false),
|
2015-01-24 00:44:41 -05:00
|
|
|
m_ignore_map_edit_events_peer_id(0),
|
|
|
|
m_next_sound_id(0)
|
2014-01-30 18:24:00 -05:00
|
|
|
|
2010-11-26 18:02:21 -05:00
|
|
|
{
|
2011-01-17 14:15:31 -05:00
|
|
|
m_liquid_transform_timer = 0.0;
|
2013-02-24 09:39:07 -05:00
|
|
|
m_liquid_transform_every = 1.0;
|
2010-12-19 09:51:45 -05:00
|
|
|
m_print_info_timer = 0.0;
|
2013-02-21 17:00:44 -05:00
|
|
|
m_masterserver_timer = 0.0;
|
2010-12-19 09:51:45 -05:00
|
|
|
m_objectdata_timer = 0.0;
|
|
|
|
m_emergethread_trigger_timer = 0.0;
|
|
|
|
m_savemap_timer = 0.0;
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2010-11-26 18:02:21 -05:00
|
|
|
m_step_dtime = 0.0;
|
2014-01-06 17:50:45 -05:00
|
|
|
m_lag = g_settings->getFloat("dedicated_server_step");
|
2011-11-11 12:33:17 -05:00
|
|
|
|
2012-03-11 14:45:43 -04:00
|
|
|
if(path_world == "")
|
|
|
|
throw ServerError("Supplied empty world path");
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2012-03-11 08:54:23 -04:00
|
|
|
if(!gamespec.isValid())
|
|
|
|
throw ServerError("Supplied invalid gamespec");
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2012-03-15 09:20:20 -04:00
|
|
|
infostream<<"Server created for gameid \""<<m_gamespec.id<<"\"";
|
|
|
|
if(m_simple_singleplayer_mode)
|
|
|
|
infostream<<" in simple singleplayer mode"<<std::endl;
|
|
|
|
else
|
|
|
|
infostream<<std::endl;
|
2012-03-11 08:54:23 -04:00
|
|
|
infostream<<"- world: "<<m_path_world<<std::endl;
|
|
|
|
infostream<<"- game: "<<m_gamespec.path<<std::endl;
|
2012-03-10 21:15:45 -05:00
|
|
|
|
2015-01-26 06:44:49 -05:00
|
|
|
// Create world if it doesn't exist
|
2015-03-12 23:35:34 -04:00
|
|
|
if(!loadGameConfAndInitWorld(m_path_world, m_gamespec))
|
2015-01-26 06:44:49 -05:00
|
|
|
throw ServerError("Failed to initialize world");
|
2013-08-10 22:09:45 -04:00
|
|
|
|
|
|
|
// Create server thread
|
|
|
|
m_thread = new ServerThread(this);
|
|
|
|
|
2013-03-24 01:43:38 -04:00
|
|
|
// Create emerge manager
|
2013-04-06 11:19:59 -04:00
|
|
|
m_emerge = new EmergeManager(this);
|
2013-08-10 22:09:45 -04:00
|
|
|
|
|
|
|
// Create ban manager
|
2014-06-25 20:28:41 -04:00
|
|
|
std::string ban_path = m_path_world + DIR_DELIM "ipban.txt";
|
2013-08-10 22:09:45 -04:00
|
|
|
m_banmanager = new BanManager(ban_path);
|
|
|
|
|
2012-12-08 12:10:54 -05:00
|
|
|
ModConfiguration modconf(m_path_world);
|
|
|
|
m_mods = modconf.getMods();
|
2013-05-03 17:58:22 -04:00
|
|
|
std::vector<ModSpec> unsatisfied_mods = modconf.getUnsatisfiedMods();
|
2012-12-08 12:10:54 -05:00
|
|
|
// complain about mods with unsatisfied dependencies
|
2015-03-02 13:26:20 -05:00
|
|
|
if(!modconf.isConsistent()) {
|
2013-05-03 17:58:22 -04:00
|
|
|
for(std::vector<ModSpec>::iterator it = unsatisfied_mods.begin();
|
2015-03-02 13:26:20 -05:00
|
|
|
it != unsatisfied_mods.end(); ++it) {
|
2013-02-20 14:06:39 -05:00
|
|
|
ModSpec mod = *it;
|
|
|
|
errorstream << "mod \"" << mod.name << "\" has unsatisfied dependencies: ";
|
|
|
|
for(std::set<std::string>::iterator dep_it = mod.unsatisfied_depends.begin();
|
|
|
|
dep_it != mod.unsatisfied_depends.end(); ++dep_it)
|
|
|
|
errorstream << " \"" << *dep_it << "\"";
|
|
|
|
errorstream << std::endl;
|
2012-12-08 12:10:54 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Settings worldmt_settings;
|
|
|
|
std::string worldmt = m_path_world + DIR_DELIM + "world.mt";
|
|
|
|
worldmt_settings.readConfigFile(worldmt.c_str());
|
|
|
|
std::vector<std::string> names = worldmt_settings.getNames();
|
|
|
|
std::set<std::string> load_mod_names;
|
2013-11-30 19:52:06 -05:00
|
|
|
for(std::vector<std::string>::iterator it = names.begin();
|
2015-03-02 13:26:20 -05:00
|
|
|
it != names.end(); ++it) {
|
2013-11-30 19:52:06 -05:00
|
|
|
std::string name = *it;
|
2013-05-19 13:46:50 -04:00
|
|
|
if(name.compare(0,9,"load_mod_")==0 && worldmt_settings.getBool(name))
|
|
|
|
load_mod_names.insert(name.substr(9));
|
2012-12-08 12:10:54 -05:00
|
|
|
}
|
|
|
|
// complain about mods declared to be loaded, but not found
|
|
|
|
for(std::vector<ModSpec>::iterator it = m_mods.begin();
|
2013-03-21 12:48:21 -04:00
|
|
|
it != m_mods.end(); ++it)
|
2012-12-08 12:10:54 -05:00
|
|
|
load_mod_names.erase((*it).name);
|
2013-05-03 17:58:22 -04:00
|
|
|
for(std::vector<ModSpec>::iterator it = unsatisfied_mods.begin();
|
2013-03-21 12:48:21 -04:00
|
|
|
it != unsatisfied_mods.end(); ++it)
|
2013-02-20 14:06:39 -05:00
|
|
|
load_mod_names.erase((*it).name);
|
2015-03-02 13:26:20 -05:00
|
|
|
if(!load_mod_names.empty()) {
|
2013-02-20 14:06:39 -05:00
|
|
|
errorstream << "The following mods could not be found:";
|
2012-12-08 12:10:54 -05:00
|
|
|
for(std::set<std::string>::iterator it = load_mod_names.begin();
|
|
|
|
it != load_mod_names.end(); ++it)
|
2013-02-20 14:06:39 -05:00
|
|
|
errorstream << " \"" << (*it) << "\"";
|
2012-12-08 12:10:54 -05:00
|
|
|
errorstream << std::endl;
|
|
|
|
}
|
|
|
|
|
2015-04-07 06:13:12 -04:00
|
|
|
//lock environment
|
|
|
|
MutexAutoLock envlock(m_env_mutex);
|
2012-03-10 08:56:24 -05:00
|
|
|
|
2014-12-30 12:30:14 -05:00
|
|
|
// Create the Map (loads map_meta.txt, overriding configured mapgen params)
|
|
|
|
ServerMap *servermap = new ServerMap(path_world, this, m_emerge);
|
|
|
|
|
2011-11-11 12:33:17 -05:00
|
|
|
// Initialize scripting
|
2012-03-10 21:15:45 -05:00
|
|
|
infostream<<"Server: Initializing Lua"<<std::endl;
|
2013-05-24 18:51:02 -04:00
|
|
|
|
2013-08-10 22:09:45 -04:00
|
|
|
m_script = new GameScripting(this);
|
2013-05-24 18:51:02 -04:00
|
|
|
|
2014-09-05 20:08:51 -04:00
|
|
|
std::string script_path = getBuiltinLuaPath() + DIR_DELIM "init.lua";
|
2013-05-24 18:51:02 -04:00
|
|
|
|
2015-10-29 14:48:10 -04:00
|
|
|
m_script->loadMod(script_path, BUILTIN_MOD_NAME);
|
2014-04-27 17:55:49 -04:00
|
|
|
|
2014-09-05 20:08:51 -04:00
|
|
|
// Print mods
|
|
|
|
infostream << "Server: Loading mods: ";
|
2012-12-08 12:10:54 -05:00
|
|
|
for(std::vector<ModSpec>::iterator i = m_mods.begin();
|
2015-08-25 16:23:05 -04:00
|
|
|
i != m_mods.end(); ++i) {
|
2012-03-10 21:15:45 -05:00
|
|
|
const ModSpec &mod = *i;
|
2014-09-05 20:08:51 -04:00
|
|
|
infostream << mod.name << " ";
|
2012-03-10 21:15:45 -05:00
|
|
|
}
|
2014-09-05 20:08:51 -04:00
|
|
|
infostream << std::endl;
|
2012-03-10 21:15:45 -05:00
|
|
|
// Load and run "mod" scripts
|
2015-10-29 14:48:10 -04:00
|
|
|
for (std::vector<ModSpec>::iterator it = m_mods.begin();
|
|
|
|
it != m_mods.end(); ++it) {
|
|
|
|
const ModSpec &mod = *it;
|
2014-09-05 20:08:51 -04:00
|
|
|
if (!string_allowed(mod.name, MODNAME_ALLOWED_CHARS)) {
|
2015-10-29 14:48:10 -04:00
|
|
|
throw ModError("Error loading mod \"" + mod.name +
|
|
|
|
"\": Mod name does not follow naming conventions: "
|
|
|
|
"Only chararacters [a-z0-9_] are allowed.");
|
2014-09-05 20:08:51 -04:00
|
|
|
}
|
2015-10-29 14:48:10 -04:00
|
|
|
std::string script_path = mod.path + DIR_DELIM + "init.lua";
|
2014-09-05 20:08:51 -04:00
|
|
|
infostream << " [" << padStringRight(mod.name, 12) << "] [\""
|
|
|
|
<< script_path << "\"]" << std::endl;
|
2015-10-29 14:48:10 -04:00
|
|
|
m_script->loadMod(script_path, mod.name);
|
2011-11-11 13:50:09 -05:00
|
|
|
}
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2012-01-02 06:31:50 -05:00
|
|
|
// Read Textures and calculate sha1 sums
|
2012-03-25 04:50:29 -04:00
|
|
|
fillMediaCache();
|
2012-01-02 06:31:50 -05:00
|
|
|
|
2012-01-12 00:10:39 -05:00
|
|
|
// Apply item aliases in the node definition manager
|
|
|
|
m_nodedef->updateAliases(m_itemdef);
|
|
|
|
|
2015-03-30 06:55:29 -04:00
|
|
|
// Apply texture overrides from texturepack/override.txt
|
|
|
|
std::string texture_path = g_settings->get("texture_path");
|
|
|
|
if (texture_path != "" && fs::IsDir(texture_path))
|
|
|
|
m_nodedef->applyTextureOverrides(texture_path + DIR_DELIM + "override.txt");
|
|
|
|
|
2015-01-04 16:32:31 -05:00
|
|
|
m_nodedef->setNodeRegistrationStatus(true);
|
|
|
|
|
2014-10-08 15:28:14 -04:00
|
|
|
// Perform pending node name resolutions
|
2015-04-16 04:12:26 -04:00
|
|
|
m_nodedef->runNodeResolveCallbacks();
|
2014-10-08 15:28:14 -04:00
|
|
|
|
Nodebox: Allow nodeboxes to "connect"
We introduce a new nodebox type "connected", and allow these nodes to
have optional nodeboxes that connect it to other connecting nodeboxes.
This is all done at scenedraw time in the client. The client will
inspect the surrounding nodes and if they are to be connected to,
it will draw the appropriate connecting nodeboxes to make those
connections.
In the node_box definition, we have to specify separate nodeboxes for
each valid connection. This allows us to make nodes that connect only
horizontally (the common case) by providing optional nodeboxes for +x,
-x, +z, -z directions. Or this allows us to make wires that can connect
up and down, by providing nodeboxes that connect it up and down (+y,
-y) as well.
The optional nodeboxes can be arrays. They are named "connect_top,
"connect_bottom", "connect_front", "connect_left", "connect_back" and
"connect_right". Here, "front" means the south facing side of the node
that has facedir = 0.
Additionally, a "fixed" nodebox list present will always be drawn,
so one can make a central post, for instance. This "fixed" nodebox
can be omitted, or it can be an array of nodeboxes.
Collision boxes are also updated in exactly the same fashion, which
allows you to walk over the upper extremities of the individual
node boxes, or stand really close to them. You can also walk up
node noxes that are small in height, all as expected, and unlike the
NDT_FENCELIKE nodes.
I've posted a screenshot demonstrating the flexibility at
http://i.imgur.com/zaJq8jo.png
In the screenshot, all connecting nodes are of this new subtype.
Transparent textures render incorrectly, Which I don't think is
related to this text, as other nodeboxes also have issues with this.
A protocol bump is performed in order to be able to send older clients
a nodeblock that is usable for them. In order to avoid abuse of users
we send older clients a "full-size" node, so that it's impossible for
them to try and walk through a fence or wall that's created in this
fashion. This was tested with a pre-bump client connected against a
server running the new protocol.
These nodes connect to other nodes, and you can select which ones
those are by specifying node names (or group names) in the
connects_to string array:
connects_to = { "group:fence", "default:wood" }
By default, nodes do not connect to anything, allowing you to create
nodes that always have to be paired in order to connect. lua_api.txt
is updated to reflect the extension to the node_box API.
Example lua code needed to generate these nodes can be found here:
https://gist.github.com/sofar/b381c8c192c8e53e6062
2016-02-25 03:16:31 -05:00
|
|
|
// unmap node names for connected nodeboxes
|
|
|
|
m_nodedef->mapNodeboxConnections();
|
|
|
|
|
2015-04-03 19:33:34 -04:00
|
|
|
// init the recipe hashes to speed up crafting
|
|
|
|
m_craftdef->initHashes(this);
|
|
|
|
|
2013-01-22 22:32:30 -05:00
|
|
|
// Initialize Environment
|
2014-05-30 16:04:07 -04:00
|
|
|
m_env = new ServerEnvironment(servermap, m_script, this, m_path_world);
|
2014-01-30 18:24:00 -05:00
|
|
|
|
|
|
|
m_clients.setEnv(m_env);
|
|
|
|
|
2016-06-24 18:15:56 -04:00
|
|
|
if (!servermap->settings_mgr.makeMapgenParams())
|
|
|
|
FATAL_ERROR("Couldn't create any mapgen type");
|
|
|
|
|
2013-06-27 17:06:52 -04:00
|
|
|
// Initialize mapgens
|
2016-06-24 18:15:56 -04:00
|
|
|
m_emerge->initMapgens(servermap->getMapgenParams());
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2015-02-17 14:09:36 -05:00
|
|
|
m_enable_rollback_recording = g_settings->getBool("enable_rollback_recording");
|
|
|
|
if (m_enable_rollback_recording) {
|
|
|
|
// Create rollback manager
|
|
|
|
m_rollback = new RollbackManager(m_path_world, this);
|
|
|
|
}
|
|
|
|
|
2011-11-11 19:25:30 -05:00
|
|
|
// Give environment reference to scripting api
|
2013-05-24 18:51:02 -04:00
|
|
|
m_script->initializeEnvironment(m_env);
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-05-22 10:00:09 -04:00
|
|
|
// Register us to receive map edit events
|
2013-01-06 14:40:24 -05:00
|
|
|
servermap->addEventReceiver(this);
|
2011-02-22 19:49:57 -05:00
|
|
|
|
2011-05-22 10:00:09 -04:00
|
|
|
// If file exists, load environment metadata
|
2016-02-09 01:08:31 -05:00
|
|
|
if (fs::PathExists(m_path_world + DIR_DELIM "env_meta.txt")) {
|
|
|
|
infostream << "Server: Loading environment metadata" << std::endl;
|
2014-05-30 16:04:07 -04:00
|
|
|
m_env->loadMeta();
|
2016-02-09 01:08:31 -05:00
|
|
|
} else {
|
|
|
|
m_env->loadDefaultMeta();
|
2011-05-22 10:00:09 -04:00
|
|
|
}
|
|
|
|
|
2014-05-30 16:04:07 -04:00
|
|
|
// Add some test ActiveBlockModifiers to environment
|
2011-11-27 17:45:34 -05:00
|
|
|
add_legacy_abms(m_env, m_nodedef);
|
2013-02-24 09:39:07 -05:00
|
|
|
|
|
|
|
m_liquid_transform_every = g_settings->getFloat("liquid_update");
|
2016-10-04 12:17:12 -04:00
|
|
|
m_max_chatmessage_length = g_settings->getU16("chat_message_max_size");
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
Server::~Server()
|
|
|
|
{
|
2012-03-10 21:15:45 -05:00
|
|
|
infostream<<"Server destructing"<<std::endl;
|
2011-04-21 12:35:17 -04:00
|
|
|
|
2014-05-30 16:04:07 -04:00
|
|
|
// Send shutdown message
|
|
|
|
SendChatMessage(PEER_ID_INEXISTENT, L"*** Server shutting down");
|
2012-09-08 14:44:26 -04:00
|
|
|
|
2012-11-30 12:41:13 -05:00
|
|
|
{
|
2015-04-07 06:13:12 -04:00
|
|
|
MutexAutoLock envlock(m_env_mutex);
|
2012-11-30 12:41:13 -05:00
|
|
|
|
2014-05-30 16:04:07 -04:00
|
|
|
// Execute script shutdown hooks
|
2013-05-24 18:51:02 -04:00
|
|
|
m_script->on_shutdown();
|
2011-02-15 09:11:24 -05:00
|
|
|
|
2015-07-16 11:37:46 -04:00
|
|
|
infostream << "Server: Saving players" << std::endl;
|
2014-05-30 16:04:07 -04:00
|
|
|
m_env->saveLoadedPlayers();
|
2011-05-22 10:00:09 -04:00
|
|
|
|
2015-07-17 00:30:21 -04:00
|
|
|
infostream << "Server: Kicking players" << std::endl;
|
2015-07-17 10:40:41 -04:00
|
|
|
std::string kick_msg;
|
|
|
|
bool reconnect = false;
|
|
|
|
if (getShutdownRequested()) {
|
|
|
|
reconnect = m_shutdown_ask_reconnect;
|
|
|
|
kick_msg = m_shutdown_msg;
|
|
|
|
}
|
|
|
|
if (kick_msg == "") {
|
|
|
|
kick_msg = g_settings->get("kick_msg_shutdown");
|
|
|
|
}
|
|
|
|
m_env->kickAllPlayers(SERVER_ACCESSDENIED_SHUTDOWN,
|
|
|
|
kick_msg, reconnect);
|
2015-07-16 11:37:46 -04:00
|
|
|
|
|
|
|
infostream << "Server: Saving environment metadata" << std::endl;
|
2014-05-30 16:04:07 -04:00
|
|
|
m_env->saveMeta();
|
2011-10-14 05:39:25 -04:00
|
|
|
}
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2014-05-30 16:04:07 -04:00
|
|
|
// Stop threads
|
2010-11-26 18:02:21 -05:00
|
|
|
stop();
|
2013-08-10 22:09:45 -04:00
|
|
|
delete m_thread;
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2014-01-26 01:12:18 -05:00
|
|
|
// stop all emerge threads before deleting players that may have
|
|
|
|
// requested blocks to be emerged
|
|
|
|
m_emerge->stopThreads();
|
2013-04-07 16:27:27 -04:00
|
|
|
|
2012-03-23 14:23:03 -04:00
|
|
|
// Delete things in the reverse order of creation
|
2014-01-26 01:12:18 -05:00
|
|
|
delete m_emerge;
|
2016-06-24 18:15:56 -04:00
|
|
|
delete m_env;
|
2012-07-26 15:06:45 -04:00
|
|
|
delete m_rollback;
|
2013-08-10 22:09:45 -04:00
|
|
|
delete m_banmanager;
|
2012-03-23 14:23:03 -04:00
|
|
|
delete m_event;
|
2012-01-12 00:10:39 -05:00
|
|
|
delete m_itemdef;
|
2011-11-16 07:08:31 -05:00
|
|
|
delete m_nodedef;
|
2011-11-29 10:15:18 -05:00
|
|
|
delete m_craftdef;
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-11-11 12:33:17 -05:00
|
|
|
// Deinitialize scripting
|
|
|
|
infostream<<"Server: Deinitializing scripting"<<std::endl;
|
2013-05-24 18:51:02 -04:00
|
|
|
delete m_script;
|
2012-07-24 13:57:17 -04:00
|
|
|
|
|
|
|
// Delete detached inventories
|
2014-05-30 16:04:07 -04:00
|
|
|
for (std::map<std::string, Inventory*>::iterator
|
|
|
|
i = m_detached_inventories.begin();
|
2015-08-25 16:23:05 -04:00
|
|
|
i != m_detached_inventories.end(); ++i) {
|
2014-05-30 16:04:07 -04:00
|
|
|
delete i->second;
|
2012-07-24 13:57:17 -04:00
|
|
|
}
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
|
|
|
|
2014-02-05 15:24:46 -05:00
|
|
|
void Server::start(Address bind_addr)
|
2010-11-26 18:02:21 -05:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2015-01-21 14:32:12 -05:00
|
|
|
|
|
|
|
m_bind_addr = bind_addr;
|
|
|
|
|
2014-02-05 15:24:46 -05:00
|
|
|
infostream<<"Starting server on "
|
|
|
|
<< bind_addr.serializeString() <<"..."<<std::endl;
|
2012-03-11 14:45:43 -04:00
|
|
|
|
2010-11-26 18:02:21 -05:00
|
|
|
// Stop thread if already running
|
2015-04-07 06:13:12 -04:00
|
|
|
m_thread->stop();
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2010-11-26 18:02:21 -05:00
|
|
|
// Initialize connection
|
2011-10-20 16:04:09 -04:00
|
|
|
m_con.SetTimeoutMs(30);
|
2014-02-05 15:24:46 -05:00
|
|
|
m_con.Serve(bind_addr);
|
2010-11-26 18:02:21 -05:00
|
|
|
|
|
|
|
// Start thread
|
2015-04-07 06:13:12 -04:00
|
|
|
m_thread->start();
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2012-03-10 21:15:45 -05:00
|
|
|
// ASCII art for the win!
|
|
|
|
actionstream
|
|
|
|
<<" .__ __ __ "<<std::endl
|
|
|
|
<<" _____ |__| ____ _____/ |_ ____ _______/ |_ "<<std::endl
|
|
|
|
<<" / \\| |/ \\_/ __ \\ __\\/ __ \\ / ___/\\ __\\"<<std::endl
|
|
|
|
<<"| Y Y \\ | | \\ ___/| | \\ ___/ \\___ \\ | | "<<std::endl
|
|
|
|
<<"|__|_| /__|___| /\\___ >__| \\___ >____ > |__| "<<std::endl
|
|
|
|
<<" \\/ \\/ \\/ \\/ \\/ "<<std::endl;
|
2012-03-11 09:49:14 -04:00
|
|
|
actionstream<<"World at ["<<m_path_world<<"]"<<std::endl;
|
2012-03-11 08:54:23 -04:00
|
|
|
actionstream<<"Server for gameid=\""<<m_gamespec.id
|
2014-02-05 15:24:46 -05:00
|
|
|
<<"\" listening on "<<bind_addr.serializeString()<<":"
|
|
|
|
<<bind_addr.getPort() << "."<<std::endl;
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void Server::stop()
|
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Server: Stopping and waiting threads"<<std::endl;
|
2011-02-21 09:10:36 -05:00
|
|
|
|
2010-11-26 18:02:21 -05:00
|
|
|
// Stop threads (set run=false first so both start stopping)
|
2015-04-07 06:13:12 -04:00
|
|
|
m_thread->stop();
|
2013-02-13 22:43:15 -05:00
|
|
|
//m_emergethread.setRun(false);
|
2015-04-07 06:13:12 -04:00
|
|
|
m_thread->wait();
|
2013-02-13 22:43:15 -05:00
|
|
|
//m_emergethread.stop();
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Server: Threads stopped"<<std::endl;
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void Server::step(float dtime)
|
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2010-11-26 18:02:21 -05:00
|
|
|
// Limit a bit
|
2015-10-29 14:48:10 -04:00
|
|
|
if (dtime > 2.0)
|
2010-11-26 18:02:21 -05:00
|
|
|
dtime = 2.0;
|
|
|
|
{
|
2015-04-07 06:13:12 -04:00
|
|
|
MutexAutoLock lock(m_step_dtime_mutex);
|
2010-11-26 18:02:21 -05:00
|
|
|
m_step_dtime += dtime;
|
|
|
|
}
|
2015-03-16 21:17:27 -04:00
|
|
|
// Throw if fatal error occurred in thread
|
2012-03-11 14:45:43 -04:00
|
|
|
std::string async_err = m_async_fatal_error.get();
|
2015-10-29 14:48:10 -04:00
|
|
|
if (!async_err.empty()) {
|
|
|
|
if (!m_simple_singleplayer_mode) {
|
2015-07-17 10:40:41 -04:00
|
|
|
m_env->kickAllPlayers(SERVER_ACCESSDENIED_CRASH,
|
|
|
|
g_settings->get("kick_msg_crash"),
|
|
|
|
g_settings->getBool("ask_reconnect_on_crash"));
|
2015-03-17 04:13:12 -04:00
|
|
|
}
|
2015-10-29 14:48:10 -04:00
|
|
|
throw ServerError(async_err);
|
2012-03-11 14:45:43 -04:00
|
|
|
}
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
|
|
|
|
2014-01-06 14:05:28 -05:00
|
|
|
void Server::AsyncRunStep(bool initial_step)
|
2010-11-26 18:02:21 -05:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-10-16 14:16:44 -04:00
|
|
|
g_profiler->add("Server::AsyncRunStep (num)", 1);
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2010-11-26 18:02:21 -05:00
|
|
|
float dtime;
|
|
|
|
{
|
2015-04-07 06:13:12 -04:00
|
|
|
MutexAutoLock lock1(m_step_dtime_mutex);
|
2010-11-26 18:02:21 -05:00
|
|
|
dtime = m_step_dtime;
|
|
|
|
}
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-05-30 17:15:43 -04:00
|
|
|
{
|
|
|
|
// Send blocks to clients
|
|
|
|
SendBlocks(dtime);
|
|
|
|
}
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2014-01-06 14:05:28 -05:00
|
|
|
if((dtime < 0.001) && (initial_step == false))
|
2010-12-13 14:32:35 -05:00
|
|
|
return;
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-10-16 14:16:44 -04:00
|
|
|
g_profiler->add("Server::AsyncRunStep with dtime (num)", 1);
|
2011-05-31 04:59:51 -04:00
|
|
|
|
2011-10-16 07:57:53 -04:00
|
|
|
//infostream<<"Server steps "<<dtime<<std::endl;
|
|
|
|
//infostream<<"Server::AsyncRunStep(): dtime="<<dtime<<std::endl;
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2010-12-13 14:32:35 -05:00
|
|
|
{
|
2015-04-07 06:13:12 -04:00
|
|
|
MutexAutoLock lock1(m_step_dtime_mutex);
|
2010-12-19 09:51:45 -05:00
|
|
|
m_step_dtime -= dtime;
|
2010-12-13 14:32:35 -05:00
|
|
|
}
|
2010-12-24 10:08:50 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
Update uptime
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
m_uptime.set(m_uptime.get() + dtime);
|
|
|
|
}
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
handlePeerChanges();
|
2011-08-22 14:27:11 -04:00
|
|
|
|
2010-12-20 07:04:31 -05:00
|
|
|
/*
|
2012-03-16 10:34:30 -04:00
|
|
|
Update time of day and overall game time
|
2010-12-20 07:04:31 -05:00
|
|
|
*/
|
2015-03-04 05:46:31 -05:00
|
|
|
m_env->setTimeOfDaySpeed(g_settings->getFloat("time_speed"));
|
2011-05-22 10:00:09 -04:00
|
|
|
|
2015-03-04 05:46:31 -05:00
|
|
|
/*
|
|
|
|
Send to clients at constant intervals
|
|
|
|
*/
|
2010-12-20 07:04:31 -05:00
|
|
|
|
2015-03-04 05:46:31 -05:00
|
|
|
m_time_of_day_send_timer -= dtime;
|
|
|
|
if(m_time_of_day_send_timer < 0.0) {
|
|
|
|
m_time_of_day_send_timer = g_settings->getFloat("time_send_interval");
|
|
|
|
u16 time = m_env->getTimeOfDay();
|
|
|
|
float time_speed = g_settings->getFloat("time_speed");
|
|
|
|
SendTimeOfDay(PEER_ID_INEXISTENT, time, time_speed);
|
2010-12-20 07:04:31 -05:00
|
|
|
}
|
2010-12-13 14:32:35 -05:00
|
|
|
|
2010-11-26 18:02:21 -05:00
|
|
|
{
|
2015-04-07 06:13:12 -04:00
|
|
|
MutexAutoLock lock(m_env_mutex);
|
2013-08-03 16:16:37 -04:00
|
|
|
// Figure out and report maximum lag to environment
|
|
|
|
float max_lag = m_env->getMaxLagEstimate();
|
|
|
|
max_lag *= 0.9998; // Decrease slowly (about half per 5 minutes)
|
|
|
|
if(dtime > max_lag){
|
|
|
|
if(dtime > 0.1 && dtime > max_lag * 2.0)
|
|
|
|
infostream<<"Server: Maximum lag peaked to "<<dtime
|
|
|
|
<<" s"<<std::endl;
|
|
|
|
max_lag = dtime;
|
|
|
|
}
|
|
|
|
m_env->reportMaxLagEstimate(max_lag);
|
2011-06-26 17:27:17 -04:00
|
|
|
// Step environment
|
2011-10-16 14:16:44 -04:00
|
|
|
ScopeProfiler sp(g_profiler, "SEnv step");
|
2011-10-16 15:39:35 -04:00
|
|
|
ScopeProfiler sp2(g_profiler, "SEnv step avg", SPT_AVG);
|
2011-11-11 12:33:17 -05:00
|
|
|
m_env->step(dtime);
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2014-12-12 03:06:36 -05:00
|
|
|
static const float map_timer_and_unload_dtime = 2.92;
|
2011-06-26 17:27:17 -04:00
|
|
|
if(m_map_timer_and_unload_interval.step(dtime, map_timer_and_unload_dtime))
|
|
|
|
{
|
2015-04-07 06:13:12 -04:00
|
|
|
MutexAutoLock lock(m_env_mutex);
|
2011-06-26 17:27:17 -04:00
|
|
|
// Run Map's timers and unload unused data
|
2011-10-12 06:53:38 -04:00
|
|
|
ScopeProfiler sp(g_profiler, "Server: map timer and unload");
|
2011-11-11 12:33:17 -05:00
|
|
|
m_env->getMap().timerUpdate(map_timer_and_unload_dtime,
|
2015-08-10 16:24:47 -04:00
|
|
|
g_settings->getFloat("server_unload_unused_data_timeout"),
|
2015-10-04 02:50:04 -04:00
|
|
|
U32_MAX);
|
2011-06-26 17:27:17 -04:00
|
|
|
}
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2015-07-25 01:43:32 -04:00
|
|
|
/*
|
|
|
|
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();
|
2015-11-09 00:04:24 -05:00
|
|
|
handleChatInterfaceEvent(evt);
|
2015-07-25 01:43:32 -04:00
|
|
|
delete evt;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
m_admin_chat->outgoing_queue.push_back(
|
|
|
|
new ChatEventTimeInfo(m_env->getGameTime(), m_env->getTimeOfDay()));
|
|
|
|
}
|
|
|
|
|
2010-11-26 18:02:21 -05:00
|
|
|
/*
|
|
|
|
Do background stuff
|
|
|
|
*/
|
2011-11-26 07:03:56 -05:00
|
|
|
|
|
|
|
/* Transform liquids */
|
2011-01-17 14:15:31 -05:00
|
|
|
m_liquid_transform_timer += dtime;
|
2013-02-24 09:39:07 -05:00
|
|
|
if(m_liquid_transform_timer >= m_liquid_transform_every)
|
2011-01-17 07:57:37 -05:00
|
|
|
{
|
2013-02-24 09:39:07 -05:00
|
|
|
m_liquid_transform_timer -= m_liquid_transform_every;
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2015-04-07 06:13:12 -04:00
|
|
|
MutexAutoLock lock(m_env_mutex);
|
2011-05-30 17:15:43 -04:00
|
|
|
|
2011-10-12 06:53:38 -04:00
|
|
|
ScopeProfiler sp(g_profiler, "Server: liquid transform");
|
2011-05-30 17:15:43 -04:00
|
|
|
|
2012-12-20 12:19:49 -05:00
|
|
|
std::map<v3s16, MapBlock*> modified_blocks;
|
2011-11-11 12:33:17 -05:00
|
|
|
m_env->getMap().transformLiquids(modified_blocks);
|
2012-11-25 21:16:48 -05:00
|
|
|
#if 0
|
2011-01-17 14:15:31 -05:00
|
|
|
/*
|
|
|
|
Update lighting
|
|
|
|
*/
|
|
|
|
core::map<v3s16, MapBlock*> lighting_modified_blocks;
|
2011-11-11 12:33:17 -05:00
|
|
|
ServerMap &map = ((ServerMap&)m_env->getMap());
|
2011-01-17 14:15:31 -05:00
|
|
|
map.updateLighting(modified_blocks, lighting_modified_blocks);
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-01-17 14:15:31 -05:00
|
|
|
// 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
|
|
|
|
*/
|
2014-12-12 09:55:40 -05:00
|
|
|
if(!modified_blocks.empty())
|
2011-01-17 14:15:31 -05:00
|
|
|
{
|
2014-01-30 18:24:00 -05:00
|
|
|
SetBlocksNotSent(modified_blocks);
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
|
|
|
}
|
2014-01-30 18:24:00 -05:00
|
|
|
m_clients.step(dtime);
|
2013-02-21 17:00:44 -05:00
|
|
|
|
2014-01-06 17:50:45 -05:00
|
|
|
m_lag += (m_lag > dtime ? -1 : 1) * dtime/100;
|
2013-02-21 17:00:44 -05:00
|
|
|
#if USE_CURL
|
|
|
|
// send masterserver announce
|
|
|
|
{
|
|
|
|
float &counter = m_masterserver_timer;
|
2014-01-30 18:24:00 -05:00
|
|
|
if(!isSingleplayer() && (!counter || counter >= 300.0) &&
|
2014-06-20 00:59:39 -04:00
|
|
|
g_settings->getBool("server_announce"))
|
2013-02-21 17:00:44 -05:00
|
|
|
{
|
2014-06-20 00:59:39 -04:00
|
|
|
ServerList::sendAnnounce(counter ? "update" : "start",
|
2015-01-21 14:32:12 -05:00
|
|
|
m_bind_addr.getPort(),
|
2014-06-20 00:59:39 -04:00
|
|
|
m_clients.getPlayerNames(),
|
|
|
|
m_uptime.get(),
|
|
|
|
m_env->getGameTime(),
|
|
|
|
m_lag,
|
|
|
|
m_gamespec.id,
|
2016-06-24 18:15:56 -04:00
|
|
|
Mapgen::getMapgenName(m_emerge->mgparams->mgtype),
|
2014-06-20 00:59:39 -04:00
|
|
|
m_mods);
|
2013-02-21 17:00:44 -05:00
|
|
|
counter = 0.01;
|
|
|
|
}
|
|
|
|
counter += dtime;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-12-18 06:10:37 -05:00
|
|
|
/*
|
2011-02-20 17:45:14 -05:00
|
|
|
Check added and deleted active objects
|
2010-12-18 06:10:37 -05:00
|
|
|
*/
|
|
|
|
{
|
2011-10-16 07:57:53 -04:00
|
|
|
//infostream<<"Server: Checking added and deleted active objects"<<std::endl;
|
2015-04-07 06:13:12 -04:00
|
|
|
MutexAutoLock envlock(m_env_mutex);
|
2011-05-30 17:15:43 -04:00
|
|
|
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.lock();
|
2016-10-05 03:03:55 -04:00
|
|
|
UNORDERED_MAP<u16, RemoteClient*> clients = m_clients.getClientList();
|
2011-10-16 14:16:44 -04:00
|
|
|
ScopeProfiler sp(g_profiler, "Server: checking added and deleted objs");
|
2011-05-30 17:15:43 -04:00
|
|
|
|
2011-02-22 19:49:57 -05:00
|
|
|
// Radius inside which objects are active
|
2015-09-02 15:21:55 -04:00
|
|
|
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)
|
2014-11-08 08:35:55 -05:00
|
|
|
player_radius = radius;
|
|
|
|
|
2016-10-05 03:03:55 -04:00
|
|
|
for (UNORDERED_MAP<u16, RemoteClient*>::iterator i = clients.begin();
|
2015-08-05 16:29:47 -04:00
|
|
|
i != clients.end(); ++i) {
|
2012-12-20 12:19:49 -05:00
|
|
|
RemoteClient *client = i->second;
|
2011-12-01 18:18:25 -05:00
|
|
|
|
|
|
|
// If definitions and textures have not been sent, don't
|
|
|
|
// send objects either
|
2014-06-28 02:02:38 -04:00
|
|
|
if (client->getState() < CS_DefinitionsSent)
|
2011-12-01 18:18:25 -05:00
|
|
|
continue;
|
|
|
|
|
2011-11-11 12:33:17 -05:00
|
|
|
Player *player = m_env->getPlayer(client->peer_id);
|
2016-10-05 03:03:55 -04:00
|
|
|
if (player == NULL) {
|
2011-06-02 13:09:30 -04:00
|
|
|
// This can happen if the client timeouts somehow
|
2015-10-14 02:39:30 -04:00
|
|
|
/*warningstream<<FUNCTION_NAME<<": Client "
|
2011-06-02 13:09:30 -04:00
|
|
|
<<client->peer_id
|
|
|
|
<<" has no associated player"<<std::endl;*/
|
2011-02-22 19:49:57 -05:00
|
|
|
continue;
|
2011-04-07 17:47:14 -04:00
|
|
|
}
|
2011-02-20 17:45:14 -05:00
|
|
|
|
2015-08-05 16:29:47 -04:00
|
|
|
std::queue<u16> removed_objects;
|
|
|
|
std::queue<u16> added_objects;
|
|
|
|
m_env->getRemovedActiveObjects(player, radius, player_radius,
|
2011-02-20 17:45:14 -05:00
|
|
|
client->m_known_objects, removed_objects);
|
2015-08-05 16:29:47 -04:00
|
|
|
m_env->getAddedActiveObjects(player, radius, player_radius,
|
2011-02-20 17:45:14 -05:00
|
|
|
client->m_known_objects, added_objects);
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-02-20 17:45:14 -05:00
|
|
|
// Ignore if nothing happened
|
2015-08-05 16:29:47 -04:00
|
|
|
if (removed_objects.empty() && added_objects.empty()) {
|
2011-02-20 17:45:14 -05:00
|
|
|
continue;
|
2011-04-07 17:47:14 -04:00
|
|
|
}
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-02-20 17:45:14 -05:00
|
|
|
std::string data_buffer;
|
2010-12-18 06:10:37 -05:00
|
|
|
|
2011-02-20 17:45:14 -05:00
|
|
|
char buf[4];
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-02-20 17:45:14 -05:00
|
|
|
// Handle removed objects
|
|
|
|
writeU16((u8*)buf, removed_objects.size());
|
|
|
|
data_buffer.append(buf, 2);
|
2015-08-05 16:29:47 -04:00
|
|
|
while (!removed_objects.empty()) {
|
2011-02-20 17:45:14 -05:00
|
|
|
// Get object
|
2015-08-05 16:29:47 -04:00
|
|
|
u16 id = removed_objects.front();
|
2011-11-11 12:33:17 -05:00
|
|
|
ServerActiveObject* obj = m_env->getActiveObject(id);
|
2010-12-18 06:10:37 -05:00
|
|
|
|
2011-02-20 17:45:14 -05:00
|
|
|
// Add to data buffer for sending
|
2012-12-20 12:19:49 -05:00
|
|
|
writeU16((u8*)buf, id);
|
2011-02-20 17:45:14 -05:00
|
|
|
data_buffer.append(buf, 2);
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-02-20 17:45:14 -05:00
|
|
|
// Remove from known objects
|
2012-12-20 12:19:49 -05:00
|
|
|
client->m_known_objects.erase(id);
|
2010-12-18 06:10:37 -05:00
|
|
|
|
2011-02-20 17:45:14 -05:00
|
|
|
if(obj && obj->m_known_by_count > 0)
|
|
|
|
obj->m_known_by_count--;
|
2015-08-05 16:29:47 -04:00
|
|
|
removed_objects.pop();
|
2011-02-20 17:45:14 -05:00
|
|
|
}
|
2010-12-18 06:10:37 -05:00
|
|
|
|
2011-02-20 17:45:14 -05:00
|
|
|
// Handle added objects
|
|
|
|
writeU16((u8*)buf, added_objects.size());
|
|
|
|
data_buffer.append(buf, 2);
|
2015-08-05 16:29:47 -04:00
|
|
|
while (!added_objects.empty()) {
|
2011-02-20 17:45:14 -05:00
|
|
|
// Get object
|
2015-08-05 16:29:47 -04:00
|
|
|
u16 id = added_objects.front();
|
2011-11-11 12:33:17 -05:00
|
|
|
ServerActiveObject* obj = m_env->getActiveObject(id);
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-02-20 17:45:14 -05:00
|
|
|
// Get object type
|
|
|
|
u8 type = ACTIVEOBJECT_TYPE_INVALID;
|
|
|
|
if(obj == NULL)
|
2015-10-14 02:39:30 -04:00
|
|
|
warningstream<<FUNCTION_NAME
|
2011-02-20 17:45:14 -05:00
|
|
|
<<": NULL object"<<std::endl;
|
|
|
|
else
|
2012-03-29 09:10:11 -04:00
|
|
|
type = obj->getSendType();
|
2011-02-20 17:45:14 -05:00
|
|
|
|
|
|
|
// Add to data buffer for sending
|
|
|
|
writeU16((u8*)buf, id);
|
|
|
|
data_buffer.append(buf, 2);
|
|
|
|
writeU8((u8*)buf, type);
|
|
|
|
data_buffer.append(buf, 1);
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-04-11 04:05:40 -04:00
|
|
|
if(obj)
|
|
|
|
data_buffer.append(serializeLongString(
|
2012-11-26 17:47:03 -05:00
|
|
|
obj->getClientInitializationData(client->net_proto_version)));
|
2011-04-11 04:05:40 -04:00
|
|
|
else
|
|
|
|
data_buffer.append(serializeLongString(""));
|
2011-02-21 09:10:36 -05:00
|
|
|
|
2011-02-20 17:45:14 -05:00
|
|
|
// Add to known objects
|
2012-12-20 12:19:49 -05:00
|
|
|
client->m_known_objects.insert(id);
|
2011-02-20 17:45:14 -05:00
|
|
|
|
|
|
|
if(obj)
|
|
|
|
obj->m_known_by_count++;
|
2015-08-05 16:29:47 -04:00
|
|
|
|
|
|
|
added_objects.pop();
|
2010-12-23 15:35:53 -05:00
|
|
|
}
|
2010-12-18 06:10:37 -05:00
|
|
|
|
2015-03-16 07:01:40 -04:00
|
|
|
u32 pktSize = SendActiveObjectRemoveAdd(client->peer_id, data_buffer);
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
verbosestream << "Server: Sent object remove/add: "
|
|
|
|
<< removed_objects.size() << " removed, "
|
|
|
|
<< added_objects.size() << " added, "
|
2015-03-16 07:01:40 -04:00
|
|
|
<< "packet size is " << pktSize << std::endl;
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
}
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.unlock();
|
2011-02-20 17:45:14 -05:00
|
|
|
}
|
2010-12-18 06:10:37 -05:00
|
|
|
|
2011-02-20 17:45:14 -05:00
|
|
|
/*
|
|
|
|
Send object messages
|
|
|
|
*/
|
|
|
|
{
|
2015-04-07 06:13:12 -04:00
|
|
|
MutexAutoLock envlock(m_env_mutex);
|
2011-12-02 10:19:42 -05:00
|
|
|
ScopeProfiler sp(g_profiler, "Server: sending object messages");
|
2011-05-30 17:15:43 -04:00
|
|
|
|
2011-02-20 17:45:14 -05:00
|
|
|
// Key = object id
|
|
|
|
// Value = data sent by object
|
2015-03-05 05:18:17 -05:00
|
|
|
std::map<u16, std::vector<ActiveObjectMessage>* > buffered_messages;
|
2011-02-20 17:45:14 -05:00
|
|
|
|
|
|
|
// Get active object messages from environment
|
2015-03-05 05:18:17 -05:00
|
|
|
for(;;) {
|
2011-11-11 12:33:17 -05:00
|
|
|
ActiveObjectMessage aom = m_env->getActiveObjectMessage();
|
2015-03-05 05:18:17 -05:00
|
|
|
if (aom.id == 0)
|
2011-02-20 17:45:14 -05:00
|
|
|
break;
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2015-03-05 05:18:17 -05:00
|
|
|
std::vector<ActiveObjectMessage>* message_list = NULL;
|
|
|
|
std::map<u16, std::vector<ActiveObjectMessage>* >::iterator n;
|
2011-02-20 17:45:14 -05:00
|
|
|
n = buffered_messages.find(aom.id);
|
2015-03-05 05:18:17 -05:00
|
|
|
if (n == buffered_messages.end()) {
|
|
|
|
message_list = new std::vector<ActiveObjectMessage>;
|
2012-12-20 12:19:49 -05:00
|
|
|
buffered_messages[aom.id] = message_list;
|
2010-12-18 06:10:37 -05:00
|
|
|
}
|
2015-03-05 05:18:17 -05:00
|
|
|
else {
|
2012-12-20 12:19:49 -05:00
|
|
|
message_list = n->second;
|
2010-12-18 06:10:37 -05:00
|
|
|
}
|
2011-02-20 17:45:14 -05:00
|
|
|
message_list->push_back(aom);
|
|
|
|
}
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.lock();
|
2016-10-05 03:03:55 -04:00
|
|
|
UNORDERED_MAP<u16, RemoteClient*> clients = m_clients.getClientList();
|
2011-02-20 17:45:14 -05:00
|
|
|
// Route data to every client
|
2016-10-05 03:03:55 -04:00
|
|
|
for (UNORDERED_MAP<u16, RemoteClient*>::iterator i = clients.begin();
|
2015-03-05 05:18:17 -05:00
|
|
|
i != clients.end(); ++i) {
|
2012-12-20 12:19:49 -05:00
|
|
|
RemoteClient *client = i->second;
|
2011-02-20 17:45:14 -05:00
|
|
|
std::string reliable_data;
|
|
|
|
std::string unreliable_data;
|
|
|
|
// Go through all objects in message buffer
|
2015-03-05 05:18:17 -05:00
|
|
|
for (std::map<u16, std::vector<ActiveObjectMessage>* >::iterator
|
2012-12-20 12:19:49 -05:00
|
|
|
j = buffered_messages.begin();
|
2015-03-05 05:18:17 -05:00
|
|
|
j != buffered_messages.end(); ++j) {
|
2011-02-20 17:45:14 -05:00
|
|
|
// If object is not known by client, skip it
|
2012-12-20 12:19:49 -05:00
|
|
|
u16 id = j->first;
|
2015-03-05 05:18:17 -05:00
|
|
|
if (client->m_known_objects.find(id) == client->m_known_objects.end())
|
2011-02-20 17:45:14 -05:00
|
|
|
continue;
|
2015-03-05 05:18:17 -05:00
|
|
|
|
2011-02-20 17:45:14 -05:00
|
|
|
// Get message list of object
|
2015-03-05 05:18:17 -05:00
|
|
|
std::vector<ActiveObjectMessage>* list = j->second;
|
2011-02-20 17:45:14 -05:00
|
|
|
// Go through every message
|
2015-03-05 05:18:17 -05:00
|
|
|
for (std::vector<ActiveObjectMessage>::iterator
|
|
|
|
k = list->begin(); k != list->end(); ++k) {
|
2011-02-20 17:45:14 -05:00
|
|
|
// Compose the full new data with header
|
|
|
|
ActiveObjectMessage aom = *k;
|
|
|
|
std::string new_data;
|
2011-02-21 09:10:36 -05:00
|
|
|
// Add object id
|
|
|
|
char buf[2];
|
|
|
|
writeU16((u8*)&buf[0], aom.id);
|
|
|
|
new_data.append(buf, 2);
|
2011-02-20 17:45:14 -05:00
|
|
|
// Add data
|
2011-02-21 09:10:36 -05:00
|
|
|
new_data += serializeString(aom.datastring);
|
2011-02-20 17:45:14 -05:00
|
|
|
// Add data to buffer
|
|
|
|
if(aom.reliable)
|
|
|
|
reliable_data += new_data;
|
|
|
|
else
|
|
|
|
unreliable_data += new_data;
|
|
|
|
}
|
2010-12-18 06:10:37 -05:00
|
|
|
}
|
|
|
|
/*
|
2011-02-20 17:45:14 -05:00
|
|
|
reliable_data and unreliable_data are now ready.
|
|
|
|
Send them.
|
2010-12-18 06:10:37 -05:00
|
|
|
*/
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
if(reliable_data.size() > 0) {
|
2015-03-16 07:01:40 -04:00
|
|
|
SendActiveObjectMessages(client->peer_id, reliable_data);
|
2010-12-18 06:10:37 -05:00
|
|
|
}
|
2011-02-21 09:10:36 -05:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
if(unreliable_data.size() > 0) {
|
2015-03-17 04:16:39 -04:00
|
|
|
SendActiveObjectMessages(client->peer_id, unreliable_data, false);
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
}
|
2011-02-20 17:45:14 -05:00
|
|
|
}
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.unlock();
|
2011-02-20 17:45:14 -05:00
|
|
|
|
|
|
|
// Clear buffered_messages
|
2015-03-05 05:18:17 -05:00
|
|
|
for(std::map<u16, std::vector<ActiveObjectMessage>* >::iterator
|
2012-12-20 12:19:49 -05:00
|
|
|
i = buffered_messages.begin();
|
2015-03-05 05:18:17 -05:00
|
|
|
i != buffered_messages.end(); ++i) {
|
2012-12-20 12:19:49 -05:00
|
|
|
delete i->second;
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
2010-12-18 06:10:37 -05:00
|
|
|
}
|
2010-11-26 18:02:21 -05:00
|
|
|
|
2011-02-22 19:49:57 -05:00
|
|
|
/*
|
|
|
|
Send queued-for-sending map edit events.
|
|
|
|
*/
|
|
|
|
{
|
2014-01-30 18:24:00 -05:00
|
|
|
// We will be accessing the environment
|
2015-04-07 06:13:12 -04:00
|
|
|
MutexAutoLock lock(m_env_mutex);
|
2012-03-28 05:51:47 -04:00
|
|
|
|
2011-06-24 21:25:14 -04:00
|
|
|
// Don't send too many at a time
|
2011-06-25 20:14:52 -04:00
|
|
|
//u32 count = 0;
|
|
|
|
|
|
|
|
// Single change sending is disabled if queue size is not small
|
|
|
|
bool disable_single_change_sending = false;
|
|
|
|
if(m_unsent_map_edit_queue.size() >= 4)
|
|
|
|
disable_single_change_sending = true;
|
|
|
|
|
2012-03-10 21:15:45 -05:00
|
|
|
int event_count = m_unsent_map_edit_queue.size();
|
2011-06-26 17:27:17 -04:00
|
|
|
|
|
|
|
// We'll log the amount of each
|
|
|
|
Profiler prof;
|
|
|
|
|
2011-02-22 19:49:57 -05:00
|
|
|
while(m_unsent_map_edit_queue.size() != 0)
|
|
|
|
{
|
2015-03-04 11:48:07 -05:00
|
|
|
MapEditEvent* event = m_unsent_map_edit_queue.front();
|
|
|
|
m_unsent_map_edit_queue.pop();
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-06-24 21:25:14 -04:00
|
|
|
// Players far away from the change are stored here.
|
|
|
|
// Instead of sending the changes, MapBlocks are set not sent
|
|
|
|
// for them.
|
2015-03-05 05:18:17 -05:00
|
|
|
std::vector<u16> far_players;
|
2011-02-22 19:49:57 -05:00
|
|
|
|
2015-03-05 05:18:17 -05:00
|
|
|
switch (event->type) {
|
|
|
|
case MEET_ADDNODE:
|
|
|
|
case MEET_SWAPNODE:
|
2011-06-26 17:27:17 -04:00
|
|
|
prof.add("MEET_ADDNODE", 1);
|
2015-03-05 05:18:17 -05:00
|
|
|
sendAddNode(event->p, event->n, event->already_known_by_peer,
|
|
|
|
&far_players, disable_single_change_sending ? 5 : 30,
|
|
|
|
event->type == MEET_ADDNODE);
|
|
|
|
break;
|
|
|
|
case MEET_REMOVENODE:
|
2011-06-26 17:27:17 -04:00
|
|
|
prof.add("MEET_REMOVENODE", 1);
|
2015-03-05 05:18:17 -05:00
|
|
|
sendRemoveNode(event->p, event->already_known_by_peer,
|
|
|
|
&far_players, disable_single_change_sending ? 5 : 30);
|
|
|
|
break;
|
|
|
|
case MEET_BLOCK_NODE_METADATA_CHANGED:
|
|
|
|
infostream << "Server: MEET_BLOCK_NODE_METADATA_CHANGED" << std::endl;
|
|
|
|
prof.add("MEET_BLOCK_NODE_METADATA_CHANGED", 1);
|
|
|
|
setBlockNotSent(event->p);
|
|
|
|
break;
|
|
|
|
case MEET_OTHER:
|
|
|
|
infostream << "Server: MEET_OTHER" << std::endl;
|
2011-06-26 17:27:17 -04:00
|
|
|
prof.add("MEET_OTHER", 1);
|
2012-12-20 12:19:49 -05:00
|
|
|
for(std::set<v3s16>::iterator
|
|
|
|
i = event->modified_blocks.begin();
|
2015-03-05 05:18:17 -05:00
|
|
|
i != event->modified_blocks.end(); ++i) {
|
2012-12-20 12:19:49 -05:00
|
|
|
setBlockNotSent(*i);
|
2011-08-16 05:23:19 -04:00
|
|
|
}
|
2015-03-05 05:18:17 -05:00
|
|
|
break;
|
|
|
|
default:
|
2011-06-26 17:27:17 -04:00
|
|
|
prof.add("unknown", 1);
|
2015-10-14 01:26:03 -04:00
|
|
|
warningstream << "Server: Unknown MapEditEvent "
|
2015-03-05 05:18:17 -05:00
|
|
|
<< ((u32)event->type) << std::endl;
|
|
|
|
break;
|
2011-02-22 19:49:57 -05:00
|
|
|
}
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-06-24 21:25:14 -04:00
|
|
|
/*
|
|
|
|
Set blocks not sent to far players
|
|
|
|
*/
|
2015-03-05 05:18:17 -05:00
|
|
|
if(!far_players.empty()) {
|
2011-07-01 14:04:40 -04:00
|
|
|
// Convert list format to that wanted by SetBlocksNotSent
|
2012-12-20 12:19:49 -05:00
|
|
|
std::map<v3s16, MapBlock*> modified_blocks2;
|
|
|
|
for(std::set<v3s16>::iterator
|
|
|
|
i = event->modified_blocks.begin();
|
2015-03-05 05:18:17 -05:00
|
|
|
i != event->modified_blocks.end(); ++i) {
|
2012-12-20 12:19:49 -05:00
|
|
|
modified_blocks2[*i] =
|
|
|
|
m_env->getMap().getBlockNoCreateNoEx(*i);
|
2011-06-25 20:14:52 -04:00
|
|
|
}
|
2015-03-05 05:18:17 -05:00
|
|
|
|
2011-07-01 14:04:40 -04:00
|
|
|
// Set blocks not sent
|
2015-03-05 05:18:17 -05:00
|
|
|
for(std::vector<u16>::iterator
|
2011-06-25 20:14:52 -04:00
|
|
|
i = far_players.begin();
|
2015-03-05 05:18:17 -05:00
|
|
|
i != far_players.end(); ++i) {
|
|
|
|
if(RemoteClient *client = getClient(*i))
|
|
|
|
client->SetBlocksNotSent(modified_blocks2);
|
2011-06-25 20:14:52 -04:00
|
|
|
}
|
2011-06-24 21:25:14 -04:00
|
|
|
}
|
2011-02-22 19:49:57 -05:00
|
|
|
|
|
|
|
delete event;
|
2011-06-24 21:25:14 -04:00
|
|
|
|
2011-06-25 20:14:52 -04:00
|
|
|
/*// Don't send too many at a time
|
2011-06-24 21:25:14 -04:00
|
|
|
count++;
|
2011-06-25 09:32:09 -04:00
|
|
|
if(count >= 1 && m_unsent_map_edit_queue.size() < 100)
|
2011-06-25 20:14:52 -04:00
|
|
|
break;*/
|
2011-02-22 19:49:57 -05:00
|
|
|
}
|
2011-06-26 17:27:17 -04:00
|
|
|
|
2012-03-10 21:15:45 -05:00
|
|
|
if(event_count >= 5){
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Server: MapEditEvents:"<<std::endl;
|
|
|
|
prof.print(infostream);
|
2012-03-10 21:15:45 -05:00
|
|
|
} else if(event_count != 0){
|
|
|
|
verbosestream<<"Server: MapEditEvents:"<<std::endl;
|
|
|
|
prof.print(verbosestream);
|
2011-06-26 17:27:17 -04:00
|
|
|
}
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-02-22 19:49:57 -05:00
|
|
|
}
|
|
|
|
|
2011-02-05 07:55:16 -05:00
|
|
|
/*
|
|
|
|
Trigger emergethread (it somehow gets to a non-triggered but
|
|
|
|
bysy state sometimes)
|
|
|
|
*/
|
2010-11-29 03:52:07 -05:00
|
|
|
{
|
2010-12-19 09:51:45 -05:00
|
|
|
float &counter = m_emergethread_trigger_timer;
|
2010-11-29 03:52:07 -05:00
|
|
|
counter += dtime;
|
2015-09-02 15:21:55 -04:00
|
|
|
if (counter >= 2.0) {
|
2010-11-29 03:52:07 -05:00
|
|
|
counter = 0.0;
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2014-01-26 01:12:18 -05:00
|
|
|
m_emerge->startThreads();
|
2010-11-29 03:52:07 -05:00
|
|
|
}
|
|
|
|
}
|
2010-11-26 18:02:21 -05:00
|
|
|
|
2011-05-29 14:11:16 -04:00
|
|
|
// Save map, players and auth stuff
|
2010-11-26 18:02:21 -05:00
|
|
|
{
|
2010-12-19 09:51:45 -05:00
|
|
|
float &counter = m_savemap_timer;
|
2010-11-26 18:02:21 -05:00
|
|
|
counter += dtime;
|
2015-09-02 15:21:55 -04:00
|
|
|
static const float save_interval =
|
|
|
|
g_settings->getFloat("server_map_save_interval");
|
|
|
|
if (counter >= save_interval) {
|
2010-11-26 18:02:21 -05:00
|
|
|
counter = 0.0;
|
2015-04-07 06:13:12 -04:00
|
|
|
MutexAutoLock lock(m_env_mutex);
|
2010-11-26 18:02:21 -05:00
|
|
|
|
2011-10-12 06:53:38 -04:00
|
|
|
ScopeProfiler sp(g_profiler, "Server: saving stuff");
|
2011-05-30 17:15:43 -04:00
|
|
|
|
2014-05-30 16:04:07 -04:00
|
|
|
// Save ban file
|
|
|
|
if (m_banmanager->isModified()) {
|
2013-08-10 22:09:45 -04:00
|
|
|
m_banmanager->save();
|
2014-05-30 16:04:07 -04:00
|
|
|
}
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-11-27 17:45:34 -05:00
|
|
|
// Save changed parts of map
|
|
|
|
m_env->getMap().save(MOD_STATE_WRITE_NEEDED);
|
2011-06-26 17:27:17 -04:00
|
|
|
|
|
|
|
// Save players
|
2014-05-30 16:04:07 -04:00
|
|
|
m_env->saveLoadedPlayers();
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-06-26 17:27:17 -04:00
|
|
|
// Save environment metadata
|
2014-05-30 16:04:07 -04:00
|
|
|
m_env->saveMeta();
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Server::Receive()
|
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2011-11-06 22:20:33 -05:00
|
|
|
SharedBuffer<u8> data;
|
2010-11-26 18:02:21 -05:00
|
|
|
u16 peer_id;
|
2015-01-12 11:01:41 -05:00
|
|
|
try {
|
2015-03-31 04:35:51 -04:00
|
|
|
NetworkPacket pkt;
|
|
|
|
m_con.Receive(&pkt);
|
|
|
|
peer_id = pkt.getPeerId();
|
|
|
|
ProcessData(&pkt);
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
2015-01-12 11:01:41 -05:00
|
|
|
catch(con::InvalidIncomingDataException &e) {
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Server::Receive(): "
|
2010-11-26 18:02:21 -05:00
|
|
|
"InvalidIncomingDataException: what()="
|
|
|
|
<<e.what()<<std::endl;
|
|
|
|
}
|
2014-06-21 18:05:41 -04:00
|
|
|
catch(SerializationError &e) {
|
|
|
|
infostream<<"Server::Receive(): "
|
|
|
|
"SerializationError: what()="
|
|
|
|
<<e.what()<<std::endl;
|
|
|
|
}
|
2015-01-12 11:01:41 -05:00
|
|
|
catch(ClientStateError &e) {
|
2014-02-13 14:17:42 -05:00
|
|
|
errorstream << "ProcessData: peer=" << peer_id << e.what() << std::endl;
|
2015-03-13 11:35:21 -04:00
|
|
|
DenyAccess_Legacy(peer_id, L"Your client sent something server didn't expect."
|
2014-02-13 14:17:42 -05:00
|
|
|
L"Try reconnecting or updating your client");
|
|
|
|
}
|
2015-01-12 11:01:41 -05:00
|
|
|
catch(con::PeerNotFoundException &e) {
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
// Do nothing
|
2015-01-12 11:01:41 -05:00
|
|
|
}
|
|
|
|
}
|
2011-11-29 10:15:18 -05:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
PlayerSAO* Server::StageTwoClientInit(u16 peer_id)
|
2015-01-12 11:01:41 -05:00
|
|
|
{
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
std::string playername = "";
|
|
|
|
PlayerSAO *playersao = NULL;
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.lock();
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
try {
|
|
|
|
RemoteClient* client = m_clients.lockedGetClientNoEx(peer_id, CS_InitDone);
|
|
|
|
if (client != NULL) {
|
|
|
|
playername = client->getName();
|
2015-07-17 10:40:41 -04:00
|
|
|
playersao = emergePlayer(playername.c_str(), peer_id, client->net_proto_version);
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
}
|
|
|
|
} catch (std::exception &e) {
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.unlock();
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
throw;
|
|
|
|
}
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.unlock();
|
2012-01-20 18:11:44 -05:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
RemotePlayer *player =
|
|
|
|
static_cast<RemotePlayer*>(m_env->getPlayer(playername.c_str()));
|
2011-11-29 10:15:18 -05:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
// If failed, cancel
|
2015-05-18 18:55:58 -04:00
|
|
|
if ((playersao == NULL) || (player == NULL)) {
|
|
|
|
if (player && player->peer_id != 0) {
|
|
|
|
actionstream << "Server: Failed to emerge player \"" << playername
|
|
|
|
<< "\" (player allocated to an another client)" << std::endl;
|
2015-03-13 11:35:21 -04:00
|
|
|
DenyAccess_Legacy(peer_id, L"Another client is connected with this "
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
L"name. If your client closed unexpectedly, try again in "
|
|
|
|
L"a minute.");
|
|
|
|
} else {
|
2015-05-18 18:55:58 -04:00
|
|
|
errorstream << "Server: " << playername << ": Failed to emerge player"
|
|
|
|
<< std::endl;
|
2015-03-13 11:35:21 -04:00
|
|
|
DenyAccess_Legacy(peer_id, L"Could not allocate player.");
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
}
|
|
|
|
return NULL;
|
2015-01-12 11:01:41 -05:00
|
|
|
}
|
2011-11-29 10:15:18 -05:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
/*
|
|
|
|
Send complete position information
|
|
|
|
*/
|
|
|
|
SendMovePlayer(peer_id);
|
2011-11-29 10:15:18 -05:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
// Send privileges
|
|
|
|
SendPlayerPrivileges(peer_id);
|
2011-05-23 15:40:25 -04:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
// Send inventory formspec
|
|
|
|
SendPlayerInventoryFormspec(peer_id);
|
2012-11-25 21:16:48 -05:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
// Send inventory
|
2015-03-04 09:27:53 -05:00
|
|
|
SendInventory(playersao);
|
2011-11-29 10:15:18 -05:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
// Send HP
|
2015-07-10 15:58:32 -04:00
|
|
|
SendPlayerHPOrDie(playersao);
|
2012-01-12 00:10:39 -05:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
// Send Breath
|
|
|
|
SendPlayerBreath(peer_id);
|
2011-05-29 14:11:16 -04:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
// Show death screen if necessary
|
2015-03-13 03:57:19 -04:00
|
|
|
if(player->isDead())
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
SendDeathscreen(peer_id, false, v3f(0,0,0));
|
2011-07-31 08:32:45 -04:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
// 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());
|
2011-10-15 07:46:59 -04:00
|
|
|
}
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
Address addr = getPeerAddress(player->peer_id);
|
|
|
|
std::string ip_str = addr.serializeString();
|
|
|
|
actionstream<<player->getName() <<" [" << ip_str << "] joins game. " << std::endl;
|
|
|
|
/*
|
|
|
|
Print out action
|
|
|
|
*/
|
|
|
|
{
|
|
|
|
std::vector<std::string> names = m_clients.getPlayerNames();
|
2015-01-12 11:01:41 -05:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
actionstream<<player->getName() <<" joins game. List of players: ";
|
|
|
|
|
|
|
|
for (std::vector<std::string>::iterator i = names.begin();
|
2015-08-25 16:23:05 -04:00
|
|
|
i != names.end(); ++i) {
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
actionstream << *i << " ";
|
|
|
|
}
|
2015-01-12 11:01:41 -05:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
actionstream << player->getName() <<std::endl;
|
|
|
|
}
|
|
|
|
return playersao;
|
2015-01-12 11:01:41 -05:00
|
|
|
}
|
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
inline void Server::handleCommand(NetworkPacket* pkt)
|
2015-01-12 11:01:41 -05:00
|
|
|
{
|
|
|
|
const ToServerCommandHandler& opHandle = toServerCommandTable[pkt->getCommand()];
|
|
|
|
(this->*opHandle.handler)(pkt);
|
|
|
|
}
|
|
|
|
|
2015-03-31 04:35:51 -04:00
|
|
|
void Server::ProcessData(NetworkPacket *pkt)
|
2015-01-12 11:01:41 -05:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2015-01-12 11:01:41 -05:00
|
|
|
// Environment is locked first.
|
2015-04-07 06:13:12 -04:00
|
|
|
MutexAutoLock envlock(m_env_mutex);
|
2015-01-12 11:01:41 -05:00
|
|
|
|
|
|
|
ScopeProfiler sp(g_profiler, "Server::ProcessData");
|
2015-03-31 04:35:51 -04:00
|
|
|
u32 peer_id = pkt->getPeerId();
|
2015-01-12 11:01:41 -05:00
|
|
|
|
|
|
|
try {
|
|
|
|
Address address = getPeerAddress(peer_id);
|
|
|
|
std::string addr_s = address.serializeString();
|
|
|
|
|
|
|
|
if(m_banmanager->isIpBanned(addr_s)) {
|
|
|
|
std::string ban_name = m_banmanager->getBanName(addr_s);
|
|
|
|
infostream << "Server: A banned client tried to connect from "
|
|
|
|
<< addr_s << "; banned name was "
|
|
|
|
<< ban_name << std::endl;
|
|
|
|
// This actually doesn't seem to transfer to the client
|
2015-03-13 11:35:21 -04:00
|
|
|
DenyAccess_Legacy(peer_id, L"Your ip is banned. Banned name was "
|
2015-07-06 23:55:07 -04:00
|
|
|
+ utf8_to_wide(ban_name));
|
2015-01-12 11:01:41 -05:00
|
|
|
return;
|
2012-03-24 13:01:26 -04:00
|
|
|
}
|
|
|
|
}
|
2015-01-12 11:01:41 -05:00
|
|
|
catch(con::PeerNotFoundException &e) {
|
|
|
|
/*
|
|
|
|
* no peer for this packet found
|
|
|
|
* most common reason is peer timeout, e.g. peer didn't
|
|
|
|
* respond for some time, your server was overloaded or
|
|
|
|
* things like that.
|
|
|
|
*/
|
2015-03-31 04:35:51 -04:00
|
|
|
infostream << "Server::ProcessData(): Canceling: peer "
|
2015-01-12 11:01:41 -05:00
|
|
|
<< peer_id << " not found" << std::endl;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
2015-03-31 04:35:51 -04:00
|
|
|
ToServerCommand command = (ToServerCommand) pkt->getCommand();
|
2015-01-12 11:01:41 -05:00
|
|
|
|
|
|
|
// Command must be handled into ToServerCommandHandler
|
|
|
|
if (command >= TOSERVER_NUM_MSG_TYPES) {
|
|
|
|
infostream << "Server: Ignoring unknown command "
|
|
|
|
<< command << std::endl;
|
2015-06-24 16:45:52 -04:00
|
|
|
return;
|
2012-06-01 13:51:15 -04:00
|
|
|
}
|
|
|
|
|
2015-01-12 11:01:41 -05:00
|
|
|
if (toServerCommandTable[command].state == TOSERVER_STATE_NOT_CONNECTED) {
|
2015-03-31 04:35:51 -04:00
|
|
|
handleCommand(pkt);
|
2015-01-12 11:01:41 -05:00
|
|
|
return;
|
|
|
|
}
|
2012-07-26 15:06:45 -04:00
|
|
|
|
2015-01-12 11:01:41 -05:00
|
|
|
u8 peer_ser_ver = getClient(peer_id, CS_InitDone)->serialization_version;
|
2012-07-26 15:06:45 -04:00
|
|
|
|
2015-01-12 11:01:41 -05:00
|
|
|
if(peer_ser_ver == SER_FMT_VER_INVALID) {
|
|
|
|
errorstream << "Server::ProcessData(): Cancelling: Peer"
|
|
|
|
" serialization format invalid or not initialized."
|
|
|
|
" Skipping incoming command=" << command << std::endl;
|
|
|
|
return;
|
2012-07-26 15:06:45 -04:00
|
|
|
}
|
2015-01-12 11:01:41 -05:00
|
|
|
|
|
|
|
/* Handle commands related to client startup */
|
|
|
|
if (toServerCommandTable[command].state == TOSERVER_STATE_STARTUP) {
|
2015-03-31 04:35:51 -04:00
|
|
|
handleCommand(pkt);
|
2015-01-12 11:01:41 -05:00
|
|
|
return;
|
2012-07-22 10:10:58 -04:00
|
|
|
}
|
|
|
|
|
2015-01-12 11:01:41 -05:00
|
|
|
if (m_clients.getClientState(peer_id) < CS_Active) {
|
|
|
|
if (command == TOSERVER_PLAYERPOS) return;
|
|
|
|
|
|
|
|
errorstream << "Got packet command: " << command << " for peer id "
|
|
|
|
<< peer_id << " but client isn't active yet. Dropping packet "
|
|
|
|
<< std::endl;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-03-31 04:35:51 -04:00
|
|
|
handleCommand(pkt);
|
2015-05-08 00:51:03 -04:00
|
|
|
} catch (SendFailedException &e) {
|
2015-01-12 11:01:41 -05:00
|
|
|
errorstream << "Server::ProcessData(): SendFailedException: "
|
|
|
|
<< "what=" << e.what()
|
|
|
|
<< std::endl;
|
2015-05-08 00:51:03 -04:00
|
|
|
} catch (PacketError &e) {
|
|
|
|
actionstream << "Server::ProcessData(): PacketError: "
|
|
|
|
<< "what=" << e.what()
|
|
|
|
<< std::endl;
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-10 22:09:45 -04:00
|
|
|
void Server::setTimeOfDay(u32 time)
|
|
|
|
{
|
|
|
|
m_env->setTimeOfDay(time);
|
|
|
|
m_time_of_day_send_timer = 0;
|
|
|
|
}
|
|
|
|
|
2011-02-22 19:49:57 -05:00
|
|
|
void Server::onMapEditEvent(MapEditEvent *event)
|
2010-11-26 18:02:21 -05:00
|
|
|
{
|
2011-02-22 19:49:57 -05:00
|
|
|
if(m_ignore_map_edit_events)
|
|
|
|
return;
|
2012-03-28 18:22:08 -04:00
|
|
|
if(m_ignore_map_edit_events_area.contains(event->getArea()))
|
|
|
|
return;
|
2011-02-22 19:49:57 -05:00
|
|
|
MapEditEvent *e = event->clone();
|
2015-03-04 11:48:07 -05:00
|
|
|
m_unsent_map_edit_queue.push(e);
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
|
|
|
|
2011-12-06 08:21:56 -05:00
|
|
|
Inventory* Server::getInventory(const InventoryLocation &loc)
|
|
|
|
{
|
2015-01-12 11:01:41 -05:00
|
|
|
switch (loc.type) {
|
2011-12-06 08:21:56 -05:00
|
|
|
case InventoryLocation::UNDEFINED:
|
2012-01-12 00:10:39 -05:00
|
|
|
case InventoryLocation::CURRENT_PLAYER:
|
2015-01-12 11:01:41 -05:00
|
|
|
break;
|
2011-12-06 08:21:56 -05:00
|
|
|
case InventoryLocation::PLAYER:
|
|
|
|
{
|
|
|
|
Player *player = m_env->getPlayer(loc.name.c_str());
|
|
|
|
if(!player)
|
|
|
|
return NULL;
|
2012-03-18 22:04:16 -04:00
|
|
|
PlayerSAO *playersao = player->getPlayerSAO();
|
|
|
|
if(!playersao)
|
|
|
|
return NULL;
|
|
|
|
return playersao->getInventory();
|
2011-12-06 08:21:56 -05:00
|
|
|
}
|
2015-01-12 11:01:41 -05:00
|
|
|
break;
|
2011-12-06 08:21:56 -05:00
|
|
|
case InventoryLocation::NODEMETA:
|
|
|
|
{
|
|
|
|
NodeMetadata *meta = m_env->getMap().getNodeMetadata(loc.p);
|
|
|
|
if(!meta)
|
|
|
|
return NULL;
|
|
|
|
return meta->getInventory();
|
|
|
|
}
|
2015-01-12 11:01:41 -05:00
|
|
|
break;
|
2012-07-24 13:57:17 -04:00
|
|
|
case InventoryLocation::DETACHED:
|
|
|
|
{
|
|
|
|
if(m_detached_inventories.count(loc.name) == 0)
|
|
|
|
return NULL;
|
|
|
|
return m_detached_inventories[loc.name];
|
|
|
|
}
|
2015-01-12 11:01:41 -05:00
|
|
|
break;
|
2011-12-06 08:21:56 -05:00
|
|
|
default:
|
2015-03-06 05:21:51 -05:00
|
|
|
sanity_check(false); // abort
|
2015-03-04 09:27:53 -05:00
|
|
|
break;
|
2011-12-06 08:21:56 -05:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2015-03-24 04:36:54 -04:00
|
|
|
void Server::setInventoryModified(const InventoryLocation &loc, bool playerSend)
|
2011-12-06 08:21:56 -05:00
|
|
|
{
|
|
|
|
switch(loc.type){
|
|
|
|
case InventoryLocation::UNDEFINED:
|
2015-01-12 11:01:41 -05:00
|
|
|
break;
|
2011-12-06 08:21:56 -05:00
|
|
|
case InventoryLocation::PLAYER:
|
|
|
|
{
|
2015-03-24 04:36:54 -04:00
|
|
|
if (!playerSend)
|
|
|
|
return;
|
|
|
|
|
2012-03-18 22:04:16 -04:00
|
|
|
Player *player = m_env->getPlayer(loc.name.c_str());
|
|
|
|
if(!player)
|
|
|
|
return;
|
|
|
|
PlayerSAO *playersao = player->getPlayerSAO();
|
|
|
|
if(!playersao)
|
2011-12-06 08:21:56 -05:00
|
|
|
return;
|
2015-03-04 05:29:34 -05:00
|
|
|
|
2015-03-04 09:27:53 -05:00
|
|
|
SendInventory(playersao);
|
2011-12-06 08:21:56 -05:00
|
|
|
}
|
2015-01-12 11:01:41 -05:00
|
|
|
break;
|
2011-12-06 08:21:56 -05:00
|
|
|
case InventoryLocation::NODEMETA:
|
|
|
|
{
|
|
|
|
v3s16 blockpos = getNodeBlockPos(loc.p);
|
|
|
|
|
|
|
|
MapBlock *block = m_env->getMap().getBlockNoCreateNoEx(blockpos);
|
|
|
|
if(block)
|
|
|
|
block->raiseModified(MOD_STATE_WRITE_NEEDED);
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-12-06 08:21:56 -05:00
|
|
|
setBlockNotSent(blockpos);
|
|
|
|
}
|
2015-01-12 11:01:41 -05:00
|
|
|
break;
|
2012-07-24 13:57:17 -04:00
|
|
|
case InventoryLocation::DETACHED:
|
|
|
|
{
|
2014-01-30 18:24:00 -05:00
|
|
|
sendDetachedInventory(loc.name,PEER_ID_INEXISTENT);
|
2012-07-24 13:57:17 -04:00
|
|
|
}
|
2015-01-12 11:01:41 -05:00
|
|
|
break;
|
2011-12-06 08:21:56 -05:00
|
|
|
default:
|
2015-03-06 05:21:51 -05:00
|
|
|
sanity_check(false); // abort
|
2015-03-04 09:27:53 -05:00
|
|
|
break;
|
2011-12-06 08:21:56 -05:00
|
|
|
}
|
|
|
|
}
|
2011-04-04 08:13:19 -04:00
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
void Server::SetBlocksNotSent(std::map<v3s16, MapBlock *>& block)
|
|
|
|
{
|
2015-03-04 10:30:24 -05:00
|
|
|
std::vector<u16> clients = m_clients.getClientIDs();
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.lock();
|
2014-01-30 18:24:00 -05:00
|
|
|
// Set the modified blocks unsent for all the clients
|
2015-03-04 10:30:24 -05:00
|
|
|
for (std::vector<u16>::iterator i = clients.begin();
|
2014-01-30 18:24:00 -05:00
|
|
|
i != clients.end(); ++i) {
|
2015-03-04 10:30:24 -05:00
|
|
|
if (RemoteClient *client = m_clients.lockedGetClientNoEx(*i))
|
2014-01-30 18:24:00 -05:00
|
|
|
client->SetBlocksNotSent(block);
|
2015-03-04 10:30:24 -05:00
|
|
|
}
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.unlock();
|
2014-01-30 18:24:00 -05:00
|
|
|
}
|
|
|
|
|
2010-11-26 18:02:21 -05:00
|
|
|
void Server::peerAdded(con::Peer *peer)
|
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2012-03-10 21:15:45 -05:00
|
|
|
verbosestream<<"Server::peerAdded(): peer->id="
|
2010-11-26 18:02:21 -05:00
|
|
|
<<peer->id<<std::endl;
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
con::PeerChange c;
|
|
|
|
c.type = con::PEER_ADDED;
|
2010-12-24 10:08:50 -05:00
|
|
|
c.peer_id = peer->id;
|
|
|
|
c.timeout = false;
|
2015-03-04 11:48:07 -05:00
|
|
|
m_peer_change_queue.push(c);
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void Server::deletingPeer(con::Peer *peer, bool timeout)
|
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2012-03-10 21:15:45 -05:00
|
|
|
verbosestream<<"Server::deletingPeer(): peer->id="
|
2010-11-26 18:02:21 -05:00
|
|
|
<<peer->id<<", timeout="<<timeout<<std::endl;
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2014-06-28 02:02:38 -04:00
|
|
|
m_clients.event(peer->id, CSE_Disconnect);
|
2014-01-30 18:24:00 -05:00
|
|
|
con::PeerChange c;
|
|
|
|
c.type = con::PEER_REMOVED;
|
2010-12-24 10:08:50 -05:00
|
|
|
c.peer_id = peer->id;
|
|
|
|
c.timeout = timeout;
|
2015-03-04 11:48:07 -05:00
|
|
|
m_peer_change_queue.push(c);
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
|
|
|
|
2014-02-13 14:17:42 -05:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Server::getClientInfo(
|
|
|
|
u16 peer_id,
|
|
|
|
ClientState* state,
|
|
|
|
u32* uptime,
|
|
|
|
u8* ser_vers,
|
|
|
|
u16* prot_vers,
|
|
|
|
u8* major,
|
|
|
|
u8* minor,
|
|
|
|
u8* patch,
|
|
|
|
std::string* vers_string
|
|
|
|
)
|
|
|
|
{
|
|
|
|
*state = m_clients.getClientState(peer_id);
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.lock();
|
2014-06-28 02:02:38 -04:00
|
|
|
RemoteClient* client = m_clients.lockedGetClientNoEx(peer_id, CS_Invalid);
|
2014-02-13 14:17:42 -05:00
|
|
|
|
2014-05-10 18:14:57 -04:00
|
|
|
if (client == NULL) {
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.unlock();
|
2014-02-13 14:17:42 -05:00
|
|
|
return false;
|
2014-06-28 02:02:38 -04:00
|
|
|
}
|
2014-02-13 14:17:42 -05:00
|
|
|
|
|
|
|
*uptime = client->uptime();
|
|
|
|
*ser_vers = client->serialization_version;
|
|
|
|
*prot_vers = client->net_proto_version;
|
|
|
|
|
|
|
|
*major = client->getMajor();
|
|
|
|
*minor = client->getMinor();
|
|
|
|
*patch = client->getPatch();
|
|
|
|
*vers_string = client->getPatch();
|
|
|
|
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.unlock();
|
2014-02-13 14:17:42 -05:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
void Server::handlePeerChanges()
|
|
|
|
{
|
|
|
|
while(m_peer_change_queue.size() > 0)
|
|
|
|
{
|
2015-03-04 11:48:07 -05:00
|
|
|
con::PeerChange c = m_peer_change_queue.front();
|
|
|
|
m_peer_change_queue.pop();
|
2014-01-30 18:24:00 -05:00
|
|
|
|
|
|
|
verbosestream<<"Server: Handling peer change: "
|
|
|
|
<<"id="<<c.peer_id<<", timeout="<<c.timeout
|
|
|
|
<<std::endl;
|
|
|
|
|
|
|
|
switch(c.type)
|
|
|
|
{
|
|
|
|
case con::PEER_ADDED:
|
|
|
|
m_clients.CreateClient(c.peer_id);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case con::PEER_REMOVED:
|
|
|
|
DeleteClient(c.peer_id, c.timeout?CDR_TIMEOUT:CDR_LEAVE);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2015-03-06 05:21:51 -05:00
|
|
|
FATAL_ERROR("Invalid peer change event received!");
|
2014-01-30 18:24:00 -05:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-04-21 12:35:17 -04:00
|
|
|
|
2015-07-25 01:43:32 -04:00
|
|
|
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 {
|
2015-11-08 16:23:16 -05:00
|
|
|
std::cout << text << std::endl;
|
2015-07-25 01:43:32 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
void Server::Send(NetworkPacket* pkt)
|
|
|
|
{
|
|
|
|
m_clients.send(pkt->getPeerId(),
|
|
|
|
clientCommandFactoryTable[pkt->getCommand()].channel,
|
|
|
|
pkt,
|
|
|
|
clientCommandFactoryTable[pkt->getCommand()].reliable);
|
|
|
|
}
|
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
void Server::SendMovement(u16 peer_id)
|
2013-02-08 15:54:01 -05:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2013-02-08 15:54:01 -05:00
|
|
|
std::ostringstream os(std::ios_base::binary);
|
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_MOVEMENT, 12 * sizeof(float), peer_id);
|
|
|
|
|
|
|
|
pkt << g_settings->getFloat("movement_acceleration_default");
|
|
|
|
pkt << g_settings->getFloat("movement_acceleration_air");
|
|
|
|
pkt << g_settings->getFloat("movement_acceleration_fast");
|
|
|
|
pkt << g_settings->getFloat("movement_speed_walk");
|
|
|
|
pkt << g_settings->getFloat("movement_speed_crouch");
|
|
|
|
pkt << g_settings->getFloat("movement_speed_fast");
|
|
|
|
pkt << g_settings->getFloat("movement_speed_climb");
|
|
|
|
pkt << g_settings->getFloat("movement_speed_jump");
|
|
|
|
pkt << g_settings->getFloat("movement_liquid_fluidity");
|
|
|
|
pkt << g_settings->getFloat("movement_liquid_fluidity_smooth");
|
|
|
|
pkt << g_settings->getFloat("movement_liquid_sink");
|
|
|
|
pkt << g_settings->getFloat("movement_gravity");
|
2013-02-08 15:54:01 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2013-02-08 15:54:01 -05:00
|
|
|
}
|
|
|
|
|
2015-07-10 15:58:32 -04:00
|
|
|
void Server::SendPlayerHPOrDie(PlayerSAO *playersao)
|
|
|
|
{
|
|
|
|
if (!g_settings->getBool("enable_damage"))
|
|
|
|
return;
|
|
|
|
|
|
|
|
u16 peer_id = playersao->getPeerID();
|
|
|
|
bool is_alive = playersao->getHP() > 0;
|
|
|
|
|
|
|
|
if (is_alive)
|
|
|
|
SendPlayerHP(peer_id);
|
|
|
|
else
|
|
|
|
DiePlayer(peer_id);
|
|
|
|
}
|
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
void Server::SendHP(u16 peer_id, u8 hp)
|
2011-04-21 12:35:17 -04:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2011-04-21 12:35:17 -04:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_HP, 1, peer_id);
|
|
|
|
pkt << hp;
|
|
|
|
Send(&pkt);
|
2011-04-21 12:35:17 -04:00
|
|
|
}
|
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
void Server::SendBreath(u16 peer_id, u16 breath)
|
2013-07-19 13:50:33 -04:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2013-07-19 13:50:33 -04:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_BREATH, 2, peer_id);
|
|
|
|
pkt << (u16) breath;
|
|
|
|
Send(&pkt);
|
2013-07-19 13:50:33 -04:00
|
|
|
}
|
|
|
|
|
2015-07-17 10:40:41 -04:00
|
|
|
void Server::SendAccessDenied(u16 peer_id, AccessDeniedCode reason,
|
|
|
|
const std::string &custom_reason, bool reconnect)
|
2015-03-13 11:35:21 -04:00
|
|
|
{
|
2015-07-17 10:40:41 -04:00
|
|
|
assert(reason < SERVER_ACCESSDENIED_MAX);
|
2015-03-13 11:35:21 -04:00
|
|
|
|
|
|
|
NetworkPacket pkt(TOCLIENT_ACCESS_DENIED, 1, peer_id);
|
2015-07-17 10:40:41 -04:00
|
|
|
pkt << (u8)reason;
|
|
|
|
if (reason == SERVER_ACCESSDENIED_CUSTOM_STRING)
|
2015-03-13 11:35:21 -04:00
|
|
|
pkt << custom_reason;
|
2015-07-17 10:40:41 -04:00
|
|
|
else if (reason == SERVER_ACCESSDENIED_SHUTDOWN ||
|
|
|
|
reason == SERVER_ACCESSDENIED_CRASH)
|
|
|
|
pkt << custom_reason << (u8)reconnect;
|
2015-03-13 11:35:21 -04:00
|
|
|
Send(&pkt);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Server::SendAccessDenied_Legacy(u16 peer_id,const std::wstring &reason)
|
2011-05-20 15:28:03 -04:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2011-05-20 15:28:03 -04:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_ACCESS_DENIED_LEGACY, 0, peer_id);
|
|
|
|
pkt << reason;
|
|
|
|
Send(&pkt);
|
2011-05-20 15:28:03 -04:00
|
|
|
}
|
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
void Server::SendDeathscreen(u16 peer_id,bool set_camera_point_target,
|
|
|
|
v3f camera_point_target)
|
2011-10-15 07:46:59 -04:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2011-10-15 07:46:59 -04:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_DEATHSCREEN, 1 + sizeof(v3f), peer_id);
|
|
|
|
pkt << set_camera_point_target << camera_point_target;
|
|
|
|
Send(&pkt);
|
2011-10-15 07:46:59 -04:00
|
|
|
}
|
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
void Server::SendItemDef(u16 peer_id,
|
2013-03-28 16:40:44 -04:00
|
|
|
IItemDefManager *itemdef, u16 protocol_version)
|
2011-11-14 18:00:16 -05:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_ITEMDEF, 0, peer_id);
|
2011-11-14 18:00:16 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
u16 command
|
|
|
|
u32 length of the next item
|
2012-01-12 00:10:39 -05:00
|
|
|
zlib-compressed serialized ItemDefManager
|
2011-11-14 18:00:16 -05:00
|
|
|
*/
|
|
|
|
std::ostringstream tmp_os(std::ios::binary);
|
2013-03-28 16:40:44 -04:00
|
|
|
itemdef->serialize(tmp_os, protocol_version);
|
2012-01-12 00:10:39 -05:00
|
|
|
std::ostringstream tmp_os2(std::ios::binary);
|
|
|
|
compressZlib(tmp_os.str(), tmp_os2);
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt.putLongString(tmp_os2.str());
|
2011-11-14 18:00:16 -05:00
|
|
|
|
|
|
|
// Make data buffer
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
verbosestream << "Server: Sending item definitions to id(" << peer_id
|
2015-03-13 17:01:49 -04:00
|
|
|
<< "): size=" << pkt.getSize() << std::endl;
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2011-11-15 13:32:56 -05:00
|
|
|
}
|
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
void Server::SendNodeDef(u16 peer_id,
|
2012-11-26 16:59:03 -05:00
|
|
|
INodeDefManager *nodedef, u16 protocol_version)
|
2011-11-15 13:32:56 -05:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_NODEDEF, 0, peer_id);
|
2011-11-15 13:32:56 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
u16 command
|
|
|
|
u32 length of the next item
|
2012-01-12 00:10:39 -05:00
|
|
|
zlib-compressed serialized NodeDefManager
|
2011-11-15 13:32:56 -05:00
|
|
|
*/
|
|
|
|
std::ostringstream tmp_os(std::ios::binary);
|
2012-11-26 16:59:03 -05:00
|
|
|
nodedef->serialize(tmp_os, protocol_version);
|
2012-01-12 00:10:39 -05:00
|
|
|
std::ostringstream tmp_os2(std::ios::binary);
|
|
|
|
compressZlib(tmp_os.str(), tmp_os2);
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt.putLongString(tmp_os2.str());
|
2011-11-15 13:32:56 -05:00
|
|
|
|
|
|
|
// Make data buffer
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
verbosestream << "Server: Sending node definitions to id(" << peer_id
|
2015-03-13 17:01:49 -04:00
|
|
|
<< "): size=" << pkt.getSize() << std::endl;
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2011-11-14 18:00:16 -05:00
|
|
|
}
|
|
|
|
|
2011-04-21 12:35:17 -04:00
|
|
|
/*
|
|
|
|
Non-static send methods
|
|
|
|
*/
|
|
|
|
|
2015-03-04 09:27:53 -05:00
|
|
|
void Server::SendInventory(PlayerSAO* playerSAO)
|
2010-11-26 18:02:21 -05:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2015-03-04 09:27:53 -05:00
|
|
|
UpdateCrafting(playerSAO->getPlayer());
|
2011-11-29 16:18:20 -05:00
|
|
|
|
2010-12-22 09:30:23 -05:00
|
|
|
/*
|
2011-04-21 12:35:17 -04:00
|
|
|
Serialize it
|
2010-12-22 09:30:23 -05:00
|
|
|
*/
|
2011-04-21 12:35:17 -04:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_INVENTORY, 0, playerSAO->getPeerID());
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
|
2011-04-21 12:35:17 -04:00
|
|
|
std::ostringstream os;
|
2015-03-04 09:27:53 -05:00
|
|
|
playerSAO->getInventory()->serialize(os);
|
2011-04-21 12:35:17 -04:00
|
|
|
|
|
|
|
std::string s = os.str();
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt.putRawString(s.c_str(), s.size());
|
|
|
|
Send(&pkt);
|
2011-04-21 12:35:17 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void Server::SendChatMessage(u16 peer_id, const std::wstring &message)
|
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_CHAT_MESSAGE, 0, peer_id);
|
|
|
|
pkt << message;
|
2014-01-30 18:24:00 -05:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
if (peer_id != PEER_ID_INEXISTENT) {
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2014-01-30 18:24:00 -05:00
|
|
|
}
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
else {
|
2015-03-13 17:01:49 -04:00
|
|
|
m_clients.sendToAll(0, &pkt, true);
|
2014-01-30 18:24:00 -05:00
|
|
|
}
|
2011-04-21 12:35:17 -04:00
|
|
|
}
|
2013-04-13 18:20:22 -04:00
|
|
|
|
2014-02-27 15:12:59 -05:00
|
|
|
void Server::SendShowFormspecMessage(u16 peer_id, const std::string &formspec,
|
|
|
|
const std::string &formname)
|
2013-01-02 14:45:04 -05:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2013-01-02 14:45:04 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_SHOW_FORMSPEC, 0 , peer_id);
|
2014-06-25 13:04:47 -04:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt.putLongString(FORMSPEC_VERSION_STRING + formspec);
|
|
|
|
pkt << formname;
|
2013-01-02 14:45:04 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2013-01-02 14:45:04 -05:00
|
|
|
}
|
2011-04-11 14:28:04 -04:00
|
|
|
|
2013-01-23 12:32:02 -05:00
|
|
|
// Spawns a particle on peer with peer_id
|
2013-04-13 18:20:22 -04:00
|
|
|
void Server::SendSpawnParticle(u16 peer_id, v3f pos, v3f velocity, v3f acceleration,
|
|
|
|
float expirationtime, float size, bool collisiondetection,
|
2016-05-28 00:08:23 -04:00
|
|
|
bool collision_removal,
|
|
|
|
bool vertical, const std::string &texture)
|
2013-01-23 12:32:02 -05:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2013-01-23 12:32:02 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_SPAWN_PARTICLE, 0, peer_id);
|
2013-01-23 12:32:02 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << pos << velocity << acceleration << expirationtime
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
<< size << collisiondetection;
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt.putLongString(texture);
|
|
|
|
pkt << vertical;
|
2016-05-28 00:08:23 -04:00
|
|
|
pkt << collision_removal;
|
2013-01-23 12:32:02 -05:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
if (peer_id != PEER_ID_INEXISTENT) {
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2014-01-30 18:24:00 -05:00
|
|
|
}
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
else {
|
2015-03-13 17:01:49 -04:00
|
|
|
m_clients.sendToAll(0, &pkt, true);
|
2013-01-23 12:32:02 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Adds a ParticleSpawner on peer with peer_id
|
|
|
|
void Server::SendAddParticleSpawner(u16 peer_id, u16 amount, float spawntime, v3f minpos, v3f maxpos,
|
|
|
|
v3f minvel, v3f maxvel, v3f minacc, v3f maxacc, float minexptime, float maxexptime,
|
2016-05-28 00:08:23 -04:00
|
|
|
float minsize, float maxsize, bool collisiondetection, bool collision_removal,
|
|
|
|
bool vertical, const std::string &texture, u32 id)
|
2013-01-23 12:32:02 -05:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2013-01-23 12:32:02 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_ADD_PARTICLESPAWNER, 0, peer_id);
|
2013-01-23 12:32:02 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << amount << spawntime << minpos << maxpos << minvel << maxvel
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
<< minacc << maxacc << minexptime << maxexptime << minsize
|
|
|
|
<< maxsize << collisiondetection;
|
2013-01-23 12:32:02 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt.putLongString(texture);
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << id << vertical;
|
2016-05-28 00:08:23 -04:00
|
|
|
pkt << collision_removal;
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
|
|
|
|
if (peer_id != PEER_ID_INEXISTENT) {
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2014-01-30 18:24:00 -05:00
|
|
|
}
|
|
|
|
else {
|
2015-03-13 17:01:49 -04:00
|
|
|
m_clients.sendToAll(0, &pkt, true);
|
2013-01-23 12:32:02 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Server::SendDeleteParticleSpawner(u16 peer_id, u32 id)
|
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2013-01-23 12:32:02 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_DELETE_PARTICLESPAWNER_LEGACY, 2, peer_id);
|
2013-01-23 12:32:02 -05:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
// Ugly error in this packet
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << (u16) id;
|
2013-01-23 12:32:02 -05:00
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
if (peer_id != PEER_ID_INEXISTENT) {
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2014-01-30 18:24:00 -05:00
|
|
|
}
|
|
|
|
else {
|
2015-03-13 17:01:49 -04:00
|
|
|
m_clients.sendToAll(0, &pkt, true);
|
2013-01-23 12:32:02 -05:00
|
|
|
}
|
2014-01-30 18:24:00 -05:00
|
|
|
|
2013-01-23 12:32:02 -05:00
|
|
|
}
|
|
|
|
|
2013-04-13 18:20:22 -04:00
|
|
|
void Server::SendHUDAdd(u16 peer_id, u32 id, HudElement *form)
|
2013-04-11 14:23:38 -04:00
|
|
|
{
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_HUDADD, 0 , peer_id);
|
2013-04-11 14:23:38 -04:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << id << (u8) form->type << form->pos << form->name << form->scale
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
<< form->text << form->number << form->item << form->dir
|
|
|
|
<< form->align << form->offset << form->world_pos << form->size;
|
2013-04-11 14:23:38 -04:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2013-04-11 14:23:38 -04:00
|
|
|
}
|
|
|
|
|
2013-04-13 18:20:22 -04:00
|
|
|
void Server::SendHUDRemove(u16 peer_id, u32 id)
|
2013-04-11 14:23:38 -04:00
|
|
|
{
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_HUDRM, 4, peer_id);
|
|
|
|
pkt << id;
|
|
|
|
Send(&pkt);
|
2013-04-11 14:23:38 -04:00
|
|
|
}
|
|
|
|
|
2013-04-13 18:20:22 -04:00
|
|
|
void Server::SendHUDChange(u16 peer_id, u32 id, HudElementStat stat, void *value)
|
2013-04-11 14:23:38 -04:00
|
|
|
{
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_HUDCHANGE, 0, peer_id);
|
|
|
|
pkt << id << (u8) stat;
|
2013-04-11 14:23:38 -04:00
|
|
|
|
2013-04-13 18:20:22 -04:00
|
|
|
switch (stat) {
|
|
|
|
case HUD_STAT_POS:
|
|
|
|
case HUD_STAT_SCALE:
|
2013-04-22 05:53:55 -04:00
|
|
|
case HUD_STAT_ALIGN:
|
2013-04-22 19:47:59 -04:00
|
|
|
case HUD_STAT_OFFSET:
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << *(v2f *) value;
|
2013-04-13 18:20:22 -04:00
|
|
|
break;
|
|
|
|
case HUD_STAT_NAME:
|
|
|
|
case HUD_STAT_TEXT:
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << *(std::string *) value;
|
2013-04-13 18:20:22 -04:00
|
|
|
break;
|
2014-01-26 15:31:59 -05:00
|
|
|
case HUD_STAT_WORLD_POS:
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << *(v3f *) value;
|
2014-01-26 15:31:59 -05:00
|
|
|
break;
|
2014-04-28 17:41:27 -04:00
|
|
|
case HUD_STAT_SIZE:
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << *(v2s32 *) value;
|
2014-04-28 17:41:27 -04:00
|
|
|
break;
|
2013-04-13 18:20:22 -04:00
|
|
|
case HUD_STAT_NUMBER:
|
|
|
|
case HUD_STAT_ITEM:
|
|
|
|
case HUD_STAT_DIR:
|
|
|
|
default:
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << *(u32 *) value;
|
2013-04-13 18:20:22 -04:00
|
|
|
break;
|
|
|
|
}
|
2013-04-11 14:23:38 -04:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2013-04-11 14:23:38 -04:00
|
|
|
}
|
|
|
|
|
2013-04-25 19:27:22 -04:00
|
|
|
void Server::SendHUDSetFlags(u16 peer_id, u32 flags, u32 mask)
|
2013-04-24 06:52:46 -04:00
|
|
|
{
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_HUD_SET_FLAGS, 4 + 4, peer_id);
|
2013-04-24 06:52:46 -04:00
|
|
|
|
2014-05-10 18:35:31 -04:00
|
|
|
flags &= ~(HUD_FLAG_HEALTHBAR_VISIBLE | HUD_FLAG_BREATHBAR_VISIBLE);
|
2013-04-24 06:52:46 -04:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << flags << mask;
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2013-04-24 06:52:46 -04:00
|
|
|
}
|
|
|
|
|
2013-05-03 20:08:52 -04:00
|
|
|
void Server::SendHUDSetParam(u16 peer_id, u16 param, const std::string &value)
|
|
|
|
{
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_HUD_SET_PARAM, 0, peer_id);
|
|
|
|
pkt << param << value;
|
|
|
|
Send(&pkt);
|
2011-04-21 12:35:17 -04:00
|
|
|
}
|
2010-12-24 18:54:39 -05:00
|
|
|
|
2013-05-02 16:52:50 -04:00
|
|
|
void Server::SendSetSky(u16 peer_id, const video::SColor &bgcolor,
|
|
|
|
const std::string &type, const std::vector<std::string> ¶ms)
|
|
|
|
{
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_SET_SKY, 0, peer_id);
|
|
|
|
pkt << bgcolor << type << (u16) params.size();
|
2013-05-02 16:52:50 -04:00
|
|
|
|
|
|
|
for(size_t i=0; i<params.size(); i++)
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << params[i];
|
2013-05-02 16:52:50 -04:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2013-05-02 16:52:50 -04:00
|
|
|
}
|
|
|
|
|
2013-10-18 04:53:19 -04:00
|
|
|
void Server::SendOverrideDayNightRatio(u16 peer_id, bool do_override,
|
|
|
|
float ratio)
|
|
|
|
{
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_OVERRIDE_DAY_NIGHT_RATIO,
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
1 + 2, peer_id);
|
2013-10-18 04:53:19 -04:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << do_override << (u16) (ratio * 65535);
|
2013-10-18 04:53:19 -04:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2013-10-18 04:53:19 -04:00
|
|
|
}
|
|
|
|
|
2013-08-10 22:09:45 -04:00
|
|
|
void Server::SendTimeOfDay(u16 peer_id, u16 time, f32 time_speed)
|
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2013-08-10 22:09:45 -04:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_TIME_OF_DAY, 0, peer_id);
|
|
|
|
pkt << time << time_speed;
|
2013-08-10 22:09:45 -04:00
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
if (peer_id == PEER_ID_INEXISTENT) {
|
2015-03-13 17:01:49 -04:00
|
|
|
m_clients.sendToAll(0, &pkt, true);
|
2014-01-30 18:24:00 -05:00
|
|
|
}
|
|
|
|
else {
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2014-01-30 18:24:00 -05:00
|
|
|
}
|
2013-08-10 22:09:45 -04:00
|
|
|
}
|
|
|
|
|
2012-03-18 22:04:16 -04:00
|
|
|
void Server::SendPlayerHP(u16 peer_id)
|
2011-04-21 12:35:17 -04:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2012-03-18 22:04:16 -04:00
|
|
|
PlayerSAO *playersao = getPlayerSAO(peer_id);
|
2016-05-08 05:02:11 -04:00
|
|
|
// In some rare case if the player is disconnected
|
2015-04-11 04:07:23 -04:00
|
|
|
// while Lua call l_punch, for example, this can be NULL
|
|
|
|
if (!playersao)
|
|
|
|
return;
|
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
SendHP(peer_id, playersao->getHP());
|
2014-04-28 17:41:27 -04:00
|
|
|
m_script->player_event(playersao,"health_changed");
|
2013-08-13 17:06:39 -04:00
|
|
|
|
|
|
|
// Send to other clients
|
|
|
|
std::string str = gob_cmd_punched(playersao->readDamage(), playersao->getHP());
|
|
|
|
ActiveObjectMessage aom(playersao->getId(), true, str);
|
2015-03-04 11:48:07 -05:00
|
|
|
playersao->m_messages_out.push(aom);
|
2011-04-21 12:35:17 -04:00
|
|
|
}
|
|
|
|
|
2013-07-19 13:50:33 -04:00
|
|
|
void Server::SendPlayerBreath(u16 peer_id)
|
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2013-07-19 13:50:33 -04:00
|
|
|
PlayerSAO *playersao = getPlayerSAO(peer_id);
|
|
|
|
assert(playersao);
|
2015-03-03 10:23:47 -05:00
|
|
|
|
|
|
|
m_script->player_event(playersao, "breath_changed");
|
2014-01-30 18:24:00 -05:00
|
|
|
SendBreath(peer_id, playersao->getBreath());
|
2013-07-19 13:50:33 -04:00
|
|
|
}
|
|
|
|
|
2012-03-18 22:04:16 -04:00
|
|
|
void Server::SendMovePlayer(u16 peer_id)
|
2011-04-21 12:35:17 -04:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2012-03-18 22:04:16 -04:00
|
|
|
Player *player = m_env->getPlayer(peer_id);
|
|
|
|
assert(player);
|
2011-04-21 12:35:17 -04:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_MOVE_PLAYER, sizeof(v3f) + sizeof(f32) * 2, peer_id);
|
|
|
|
pkt << player->getPosition() << player->getPitch() << player->getYaw();
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-04-21 12:35:17 -04:00
|
|
|
{
|
|
|
|
v3f pos = player->getPosition();
|
|
|
|
f32 pitch = player->getPitch();
|
|
|
|
f32 yaw = player->getYaw();
|
2015-03-13 17:01:49 -04:00
|
|
|
verbosestream << "Server: Sending TOCLIENT_MOVE_PLAYER"
|
|
|
|
<< " pos=(" << pos.X << "," << pos.Y << "," << pos.Z << ")"
|
|
|
|
<< " pitch=" << pitch
|
|
|
|
<< " yaw=" << yaw
|
|
|
|
<< std::endl;
|
2011-04-21 12:35:17 -04:00
|
|
|
}
|
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2011-04-21 12:35:17 -04:00
|
|
|
}
|
|
|
|
|
2014-04-12 07:50:22 -04:00
|
|
|
void Server::SendLocalPlayerAnimations(u16 peer_id, v2s32 animation_frames[4], f32 animation_speed)
|
2014-01-08 07:47:53 -05:00
|
|
|
{
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_LOCAL_PLAYER_ANIMATIONS, 0,
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
peer_id);
|
2014-01-08 07:47:53 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << animation_frames[0] << animation_frames[1] << animation_frames[2]
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
<< animation_frames[3] << animation_speed;
|
2014-01-08 07:47:53 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2014-01-08 07:47:53 -05:00
|
|
|
}
|
|
|
|
|
2014-04-11 09:32:46 -04:00
|
|
|
void Server::SendEyeOffset(u16 peer_id, v3f first, v3f third)
|
|
|
|
{
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_EYE_OFFSET, 0, peer_id);
|
|
|
|
pkt << first << third;
|
|
|
|
Send(&pkt);
|
2014-04-11 09:32:46 -04:00
|
|
|
}
|
2012-03-31 09:23:26 -04:00
|
|
|
void Server::SendPlayerPrivileges(u16 peer_id)
|
|
|
|
{
|
|
|
|
Player *player = m_env->getPlayer(peer_id);
|
|
|
|
assert(player);
|
2012-07-19 07:09:16 -04:00
|
|
|
if(player->peer_id == PEER_ID_INEXISTENT)
|
|
|
|
return;
|
|
|
|
|
2012-03-31 09:23:26 -04:00
|
|
|
std::set<std::string> privs;
|
2013-05-24 18:51:02 -04:00
|
|
|
m_script->getAuth(player->getName(), NULL, &privs);
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_PRIVILEGES, 0, peer_id);
|
|
|
|
pkt << (u16) privs.size();
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
|
2012-03-31 09:23:26 -04:00
|
|
|
for(std::set<std::string>::const_iterator i = privs.begin();
|
2015-08-25 16:23:05 -04:00
|
|
|
i != privs.end(); ++i) {
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << (*i);
|
2012-03-31 09:23:26 -04:00
|
|
|
}
|
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2012-03-31 09:23:26 -04:00
|
|
|
}
|
|
|
|
|
2012-07-19 07:09:16 -04:00
|
|
|
void Server::SendPlayerInventoryFormspec(u16 peer_id)
|
|
|
|
{
|
|
|
|
Player *player = m_env->getPlayer(peer_id);
|
|
|
|
assert(player);
|
|
|
|
if(player->peer_id == PEER_ID_INEXISTENT)
|
|
|
|
return;
|
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_INVENTORY_FORMSPEC, 0, peer_id);
|
|
|
|
pkt.putLongString(FORMSPEC_VERSION_STRING + player->inventory_formspec);
|
|
|
|
Send(&pkt);
|
2012-07-19 07:09:16 -04:00
|
|
|
}
|
|
|
|
|
2015-03-16 07:01:40 -04:00
|
|
|
u32 Server::SendActiveObjectRemoveAdd(u16 peer_id, const std::string &datas)
|
|
|
|
{
|
2015-04-05 05:37:53 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_ACTIVE_OBJECT_REMOVE_ADD, datas.size(), peer_id);
|
2015-03-16 07:01:40 -04:00
|
|
|
pkt.putRawString(datas.c_str(), datas.size());
|
|
|
|
Send(&pkt);
|
|
|
|
return pkt.getSize();
|
|
|
|
}
|
|
|
|
|
2015-03-17 04:16:39 -04:00
|
|
|
void Server::SendActiveObjectMessages(u16 peer_id, const std::string &datas, bool reliable)
|
2015-03-16 07:01:40 -04:00
|
|
|
{
|
|
|
|
NetworkPacket pkt(TOCLIENT_ACTIVE_OBJECT_MESSAGES,
|
2015-04-05 05:37:53 -04:00
|
|
|
datas.size(), peer_id);
|
2015-03-16 07:01:40 -04:00
|
|
|
|
|
|
|
pkt.putRawString(datas.c_str(), datas.size());
|
2015-03-17 04:16:39 -04:00
|
|
|
|
|
|
|
m_clients.send(pkt.getPeerId(),
|
2015-04-07 08:28:36 -04:00
|
|
|
reliable ? clientCommandFactoryTable[pkt.getCommand()].channel : 1,
|
2015-03-17 04:16:39 -04:00
|
|
|
&pkt, reliable);
|
|
|
|
|
2015-03-16 07:01:40 -04:00
|
|
|
}
|
|
|
|
|
2012-03-24 13:01:26 -04:00
|
|
|
s32 Server::playSound(const SimpleSoundSpec &spec,
|
|
|
|
const ServerSoundParams ¶ms)
|
|
|
|
{
|
|
|
|
// Find out initial position of sound
|
|
|
|
bool pos_exists = false;
|
|
|
|
v3f pos = params.getPos(m_env, &pos_exists);
|
|
|
|
// If position is not found while it should be, cancel sound
|
|
|
|
if(pos_exists != (params.type != ServerSoundParams::SSP_LOCAL))
|
|
|
|
return -1;
|
2014-01-30 18:24:00 -05:00
|
|
|
|
2012-03-24 13:01:26 -04:00
|
|
|
// Filter destination clients
|
2015-03-05 05:39:05 -05:00
|
|
|
std::vector<u16> dst_clients;
|
2012-03-24 13:01:26 -04:00
|
|
|
if(params.to_player != "")
|
|
|
|
{
|
|
|
|
Player *player = m_env->getPlayer(params.to_player.c_str());
|
|
|
|
if(!player){
|
|
|
|
infostream<<"Server::playSound: Player \""<<params.to_player
|
|
|
|
<<"\" not found"<<std::endl;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if(player->peer_id == PEER_ID_INEXISTENT){
|
|
|
|
infostream<<"Server::playSound: Player \""<<params.to_player
|
|
|
|
<<"\" not connected"<<std::endl;
|
|
|
|
return -1;
|
|
|
|
}
|
2014-01-30 18:24:00 -05:00
|
|
|
dst_clients.push_back(player->peer_id);
|
2012-03-24 13:01:26 -04:00
|
|
|
}
|
2015-03-05 05:39:05 -05:00
|
|
|
else {
|
2015-03-04 10:30:24 -05:00
|
|
|
std::vector<u16> clients = m_clients.getClientIDs();
|
2014-01-30 18:24:00 -05:00
|
|
|
|
2015-03-04 10:30:24 -05:00
|
|
|
for(std::vector<u16>::iterator
|
|
|
|
i = clients.begin(); i != clients.end(); ++i) {
|
2014-01-30 18:24:00 -05:00
|
|
|
Player *player = m_env->getPlayer(*i);
|
2012-03-24 13:01:26 -04:00
|
|
|
if(!player)
|
|
|
|
continue;
|
2015-03-04 10:30:24 -05:00
|
|
|
|
|
|
|
if(pos_exists) {
|
2012-03-24 13:01:26 -04:00
|
|
|
if(player->getPosition().getDistanceFrom(pos) >
|
|
|
|
params.max_hear_distance)
|
|
|
|
continue;
|
|
|
|
}
|
2014-01-30 18:24:00 -05:00
|
|
|
dst_clients.push_back(*i);
|
2012-03-24 13:01:26 -04:00
|
|
|
}
|
|
|
|
}
|
2015-03-04 10:30:24 -05:00
|
|
|
|
2014-12-12 09:55:40 -05:00
|
|
|
if(dst_clients.empty())
|
2012-03-24 13:01:26 -04:00
|
|
|
return -1;
|
2014-01-30 18:24:00 -05:00
|
|
|
|
2012-03-24 13:01:26 -04:00
|
|
|
// Create the sound
|
|
|
|
s32 id = m_next_sound_id++;
|
|
|
|
// The sound will exist as a reference in m_playing_sounds
|
|
|
|
m_playing_sounds[id] = ServerPlayingSound();
|
|
|
|
ServerPlayingSound &psound = m_playing_sounds[id];
|
|
|
|
psound.params = params;
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_PLAY_SOUND, 0);
|
|
|
|
pkt << id << spec.name << (float) (spec.gain * params.gain)
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
<< (u8) params.type << pos << params.object << params.loop;
|
2015-03-05 05:39:05 -05:00
|
|
|
|
|
|
|
for(std::vector<u16>::iterator i = dst_clients.begin();
|
2015-08-25 16:23:05 -04:00
|
|
|
i != dst_clients.end(); ++i) {
|
2015-03-05 05:39:05 -05:00
|
|
|
psound.clients.insert(*i);
|
2015-03-13 17:01:49 -04:00
|
|
|
m_clients.send(*i, 0, &pkt, true);
|
2012-03-24 13:01:26 -04:00
|
|
|
}
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
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())
|
|
|
|
return;
|
|
|
|
ServerPlayingSound &psound = i->second;
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_STOP_SOUND, 4);
|
|
|
|
pkt << handle;
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
|
2012-03-24 13:01:26 -04:00
|
|
|
for(std::set<u16>::iterator i = psound.clients.begin();
|
2015-08-25 16:23:05 -04:00
|
|
|
i != psound.clients.end(); ++i) {
|
2012-03-24 13:01:26 -04:00
|
|
|
// Send as reliable
|
2015-03-13 17:01:49 -04:00
|
|
|
m_clients.send(*i, 0, &pkt, true);
|
2012-03-24 13:01:26 -04:00
|
|
|
}
|
|
|
|
// Remove sound reference
|
|
|
|
m_playing_sounds.erase(i);
|
|
|
|
}
|
|
|
|
|
2011-04-21 12:35:17 -04:00
|
|
|
void Server::sendRemoveNode(v3s16 p, u16 ignore_id,
|
2015-03-05 05:18:17 -05:00
|
|
|
std::vector<u16> *far_players, float far_d_nodes)
|
2011-04-21 12:35:17 -04:00
|
|
|
{
|
|
|
|
float maxd = far_d_nodes*BS;
|
|
|
|
v3f p_f = intToFloat(p, BS);
|
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_REMOVENODE, 6);
|
|
|
|
pkt << p;
|
2011-04-21 12:35:17 -04:00
|
|
|
|
2015-03-04 10:30:24 -05:00
|
|
|
std::vector<u16> clients = m_clients.getClientIDs();
|
|
|
|
for(std::vector<u16>::iterator i = clients.begin();
|
2015-02-21 11:24:27 -05:00
|
|
|
i != clients.end(); ++i) {
|
2015-03-05 05:18:17 -05:00
|
|
|
if (far_players) {
|
2011-04-21 12:35:17 -04:00
|
|
|
// Get player
|
2015-02-21 11:24:27 -05:00
|
|
|
if(Player *player = m_env->getPlayer(*i)) {
|
2011-04-21 12:35:17 -04:00
|
|
|
// If player is far away, only set modified blocks not sent
|
|
|
|
v3f player_pos = player->getPosition();
|
2015-02-21 11:24:27 -05:00
|
|
|
if(player_pos.getDistanceFrom(p_f) > maxd) {
|
2014-01-30 18:24:00 -05:00
|
|
|
far_players->push_back(*i);
|
2011-04-21 12:35:17 -04:00
|
|
|
continue;
|
2010-12-25 09:04:51 -05:00
|
|
|
}
|
2010-12-24 18:54:39 -05:00
|
|
|
}
|
2011-04-21 12:35:17 -04:00
|
|
|
}
|
2010-12-24 18:54:39 -05:00
|
|
|
|
2011-04-21 12:35:17 -04:00
|
|
|
// Send as reliable
|
2015-03-13 17:01:49 -04:00
|
|
|
m_clients.send(*i, 0, &pkt, true);
|
2011-04-21 12:35:17 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Server::sendAddNode(v3s16 p, MapNode n, u16 ignore_id,
|
2015-03-05 05:18:17 -05:00
|
|
|
std::vector<u16> *far_players, float far_d_nodes,
|
2013-11-23 09:35:49 -05:00
|
|
|
bool remove_metadata)
|
2011-04-21 12:35:17 -04:00
|
|
|
{
|
|
|
|
float maxd = far_d_nodes*BS;
|
|
|
|
v3f p_f = intToFloat(p, BS);
|
|
|
|
|
2015-03-04 10:30:24 -05:00
|
|
|
std::vector<u16> clients = m_clients.getClientIDs();
|
|
|
|
for(std::vector<u16>::iterator i = clients.begin();
|
|
|
|
i != clients.end(); ++i) {
|
2011-04-21 12:35:17 -04:00
|
|
|
|
2015-03-04 10:30:24 -05:00
|
|
|
if(far_players) {
|
2011-04-21 12:35:17 -04:00
|
|
|
// Get player
|
2015-03-04 10:30:24 -05:00
|
|
|
if(Player *player = m_env->getPlayer(*i)) {
|
2011-04-21 12:35:17 -04:00
|
|
|
// If player is far away, only set modified blocks not sent
|
|
|
|
v3f player_pos = player->getPosition();
|
2015-03-04 10:30:24 -05:00
|
|
|
if(player_pos.getDistanceFrom(p_f) > maxd) {
|
2014-01-30 18:24:00 -05:00
|
|
|
far_players->push_back(*i);
|
2011-04-21 12:35:17 -04:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_ADDNODE, 6 + 2 + 1 + 1 + 1);
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.lock();
|
2014-01-30 18:24:00 -05:00
|
|
|
RemoteClient* client = m_clients.lockedGetClientNoEx(*i);
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
if (client != 0) {
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << p << n.param0 << n.param1 << n.param2
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
<< (u8) (remove_metadata ? 0 : 1);
|
2014-01-30 18:24:00 -05:00
|
|
|
|
|
|
|
if (!remove_metadata) {
|
|
|
|
if (client->net_proto_version <= 21) {
|
|
|
|
// Old clients always clear metadata; fix it
|
|
|
|
// by sending the full block again.
|
2015-09-17 14:08:11 -04:00
|
|
|
client->SetBlockNotSent(getNodeBlockPos(p));
|
2014-01-30 18:24:00 -05:00
|
|
|
}
|
2013-11-23 09:35:49 -05:00
|
|
|
}
|
|
|
|
}
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.unlock();
|
2011-04-21 12:35:17 -04:00
|
|
|
|
|
|
|
// Send as reliable
|
2015-03-13 17:01:49 -04:00
|
|
|
if (pkt.getSize() > 0)
|
|
|
|
m_clients.send(*i, 0, &pkt, true);
|
2011-04-21 12:35:17 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-31 13:02:55 -04:00
|
|
|
void Server::setBlockNotSent(v3s16 p)
|
|
|
|
{
|
2015-03-04 10:30:24 -05:00
|
|
|
std::vector<u16> clients = m_clients.getClientIDs();
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.lock();
|
2015-03-04 10:30:24 -05:00
|
|
|
for(std::vector<u16>::iterator i = clients.begin();
|
|
|
|
i != clients.end(); ++i) {
|
2014-01-30 18:24:00 -05:00
|
|
|
RemoteClient *client = m_clients.lockedGetClientNoEx(*i);
|
2011-05-31 13:02:55 -04:00
|
|
|
client->SetBlockNotSent(p);
|
|
|
|
}
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.unlock();
|
2011-05-31 13:02:55 -04:00
|
|
|
}
|
|
|
|
|
2013-08-01 16:51:36 -04:00
|
|
|
void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto_version)
|
2011-04-21 12:35:17 -04:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2011-04-25 17:23:38 -04:00
|
|
|
|
|
|
|
v3s16 p = block->getPos();
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-04-21 12:35:17 -04:00
|
|
|
/*
|
|
|
|
Create a packet with the block in the right format
|
|
|
|
*/
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-04-21 12:35:17 -04:00
|
|
|
std::ostringstream os(std::ios_base::binary);
|
2012-01-20 18:11:44 -05:00
|
|
|
block->serialize(os, ver, false);
|
2013-08-01 16:51:36 -04:00
|
|
|
block->serializeNetworkSpecific(os, net_proto_version);
|
2011-04-21 12:35:17 -04:00
|
|
|
std::string s = os.str();
|
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_BLOCKDATA, 2 + 2 + 2 + 2 + s.size(), peer_id);
|
2011-04-21 12:35:17 -04:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << p;
|
|
|
|
pkt.putRawString(s.c_str(), s.size());
|
|
|
|
Send(&pkt);
|
2011-04-21 12:35:17 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void Server::SendBlocks(float dtime)
|
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2011-04-21 12:35:17 -04:00
|
|
|
|
2015-04-07 06:13:12 -04:00
|
|
|
MutexAutoLock envlock(m_env_mutex);
|
2014-01-30 18:24:00 -05:00
|
|
|
//TODO check if one big lock could be faster then multiple small ones
|
2011-04-21 12:35:17 -04:00
|
|
|
|
2012-03-07 14:54:18 -05:00
|
|
|
ScopeProfiler sp(g_profiler, "Server: sel and send blocks to clients");
|
2011-04-21 12:35:17 -04:00
|
|
|
|
2012-12-20 12:19:49 -05:00
|
|
|
std::vector<PrioritySortedBlockTransfer> queue;
|
2011-04-21 12:35:17 -04:00
|
|
|
|
|
|
|
s32 total_sending = 0;
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-04-21 12:35:17 -04:00
|
|
|
{
|
2011-10-12 06:53:38 -04:00
|
|
|
ScopeProfiler sp(g_profiler, "Server: selecting blocks for sending");
|
2011-04-21 12:35:17 -04:00
|
|
|
|
2015-03-04 10:30:24 -05:00
|
|
|
std::vector<u16> clients = m_clients.getClientIDs();
|
2014-01-30 18:24:00 -05:00
|
|
|
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.lock();
|
2015-03-04 10:30:24 -05:00
|
|
|
for(std::vector<u16>::iterator i = clients.begin();
|
|
|
|
i != clients.end(); ++i) {
|
2014-06-28 02:02:38 -04:00
|
|
|
RemoteClient *client = m_clients.lockedGetClientNoEx(*i, CS_Active);
|
2011-05-30 17:15:43 -04:00
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
if (client == NULL)
|
2014-09-11 20:12:52 -04:00
|
|
|
continue;
|
2011-12-01 18:18:25 -05:00
|
|
|
|
2011-05-30 17:15:43 -04:00
|
|
|
total_sending += client->SendingCount();
|
2014-01-30 18:24:00 -05:00
|
|
|
client->GetNextBlocks(m_env,m_emerge, dtime, queue);
|
2011-05-30 17:15:43 -04:00
|
|
|
}
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.unlock();
|
2011-04-21 12:35:17 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Sort.
|
|
|
|
// Lowest priority number comes first.
|
|
|
|
// Lowest is most important.
|
2012-12-20 12:19:49 -05:00
|
|
|
std::sort(queue.begin(), queue.end());
|
2011-04-21 12:35:17 -04:00
|
|
|
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.lock();
|
2011-04-21 12:35:17 -04:00
|
|
|
for(u32 i=0; i<queue.size(); i++)
|
|
|
|
{
|
|
|
|
//TODO: Calculate limit dynamically
|
2011-10-12 06:53:38 -04:00
|
|
|
if(total_sending >= g_settings->getS32
|
2011-04-21 12:35:17 -04:00
|
|
|
("max_simultaneous_block_sends_server_total"))
|
|
|
|
break;
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2011-04-21 12:35:17 -04:00
|
|
|
PrioritySortedBlockTransfer q = queue[i];
|
|
|
|
|
|
|
|
MapBlock *block = NULL;
|
|
|
|
try
|
|
|
|
{
|
2011-11-11 12:33:17 -05:00
|
|
|
block = m_env->getMap().getBlockNoCreate(q.pos);
|
2011-04-21 12:35:17 -04:00
|
|
|
}
|
|
|
|
catch(InvalidPositionException &e)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-06-28 02:02:38 -04:00
|
|
|
RemoteClient *client = m_clients.lockedGetClientNoEx(q.peer_id, CS_Active);
|
2014-01-30 18:24:00 -05:00
|
|
|
|
2013-08-04 01:17:07 -04:00
|
|
|
if(!client)
|
|
|
|
continue;
|
2011-04-21 12:35:17 -04:00
|
|
|
|
2013-08-01 16:51:36 -04:00
|
|
|
SendBlockNoLock(q.peer_id, block, client->serialization_version, client->net_proto_version);
|
2011-04-21 12:35:17 -04:00
|
|
|
|
|
|
|
client->SentBlock(q.pos);
|
|
|
|
total_sending++;
|
|
|
|
}
|
2015-04-07 06:13:12 -04:00
|
|
|
m_clients.unlock();
|
2011-04-21 12:35:17 -04:00
|
|
|
}
|
|
|
|
|
2012-03-25 04:50:29 -04:00
|
|
|
void Server::fillMediaCache()
|
2012-03-10 21:15:45 -05:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2012-01-02 06:31:50 -05:00
|
|
|
|
2012-03-25 05:10:58 -04:00
|
|
|
infostream<<"Server: Calculating media file checksums"<<std::endl;
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2012-03-25 05:10:58 -04:00
|
|
|
// Collect all media file paths
|
2015-03-05 05:39:05 -05:00
|
|
|
std::vector<std::string> paths;
|
2012-12-08 12:10:54 -05:00
|
|
|
for(std::vector<ModSpec>::iterator i = m_mods.begin();
|
2015-08-25 16:23:05 -04:00
|
|
|
i != m_mods.end(); ++i) {
|
2012-03-10 21:15:45 -05:00
|
|
|
const ModSpec &mod = *i;
|
2012-03-25 05:10:58 -04:00
|
|
|
paths.push_back(mod.path + DIR_DELIM + "textures");
|
|
|
|
paths.push_back(mod.path + DIR_DELIM + "sounds");
|
|
|
|
paths.push_back(mod.path + DIR_DELIM + "media");
|
2012-10-23 17:11:24 -04:00
|
|
|
paths.push_back(mod.path + DIR_DELIM + "models");
|
2012-03-25 05:10:58 -04:00
|
|
|
}
|
2013-08-02 09:18:48 -04:00
|
|
|
paths.push_back(porting::path_user + DIR_DELIM + "textures" + DIR_DELIM + "server");
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2012-03-25 05:10:58 -04:00
|
|
|
// Collect media file information from paths into cache
|
2015-03-05 05:39:05 -05:00
|
|
|
for(std::vector<std::string>::iterator i = paths.begin();
|
2015-08-25 16:23:05 -04:00
|
|
|
i != paths.end(); ++i) {
|
2012-03-25 05:10:58 -04:00
|
|
|
std::string mediapath = *i;
|
|
|
|
std::vector<fs::DirListNode> dirlist = fs::GetDirListing(mediapath);
|
2015-03-05 05:39:05 -05:00
|
|
|
for (u32 j = 0; j < dirlist.size(); j++) {
|
|
|
|
if (dirlist[j].dir) // Ignode dirs
|
2012-03-10 21:15:45 -05:00
|
|
|
continue;
|
2012-03-25 05:10:58 -04:00
|
|
|
std::string filename = dirlist[j].name;
|
2012-03-30 15:49:44 -04:00
|
|
|
// If name contains illegal characters, ignore the file
|
2015-03-05 05:39:05 -05:00
|
|
|
if (!string_allowed(filename, TEXTURENAME_ALLOWED_CHARS)) {
|
2012-03-30 15:49:44 -04:00
|
|
|
infostream<<"Server: ignoring illegal file name: \""
|
2015-03-05 05:39:05 -05:00
|
|
|
<< filename << "\"" << std::endl;
|
2012-03-10 21:15:45 -05:00
|
|
|
continue;
|
|
|
|
}
|
2012-03-30 15:49:44 -04:00
|
|
|
// If name is not in a supported format, ignore it
|
|
|
|
const char *supported_ext[] = {
|
|
|
|
".png", ".jpg", ".bmp", ".tga",
|
|
|
|
".pcx", ".ppm", ".psd", ".wal", ".rgb",
|
|
|
|
".ogg",
|
2012-10-24 15:10:05 -04:00
|
|
|
".x", ".b3d", ".md2", ".obj",
|
2012-03-30 15:49:44 -04:00
|
|
|
NULL
|
|
|
|
};
|
2015-03-05 05:39:05 -05:00
|
|
|
if (removeStringEnd(filename, supported_ext) == ""){
|
|
|
|
infostream << "Server: ignoring unsupported file extension: \""
|
|
|
|
<< filename << "\"" << std::endl;
|
2012-03-30 15:49:44 -04:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
// Ok, attempt to load the file and add to cache
|
2012-03-25 05:10:58 -04:00
|
|
|
std::string filepath = mediapath + DIR_DELIM + filename;
|
2012-03-10 21:15:45 -05:00
|
|
|
// Read data
|
2012-03-25 05:10:58 -04:00
|
|
|
std::ifstream fis(filepath.c_str(), std::ios_base::binary);
|
2015-03-05 05:39:05 -05:00
|
|
|
if (!fis.good()) {
|
|
|
|
errorstream << "Server::fillMediaCache(): Could not open \""
|
|
|
|
<< filename << "\" for reading" << std::endl;
|
2012-03-10 21:15:45 -05:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
std::ostringstream tmp_os(std::ios_base::binary);
|
|
|
|
bool bad = false;
|
2015-03-05 05:39:05 -05:00
|
|
|
for(;;) {
|
2012-03-10 21:15:45 -05:00
|
|
|
char buf[1024];
|
|
|
|
fis.read(buf, 1024);
|
|
|
|
std::streamsize len = fis.gcount();
|
|
|
|
tmp_os.write(buf, len);
|
2015-03-05 05:39:05 -05:00
|
|
|
if (fis.eof())
|
2012-03-10 21:15:45 -05:00
|
|
|
break;
|
2015-03-05 05:39:05 -05:00
|
|
|
if (!fis.good()) {
|
2012-03-10 21:15:45 -05:00
|
|
|
bad = true;
|
|
|
|
break;
|
2012-01-03 17:37:46 -05:00
|
|
|
}
|
2012-03-10 21:15:45 -05:00
|
|
|
}
|
2015-03-05 05:39:05 -05:00
|
|
|
if(bad) {
|
2012-03-25 04:50:29 -04:00
|
|
|
errorstream<<"Server::fillMediaCache(): Failed to read \""
|
2015-03-05 05:39:05 -05:00
|
|
|
<< filename << "\"" << std::endl;
|
2012-03-10 21:15:45 -05:00
|
|
|
continue;
|
|
|
|
}
|
2015-03-05 05:39:05 -05:00
|
|
|
if(tmp_os.str().length() == 0) {
|
|
|
|
errorstream << "Server::fillMediaCache(): Empty file \""
|
|
|
|
<< filepath << "\"" << std::endl;
|
2012-03-10 21:15:45 -05:00
|
|
|
continue;
|
|
|
|
}
|
2012-01-02 06:31:50 -05:00
|
|
|
|
2012-03-10 21:15:45 -05:00
|
|
|
SHA1 sha1;
|
|
|
|
sha1.addBytes(tmp_os.str().c_str(), tmp_os.str().length());
|
2012-01-02 06:31:50 -05:00
|
|
|
|
2012-03-10 21:15:45 -05:00
|
|
|
unsigned char *digest = sha1.getDigest();
|
2012-03-25 07:47:51 -04:00
|
|
|
std::string sha1_base64 = base64_encode(digest, 20);
|
|
|
|
std::string sha1_hex = hex_encode((char*)digest, 20);
|
2012-03-10 21:15:45 -05:00
|
|
|
free(digest);
|
2012-01-02 06:31:50 -05:00
|
|
|
|
2012-03-10 21:15:45 -05:00
|
|
|
// Put in list
|
2015-03-05 05:39:05 -05:00
|
|
|
m_media[filename] = MediaInfo(filepath, sha1_base64);
|
|
|
|
verbosestream << "Server: " << sha1_hex << " is " << filename
|
|
|
|
<< std::endl;
|
2012-03-10 21:15:45 -05:00
|
|
|
}
|
2012-01-02 06:31:50 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-25 04:50:29 -04:00
|
|
|
void Server::sendMediaAnnouncement(u16 peer_id)
|
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2012-01-02 06:31:50 -05:00
|
|
|
|
2015-07-30 17:14:05 -04:00
|
|
|
verbosestream << "Server: Announcing files to id(" << peer_id << ")"
|
|
|
|
<< std::endl;
|
2012-01-02 06:31:50 -05:00
|
|
|
|
2012-03-25 04:50:29 -04:00
|
|
|
// Make packet
|
|
|
|
std::ostringstream os(std::ios_base::binary);
|
2012-01-02 06:31:50 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_ANNOUNCE_MEDIA, 0, peer_id);
|
2015-07-30 17:14:05 -04:00
|
|
|
pkt << (u16) m_media.size();
|
2012-01-02 06:31:50 -05:00
|
|
|
|
2015-07-30 17:14:05 -04:00
|
|
|
for (std::map<std::string, MediaInfo>::iterator i = m_media.begin();
|
|
|
|
i != m_media.end(); ++i) {
|
|
|
|
pkt << i->first << i->second.sha1_digest;
|
2012-01-02 06:31:50 -05:00
|
|
|
}
|
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << g_settings->get("remote_media");
|
|
|
|
Send(&pkt);
|
2012-01-02 06:31:50 -05:00
|
|
|
}
|
|
|
|
|
2012-03-25 04:50:29 -04:00
|
|
|
struct SendableMedia
|
2011-11-15 04:02:47 -05:00
|
|
|
{
|
|
|
|
std::string name;
|
|
|
|
std::string path;
|
|
|
|
std::string data;
|
|
|
|
|
2014-02-27 15:12:59 -05:00
|
|
|
SendableMedia(const std::string &name_="", const std::string &path_="",
|
|
|
|
const std::string &data_=""):
|
2011-11-15 04:02:47 -05:00
|
|
|
name(name_),
|
|
|
|
path(path_),
|
|
|
|
data(data_)
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
2012-03-25 04:50:29 -04:00
|
|
|
void Server::sendRequestedMedia(u16 peer_id,
|
2015-03-05 05:39:05 -05:00
|
|
|
const std::vector<std::string> &tosend)
|
2012-03-25 04:50:29 -04:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2011-11-15 04:02:47 -05:00
|
|
|
|
2012-03-25 04:50:29 -04:00
|
|
|
verbosestream<<"Server::sendRequestedMedia(): "
|
|
|
|
<<"Sending files to client"<<std::endl;
|
2012-01-02 06:31:50 -05:00
|
|
|
|
2012-03-25 04:50:29 -04:00
|
|
|
/* Read files */
|
2012-01-02 06:31:50 -05:00
|
|
|
|
2011-11-15 16:58:56 -05:00
|
|
|
// Put 5kB in one bunch (this is not accurate)
|
|
|
|
u32 bytes_per_bunch = 5000;
|
2012-01-02 06:31:50 -05:00
|
|
|
|
2015-03-05 05:39:05 -05:00
|
|
|
std::vector< std::vector<SendableMedia> > file_bunches;
|
|
|
|
file_bunches.push_back(std::vector<SendableMedia>());
|
2012-01-02 06:31:50 -05:00
|
|
|
|
2012-03-25 04:50:29 -04:00
|
|
|
u32 file_size_bunch_total = 0;
|
2012-01-02 06:31:50 -05:00
|
|
|
|
2015-03-05 05:39:05 -05:00
|
|
|
for(std::vector<std::string>::const_iterator i = tosend.begin();
|
|
|
|
i != tosend.end(); ++i) {
|
Rewrite client media download and support hash-based remote download
Move most of the media-related code in client.cpp into a new class
ClientMediaDownloader (clientmedia.cpp, clientmedia.h). Among other
things, this class does the following things:
- Download [remote_server][sha1] instead of [remote_server][name]. This
is to support servers that provide the same file name with different
contents.
- Initially fetch [remote_server]index.mth. This file should follow the
Minetest Hashset format (currently version 1) and contain a list of SHA1
hashes that exist on the server.
- The list of needed SHA1s is uploaded (via HTTP POST) when index.mth is
requested, so servers can optionally narrow down the list to the needs
of the client.
- If index.mth is missing (HTTP response code 404), we enter compat mode,
fetching [remote_server][name] as before this commit.
- remote_server can now contain multiple servers, separated by commas.
The downloader code attempts to split requests between the different
servers, as permitted by each server's index.mth. If one server claims
to have a file but actually doesn't (or something fails), we ask a
different server that also claims to have it.
- As before, when none of the remote servers provide a particular
file, we download it via the conventional method, i.e. using
the minetest protocol: TOSERVER_REQUEST_MEDIA / TOCLIENT_MEDIA.
- Bugfix: Every downloaded file's SHA1 is now verified against the SHA1
announced by the minetest server (before loading it and inserting it
into the file cache).
- Bugfix: Only send TOSERVER_RECEIVED_MEDIA when we actually have all
media. This should fix #863.
2013-08-28 23:22:18 -04:00
|
|
|
const std::string &name = *i;
|
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
if(m_media.find(name) == m_media.end()) {
|
2012-03-25 04:50:29 -04:00
|
|
|
errorstream<<"Server::sendRequestedMedia(): Client asked for "
|
Rewrite client media download and support hash-based remote download
Move most of the media-related code in client.cpp into a new class
ClientMediaDownloader (clientmedia.cpp, clientmedia.h). Among other
things, this class does the following things:
- Download [remote_server][sha1] instead of [remote_server][name]. This
is to support servers that provide the same file name with different
contents.
- Initially fetch [remote_server]index.mth. This file should follow the
Minetest Hashset format (currently version 1) and contain a list of SHA1
hashes that exist on the server.
- The list of needed SHA1s is uploaded (via HTTP POST) when index.mth is
requested, so servers can optionally narrow down the list to the needs
of the client.
- If index.mth is missing (HTTP response code 404), we enter compat mode,
fetching [remote_server][name] as before this commit.
- remote_server can now contain multiple servers, separated by commas.
The downloader code attempts to split requests between the different
servers, as permitted by each server's index.mth. If one server claims
to have a file but actually doesn't (or something fails), we ask a
different server that also claims to have it.
- As before, when none of the remote servers provide a particular
file, we download it via the conventional method, i.e. using
the minetest protocol: TOSERVER_REQUEST_MEDIA / TOCLIENT_MEDIA.
- Bugfix: Every downloaded file's SHA1 is now verified against the SHA1
announced by the minetest server (before loading it and inserting it
into the file cache).
- Bugfix: Only send TOSERVER_RECEIVED_MEDIA when we actually have all
media. This should fix #863.
2013-08-28 23:22:18 -04:00
|
|
|
<<"unknown file \""<<(name)<<"\""<<std::endl;
|
2012-01-03 17:37:46 -05:00
|
|
|
continue;
|
|
|
|
}
|
2012-01-02 06:31:50 -05:00
|
|
|
|
|
|
|
//TODO get path + name
|
Rewrite client media download and support hash-based remote download
Move most of the media-related code in client.cpp into a new class
ClientMediaDownloader (clientmedia.cpp, clientmedia.h). Among other
things, this class does the following things:
- Download [remote_server][sha1] instead of [remote_server][name]. This
is to support servers that provide the same file name with different
contents.
- Initially fetch [remote_server]index.mth. This file should follow the
Minetest Hashset format (currently version 1) and contain a list of SHA1
hashes that exist on the server.
- The list of needed SHA1s is uploaded (via HTTP POST) when index.mth is
requested, so servers can optionally narrow down the list to the needs
of the client.
- If index.mth is missing (HTTP response code 404), we enter compat mode,
fetching [remote_server][name] as before this commit.
- remote_server can now contain multiple servers, separated by commas.
The downloader code attempts to split requests between the different
servers, as permitted by each server's index.mth. If one server claims
to have a file but actually doesn't (or something fails), we ask a
different server that also claims to have it.
- As before, when none of the remote servers provide a particular
file, we download it via the conventional method, i.e. using
the minetest protocol: TOSERVER_REQUEST_MEDIA / TOCLIENT_MEDIA.
- Bugfix: Every downloaded file's SHA1 is now verified against the SHA1
announced by the minetest server (before loading it and inserting it
into the file cache).
- Bugfix: Only send TOSERVER_RECEIVED_MEDIA when we actually have all
media. This should fix #863.
2013-08-28 23:22:18 -04:00
|
|
|
std::string tpath = m_media[name].path;
|
2012-01-02 06:31:50 -05:00
|
|
|
|
|
|
|
// Read data
|
|
|
|
std::ifstream fis(tpath.c_str(), std::ios_base::binary);
|
|
|
|
if(fis.good() == false){
|
2012-03-25 04:50:29 -04:00
|
|
|
errorstream<<"Server::sendRequestedMedia(): Could not open \""
|
2012-01-02 06:31:50 -05:00
|
|
|
<<tpath<<"\" for reading"<<std::endl;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
std::ostringstream tmp_os(std::ios_base::binary);
|
|
|
|
bool bad = false;
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
for(;;) {
|
2012-01-02 06:31:50 -05:00
|
|
|
char buf[1024];
|
|
|
|
fis.read(buf, 1024);
|
|
|
|
std::streamsize len = fis.gcount();
|
|
|
|
tmp_os.write(buf, len);
|
2012-03-25 04:50:29 -04:00
|
|
|
file_size_bunch_total += len;
|
2012-01-02 06:31:50 -05:00
|
|
|
if(fis.eof())
|
|
|
|
break;
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
if(!fis.good()) {
|
2012-01-02 06:31:50 -05:00
|
|
|
bad = true;
|
|
|
|
break;
|
2011-11-15 16:58:56 -05:00
|
|
|
}
|
2011-11-15 04:02:47 -05:00
|
|
|
}
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
if(bad) {
|
2012-03-25 04:50:29 -04:00
|
|
|
errorstream<<"Server::sendRequestedMedia(): Failed to read \""
|
Rewrite client media download and support hash-based remote download
Move most of the media-related code in client.cpp into a new class
ClientMediaDownloader (clientmedia.cpp, clientmedia.h). Among other
things, this class does the following things:
- Download [remote_server][sha1] instead of [remote_server][name]. This
is to support servers that provide the same file name with different
contents.
- Initially fetch [remote_server]index.mth. This file should follow the
Minetest Hashset format (currently version 1) and contain a list of SHA1
hashes that exist on the server.
- The list of needed SHA1s is uploaded (via HTTP POST) when index.mth is
requested, so servers can optionally narrow down the list to the needs
of the client.
- If index.mth is missing (HTTP response code 404), we enter compat mode,
fetching [remote_server][name] as before this commit.
- remote_server can now contain multiple servers, separated by commas.
The downloader code attempts to split requests between the different
servers, as permitted by each server's index.mth. If one server claims
to have a file but actually doesn't (or something fails), we ask a
different server that also claims to have it.
- As before, when none of the remote servers provide a particular
file, we download it via the conventional method, i.e. using
the minetest protocol: TOSERVER_REQUEST_MEDIA / TOCLIENT_MEDIA.
- Bugfix: Every downloaded file's SHA1 is now verified against the SHA1
announced by the minetest server (before loading it and inserting it
into the file cache).
- Bugfix: Only send TOSERVER_RECEIVED_MEDIA when we actually have all
media. This should fix #863.
2013-08-28 23:22:18 -04:00
|
|
|
<<name<<"\""<<std::endl;
|
2012-01-02 06:31:50 -05:00
|
|
|
continue;
|
|
|
|
}
|
2012-03-25 04:50:29 -04:00
|
|
|
/*infostream<<"Server::sendRequestedMedia(): Loaded \""
|
2012-01-02 06:31:50 -05:00
|
|
|
<<tname<<"\""<<std::endl;*/
|
|
|
|
// Put in list
|
2012-03-25 04:50:29 -04:00
|
|
|
file_bunches[file_bunches.size()-1].push_back(
|
Rewrite client media download and support hash-based remote download
Move most of the media-related code in client.cpp into a new class
ClientMediaDownloader (clientmedia.cpp, clientmedia.h). Among other
things, this class does the following things:
- Download [remote_server][sha1] instead of [remote_server][name]. This
is to support servers that provide the same file name with different
contents.
- Initially fetch [remote_server]index.mth. This file should follow the
Minetest Hashset format (currently version 1) and contain a list of SHA1
hashes that exist on the server.
- The list of needed SHA1s is uploaded (via HTTP POST) when index.mth is
requested, so servers can optionally narrow down the list to the needs
of the client.
- If index.mth is missing (HTTP response code 404), we enter compat mode,
fetching [remote_server][name] as before this commit.
- remote_server can now contain multiple servers, separated by commas.
The downloader code attempts to split requests between the different
servers, as permitted by each server's index.mth. If one server claims
to have a file but actually doesn't (or something fails), we ask a
different server that also claims to have it.
- As before, when none of the remote servers provide a particular
file, we download it via the conventional method, i.e. using
the minetest protocol: TOSERVER_REQUEST_MEDIA / TOCLIENT_MEDIA.
- Bugfix: Every downloaded file's SHA1 is now verified against the SHA1
announced by the minetest server (before loading it and inserting it
into the file cache).
- Bugfix: Only send TOSERVER_RECEIVED_MEDIA when we actually have all
media. This should fix #863.
2013-08-28 23:22:18 -04:00
|
|
|
SendableMedia(name, tpath, tmp_os.str()));
|
2012-01-02 06:31:50 -05:00
|
|
|
|
|
|
|
// Start next bunch if got enough data
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
if(file_size_bunch_total >= bytes_per_bunch) {
|
2015-03-05 05:39:05 -05:00
|
|
|
file_bunches.push_back(std::vector<SendableMedia>());
|
2012-03-25 04:50:29 -04:00
|
|
|
file_size_bunch_total = 0;
|
2012-01-02 06:31:50 -05:00
|
|
|
}
|
|
|
|
|
2011-11-15 04:02:47 -05:00
|
|
|
}
|
|
|
|
|
2011-11-15 16:58:56 -05:00
|
|
|
/* Create and send packets */
|
2012-01-02 06:31:50 -05:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
u16 num_bunches = file_bunches.size();
|
|
|
|
for(u16 i = 0; i < num_bunches; i++) {
|
2012-03-25 04:50:29 -04:00
|
|
|
/*
|
|
|
|
u16 command
|
|
|
|
u16 total number of texture bunches
|
|
|
|
u16 index of this bunch
|
|
|
|
u32 number of files in this bunch
|
|
|
|
for each file {
|
|
|
|
u16 length of name
|
|
|
|
string name
|
|
|
|
u32 length of data
|
|
|
|
data
|
2011-11-15 16:58:56 -05:00
|
|
|
}
|
2012-03-25 04:50:29 -04:00
|
|
|
*/
|
2011-11-15 04:02:47 -05:00
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_MEDIA, 4 + 0, peer_id);
|
|
|
|
pkt << num_bunches << i << (u32) file_bunches[i].size();
|
2012-01-02 06:31:50 -05:00
|
|
|
|
2015-03-05 05:39:05 -05:00
|
|
|
for(std::vector<SendableMedia>::iterator
|
2012-03-25 04:50:29 -04:00
|
|
|
j = file_bunches[i].begin();
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
j != file_bunches[i].end(); ++j) {
|
2015-03-13 17:01:49 -04:00
|
|
|
pkt << j->name;
|
|
|
|
pkt.putLongString(j->data);
|
2012-03-25 04:50:29 -04:00
|
|
|
}
|
2012-01-02 06:31:50 -05:00
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
verbosestream << "Server::sendRequestedMedia(): bunch "
|
|
|
|
<< i << "/" << num_bunches
|
|
|
|
<< " files=" << file_bunches[i].size()
|
2015-03-13 17:01:49 -04:00
|
|
|
<< " size=" << pkt.getSize() << std::endl;
|
|
|
|
Send(&pkt);
|
2012-03-25 04:50:29 -04:00
|
|
|
}
|
2011-11-15 04:02:47 -05:00
|
|
|
}
|
|
|
|
|
2012-07-24 13:57:17 -04:00
|
|
|
void Server::sendDetachedInventory(const std::string &name, u16 peer_id)
|
|
|
|
{
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
if(m_detached_inventories.count(name) == 0) {
|
2015-10-14 02:39:30 -04:00
|
|
|
errorstream<<FUNCTION_NAME<<": \""<<name<<"\" not found"<<std::endl;
|
2012-07-24 13:57:17 -04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
Inventory *inv = m_detached_inventories[name];
|
|
|
|
std::ostringstream os(std::ios_base::binary);
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
|
|
|
|
os << serializeString(name);
|
2012-07-24 13:57:17 -04:00
|
|
|
inv->serialize(os);
|
|
|
|
|
|
|
|
// Make data buffer
|
|
|
|
std::string s = os.str();
|
|
|
|
|
2015-03-13 17:01:49 -04:00
|
|
|
NetworkPacket pkt(TOCLIENT_DETACHED_INVENTORY, 0, peer_id);
|
|
|
|
pkt.putRawString(s.c_str(), s.size());
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
|
|
|
|
if (peer_id != PEER_ID_INEXISTENT) {
|
2015-03-13 17:01:49 -04:00
|
|
|
Send(&pkt);
|
2014-01-30 18:24:00 -05:00
|
|
|
}
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 05:37:49 -05:00
|
|
|
else {
|
2015-03-13 17:01:49 -04:00
|
|
|
m_clients.sendToAll(0, &pkt, true);
|
2012-07-24 13:57:17 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Server::sendDetachedInventories(u16 peer_id)
|
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2012-07-24 13:57:17 -04:00
|
|
|
|
|
|
|
for(std::map<std::string, Inventory*>::iterator
|
|
|
|
i = m_detached_inventories.begin();
|
2015-08-25 16:23:05 -04:00
|
|
|
i != m_detached_inventories.end(); ++i) {
|
2012-07-24 13:57:17 -04:00
|
|
|
const std::string &name = i->first;
|
|
|
|
//Inventory *inv = i->second;
|
|
|
|
sendDetachedInventory(name, peer_id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-04-21 12:35:17 -04:00
|
|
|
/*
|
|
|
|
Something random
|
|
|
|
*/
|
|
|
|
|
2012-03-18 22:04:16 -04:00
|
|
|
void Server::DiePlayer(u16 peer_id)
|
2011-10-15 07:46:59 -04:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2012-03-18 22:04:16 -04:00
|
|
|
PlayerSAO *playersao = getPlayerSAO(peer_id);
|
2016-05-08 05:02:11 -04:00
|
|
|
// 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;
|
2011-12-01 16:33:48 -05:00
|
|
|
|
2015-03-02 11:31:31 -05:00
|
|
|
infostream << "Server::DiePlayer(): Player "
|
|
|
|
<< playersao->getPlayer()->getName()
|
|
|
|
<< " dies" << std::endl;
|
2012-03-18 22:04:16 -04:00
|
|
|
|
|
|
|
playersao->setHP(0);
|
|
|
|
|
2012-01-05 17:12:33 -05:00
|
|
|
// Trigger scripted stuff
|
2013-05-24 18:51:02 -04:00
|
|
|
m_script->on_dieplayer(playersao);
|
2011-12-02 10:19:42 -05:00
|
|
|
|
2012-03-18 22:04:16 -04:00
|
|
|
SendPlayerHP(peer_id);
|
2014-01-30 18:24:00 -05:00
|
|
|
SendDeathscreen(peer_id, false, v3f(0,0,0));
|
2011-10-15 07:46:59 -04:00
|
|
|
}
|
|
|
|
|
2012-03-18 22:04:16 -04:00
|
|
|
void Server::RespawnPlayer(u16 peer_id)
|
2011-10-15 07:46:59 -04:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2012-03-18 22:04:16 -04:00
|
|
|
|
|
|
|
PlayerSAO *playersao = getPlayerSAO(peer_id);
|
|
|
|
assert(playersao);
|
|
|
|
|
2015-03-02 11:31:31 -05:00
|
|
|
infostream << "Server::RespawnPlayer(): Player "
|
|
|
|
<< playersao->getPlayer()->getName()
|
|
|
|
<< " respawns" << std::endl;
|
2012-03-18 22:04:16 -04:00
|
|
|
|
|
|
|
playersao->setHP(PLAYER_MAX_HP);
|
2015-02-04 03:00:34 -05:00
|
|
|
playersao->setBreath(PLAYER_MAX_BREATH);
|
2012-03-18 22:04:16 -04:00
|
|
|
|
2015-03-02 11:31:31 -05:00
|
|
|
SendPlayerHP(peer_id);
|
2015-03-03 10:23:47 -05:00
|
|
|
SendPlayerBreath(peer_id);
|
2015-03-02 11:31:31 -05:00
|
|
|
|
2013-05-24 18:51:02 -04:00
|
|
|
bool repositioned = m_script->on_respawnplayer(playersao);
|
2011-11-25 20:20:19 -05:00
|
|
|
if(!repositioned){
|
2015-04-03 03:04:02 -04:00
|
|
|
v3f pos = findSpawnPos();
|
2015-03-04 06:19:26 -05:00
|
|
|
// setPos will send the new position to client
|
2012-03-18 22:04:16 -04:00
|
|
|
playersao->setPos(pos);
|
2011-11-25 20:20:19 -05:00
|
|
|
}
|
2011-10-15 07:46:59 -04:00
|
|
|
}
|
2015-07-17 10:40:41 -04:00
|
|
|
|
|
|
|
|
2015-04-11 22:49:13 -04:00
|
|
|
void Server::DenySudoAccess(u16 peer_id)
|
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2015-04-11 22:49:13 -04:00
|
|
|
|
|
|
|
NetworkPacket pkt(TOCLIENT_DENY_SUDO_MODE, 0, peer_id);
|
|
|
|
Send(&pkt);
|
|
|
|
}
|
2011-10-15 07:46:59 -04:00
|
|
|
|
2015-07-17 10:40:41 -04:00
|
|
|
|
|
|
|
void Server::DenyAccessVerCompliant(u16 peer_id, u16 proto_ver, AccessDeniedCode reason,
|
|
|
|
const std::string &str_reason, bool reconnect)
|
|
|
|
{
|
|
|
|
if (proto_ver >= 25) {
|
2016-03-11 12:41:56 -05:00
|
|
|
SendAccessDenied(peer_id, reason, str_reason, reconnect);
|
2015-07-17 10:40:41 -04:00
|
|
|
} else {
|
|
|
|
std::wstring wreason = utf8_to_wide(
|
|
|
|
reason == SERVER_ACCESSDENIED_CUSTOM_STRING ? str_reason :
|
|
|
|
accessDeniedStrings[(u8)reason]);
|
|
|
|
SendAccessDenied_Legacy(peer_id, wreason);
|
|
|
|
}
|
|
|
|
|
|
|
|
m_clients.event(peer_id, CSE_SetDenied);
|
|
|
|
m_con.DisconnectPeer(peer_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-04-22 08:10:39 -04:00
|
|
|
void Server::DenyAccess(u16 peer_id, AccessDeniedCode reason, const std::string &custom_reason)
|
2015-03-13 11:35:21 -04:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2015-03-13 11:35:21 -04:00
|
|
|
|
|
|
|
SendAccessDenied(peer_id, reason, custom_reason);
|
|
|
|
m_clients.event(peer_id, CSE_SetDenied);
|
|
|
|
m_con.DisconnectPeer(peer_id);
|
|
|
|
}
|
|
|
|
|
|
|
|
// 13/03/15: remove this function when protocol version 25 will become
|
|
|
|
// the minimum version for MT users, maybe in 1 year
|
|
|
|
void Server::DenyAccess_Legacy(u16 peer_id, const std::wstring &reason)
|
2013-08-04 01:17:07 -04:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2013-08-04 01:17:07 -04:00
|
|
|
|
2015-03-13 11:35:21 -04:00
|
|
|
SendAccessDenied_Legacy(peer_id, reason);
|
2014-06-28 02:02:38 -04:00
|
|
|
m_clients.event(peer_id, CSE_SetDenied);
|
2014-01-30 18:24:00 -05:00
|
|
|
m_con.DisconnectPeer(peer_id);
|
2013-08-04 01:17:07 -04:00
|
|
|
}
|
|
|
|
|
2015-04-11 22:49:13 -04:00
|
|
|
void Server::acceptAuth(u16 peer_id, bool forSudoMode)
|
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2015-04-11 22:49:13 -04:00
|
|
|
|
|
|
|
if (!forSudoMode) {
|
|
|
|
RemoteClient* client = getClient(peer_id, CS_Invalid);
|
|
|
|
|
|
|
|
NetworkPacket resp_pkt(TOCLIENT_AUTH_ACCEPT, 1 + 6 + 8 + 4, peer_id);
|
|
|
|
|
|
|
|
// Right now, the auth mechs don't change between login and sudo mode.
|
|
|
|
u32 sudo_auth_mechs = client->allowed_auth_mechs;
|
|
|
|
client->allowed_sudo_mechs = sudo_auth_mechs;
|
|
|
|
|
|
|
|
resp_pkt << v3f(0,0,0) << (u64) m_env->getServerMap().getSeed()
|
|
|
|
<< g_settings->getFloat("dedicated_server_step")
|
|
|
|
<< sudo_auth_mechs;
|
|
|
|
|
|
|
|
Send(&resp_pkt);
|
|
|
|
m_clients.event(peer_id, CSE_AuthAccept);
|
|
|
|
} else {
|
|
|
|
NetworkPacket resp_pkt(TOCLIENT_ACCEPT_SUDO_MODE, 1 + 6 + 8 + 4, peer_id);
|
|
|
|
|
|
|
|
// We only support SRP right now
|
|
|
|
u32 sudo_auth_mechs = AUTH_MECHANISM_FIRST_SRP;
|
|
|
|
|
|
|
|
resp_pkt << sudo_auth_mechs;
|
|
|
|
Send(&resp_pkt);
|
|
|
|
m_clients.event(peer_id, CSE_SudoSuccess);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-08-04 01:17:07 -04:00
|
|
|
void Server::DeleteClient(u16 peer_id, ClientDeletionReason reason)
|
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2014-01-30 18:24:00 -05:00
|
|
|
std::wstring message;
|
2013-08-04 01:17:07 -04:00
|
|
|
{
|
2014-01-30 18:24:00 -05:00
|
|
|
/*
|
|
|
|
Clear references to playing sounds
|
|
|
|
*/
|
|
|
|
for(std::map<s32, ServerPlayingSound>::iterator
|
|
|
|
i = m_playing_sounds.begin();
|
|
|
|
i != m_playing_sounds.end();)
|
|
|
|
{
|
|
|
|
ServerPlayingSound &psound = i->second;
|
|
|
|
psound.clients.erase(peer_id);
|
2014-12-12 09:55:40 -05:00
|
|
|
if(psound.clients.empty())
|
2014-01-30 18:24:00 -05:00
|
|
|
m_playing_sounds.erase(i++);
|
|
|
|
else
|
2015-08-25 16:23:05 -04:00
|
|
|
++i;
|
2014-01-30 18:24:00 -05:00
|
|
|
}
|
2013-08-04 01:17:07 -04:00
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
Player *player = m_env->getPlayer(peer_id);
|
2013-08-04 01:17:07 -04:00
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
/* Run scripts and remove from environment */
|
2013-08-04 01:17:07 -04:00
|
|
|
{
|
2014-01-30 18:24:00 -05:00
|
|
|
if(player != NULL)
|
|
|
|
{
|
|
|
|
PlayerSAO *playersao = player->getPlayerSAO();
|
|
|
|
assert(playersao);
|
2013-08-04 01:17:07 -04:00
|
|
|
|
2016-01-04 20:49:11 -05:00
|
|
|
m_script->on_leaveplayer(playersao, reason == CDR_TIMEOUT);
|
2013-08-04 01:17:07 -04:00
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
playersao->disconnected();
|
|
|
|
}
|
2013-08-04 01:17:07 -04:00
|
|
|
}
|
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
/*
|
|
|
|
Print out action
|
|
|
|
*/
|
2013-08-04 01:17:07 -04:00
|
|
|
{
|
2015-03-04 10:30:24 -05:00
|
|
|
if(player != NULL && reason != CDR_DENY) {
|
2014-01-30 18:24:00 -05:00
|
|
|
std::ostringstream os(std::ios_base::binary);
|
2015-03-04 10:30:24 -05:00
|
|
|
std::vector<u16> clients = m_clients.getClientIDs();
|
2014-01-30 18:24:00 -05:00
|
|
|
|
2015-03-04 10:30:24 -05:00
|
|
|
for(std::vector<u16>::iterator i = clients.begin();
|
|
|
|
i != clients.end(); ++i) {
|
2014-01-30 18:24:00 -05:00
|
|
|
// Get player
|
|
|
|
Player *player = m_env->getPlayer(*i);
|
|
|
|
if(!player)
|
|
|
|
continue;
|
2015-03-04 10:30:24 -05:00
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
// Get name of player
|
2015-03-04 10:30:24 -05:00
|
|
|
os << player->getName() << " ";
|
2014-01-30 18:24:00 -05:00
|
|
|
}
|
2013-08-04 01:17:07 -04:00
|
|
|
|
2015-07-25 01:43:32 -04:00
|
|
|
std::string name = player->getName();
|
|
|
|
actionstream << name << " "
|
2015-03-04 10:30:24 -05:00
|
|
|
<< (reason == CDR_TIMEOUT ? "times out." : "leaves game.")
|
|
|
|
<< " List of players: " << os.str() << std::endl;
|
2015-07-25 01:43:32 -04:00
|
|
|
if (m_admin_chat)
|
|
|
|
m_admin_chat->outgoing_queue.push_back(
|
|
|
|
new ChatEventNick(CET_NICK_REMOVE, name));
|
2014-01-30 18:24:00 -05:00
|
|
|
}
|
2013-08-04 01:17:07 -04:00
|
|
|
}
|
2014-02-12 13:47:27 -05:00
|
|
|
{
|
2015-04-07 06:13:12 -04:00
|
|
|
MutexAutoLock env_lock(m_env_mutex);
|
2014-02-12 13:47:27 -05:00
|
|
|
m_clients.DeleteClient(peer_id);
|
|
|
|
}
|
2013-08-04 01:17:07 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
// Send leave chat message to all remaining clients
|
|
|
|
if(message.length() != 0)
|
2014-01-30 18:24:00 -05:00
|
|
|
SendChatMessage(PEER_ID_INEXISTENT,message);
|
2013-08-04 01:17:07 -04:00
|
|
|
}
|
|
|
|
|
2015-03-04 05:29:34 -05:00
|
|
|
void Server::UpdateCrafting(Player* player)
|
2011-04-21 12:35:17 -04:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2012-01-21 15:21:41 -05:00
|
|
|
// Get a preview for crafting
|
|
|
|
ItemStack preview;
|
2013-10-26 05:25:28 -04:00
|
|
|
InventoryLocation loc;
|
|
|
|
loc.setPlayer(player->getName());
|
2015-06-02 14:30:04 -04:00
|
|
|
std::vector<ItemStack> output_replacements;
|
|
|
|
getCraftingResult(&player->inventory, preview, output_replacements, false, this);
|
2013-10-26 05:25:28 -04:00
|
|
|
m_env->getScriptIface()->item_CraftPredict(preview, player->getPlayerSAO(), (&player->inventory)->getList("craft"), loc);
|
2012-01-21 15:21:41 -05:00
|
|
|
|
|
|
|
// Put the new preview in
|
|
|
|
InventoryList *plist = player->inventory.getList("craftpreview");
|
2015-03-06 05:21:51 -05:00
|
|
|
sanity_check(plist);
|
|
|
|
sanity_check(plist->getSize() >= 1);
|
2012-01-21 15:21:41 -05:00
|
|
|
plist->changeItem(0, preview);
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
|
|
|
|
2015-11-09 00:04:24 -05:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-25 01:43:32 -04:00
|
|
|
std::wstring Server::handleChat(const std::string &name, const std::wstring &wname,
|
2016-10-04 12:17:12 -04:00
|
|
|
const std::wstring &wmessage, bool check_shout_priv, RemotePlayer *player)
|
2015-07-25 01:43:32 -04:00
|
|
|
{
|
|
|
|
// 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"";
|
|
|
|
|
2016-10-05 21:32:52 -04:00
|
|
|
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")
|
|
|
|
<< " 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.");
|
2016-10-04 12:17:12 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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. "
|
|
|
|
"It was refused. Send a shorter message";
|
|
|
|
}
|
|
|
|
|
2015-07-25 01:43:32 -04:00
|
|
|
// 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 {
|
2015-11-12 19:35:54 -05:00
|
|
|
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;
|
|
|
|
}
|
2015-07-25 01:43:32 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
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();
|
|
|
|
|
2016-10-04 12:17:12 -04:00
|
|
|
u16 peer_id_to_avoid_sending = (player ? player->peer_id : PEER_ID_INEXISTENT);
|
2015-07-25 01:43:32 -04:00
|
|
|
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));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-30 18:24:00 -05:00
|
|
|
RemoteClient* Server::getClient(u16 peer_id, ClientState state_min)
|
2010-11-26 18:02:21 -05:00
|
|
|
{
|
2014-01-30 18:24:00 -05:00
|
|
|
RemoteClient *client = getClientNoEx(peer_id,state_min);
|
2013-08-04 01:17:07 -04:00
|
|
|
if(!client)
|
|
|
|
throw ClientNotFoundException("Client not found");
|
2014-01-30 18:24:00 -05:00
|
|
|
|
2013-08-04 01:17:07 -04:00
|
|
|
return client;
|
|
|
|
}
|
2014-01-30 18:24:00 -05:00
|
|
|
RemoteClient* Server::getClientNoEx(u16 peer_id, ClientState state_min)
|
2013-08-04 01:17:07 -04:00
|
|
|
{
|
2014-01-30 18:24:00 -05:00
|
|
|
return m_clients.getClientNoEx(peer_id, state_min);
|
2010-11-26 18:02:21 -05:00
|
|
|
}
|
|
|
|
|
2013-08-10 22:09:45 -04:00
|
|
|
std::string Server::getPlayerName(u16 peer_id)
|
|
|
|
{
|
|
|
|
Player *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)
|
|
|
|
return NULL;
|
|
|
|
return player->getPlayerSAO();
|
|
|
|
}
|
|
|
|
|
2011-02-15 09:11:24 -05:00
|
|
|
std::wstring Server::getStatusString()
|
|
|
|
{
|
|
|
|
std::wostringstream os(std::ios_base::binary);
|
|
|
|
os<<L"# Server: ";
|
2011-04-24 17:24:40 -04:00
|
|
|
// Version
|
2015-02-27 18:05:29 -05:00
|
|
|
os<<L"version="<<narrow_to_wide(g_version_string);
|
2011-02-15 09:11:24 -05:00
|
|
|
// Uptime
|
2011-04-24 17:24:40 -04:00
|
|
|
os<<L", uptime="<<m_uptime.get();
|
2013-08-03 16:16:37 -04:00
|
|
|
// Max lag estimate
|
|
|
|
os<<L", max_lag="<<m_env->getMaxLagEstimate();
|
2011-02-15 09:11:24 -05:00
|
|
|
// Information about clients
|
2014-01-30 18:24:00 -05:00
|
|
|
bool first = true;
|
2011-02-15 09:11:24 -05:00
|
|
|
os<<L", clients={";
|
2015-03-04 10:30:24 -05:00
|
|
|
std::vector<u16> clients = m_clients.getClientIDs();
|
|
|
|
for(std::vector<u16>::iterator i = clients.begin();
|
|
|
|
i != clients.end(); ++i) {
|
2011-02-15 09:11:24 -05:00
|
|
|
// Get player
|
2014-01-30 18:24:00 -05:00
|
|
|
Player *player = m_env->getPlayer(*i);
|
2011-02-15 09:11:24 -05:00
|
|
|
// Get name of player
|
|
|
|
std::wstring name = L"unknown";
|
|
|
|
if(player != NULL)
|
|
|
|
name = narrow_to_wide(player->getName());
|
|
|
|
// Add name to information string
|
2012-07-28 15:49:23 -04:00
|
|
|
if(!first)
|
2015-03-04 10:30:24 -05:00
|
|
|
os << L", ";
|
2012-07-28 15:49:23 -04:00
|
|
|
else
|
|
|
|
first = false;
|
2015-03-04 10:30:24 -05:00
|
|
|
os << name;
|
2011-02-15 09:11:24 -05:00
|
|
|
}
|
2015-03-04 10:30:24 -05:00
|
|
|
os << L"}";
|
2011-11-11 12:33:17 -05:00
|
|
|
if(((ServerMap*)(&m_env->getMap()))->isSavingEnabled() == false)
|
2011-07-30 12:49:42 -04:00
|
|
|
os<<std::endl<<L"# Server: "<<" WARNING: Map saving is disabled.";
|
2011-10-12 06:53:38 -04:00
|
|
|
if(g_settings->get("motd") != "")
|
|
|
|
os<<std::endl<<L"# Server: "<<narrow_to_wide(g_settings->get("motd"));
|
2011-02-15 09:11:24 -05:00
|
|
|
return os.str();
|
|
|
|
}
|
|
|
|
|
2012-03-30 11:42:18 -04:00
|
|
|
std::set<std::string> Server::getPlayerEffectivePrivs(const std::string &name)
|
2012-03-15 09:27:16 -04:00
|
|
|
{
|
2012-03-30 11:42:18 -04:00
|
|
|
std::set<std::string> privs;
|
2013-05-24 18:51:02 -04:00
|
|
|
m_script->getAuth(name, NULL, &privs);
|
2012-03-30 11:42:18 -04:00
|
|
|
return privs;
|
2012-03-15 09:27:16 -04:00
|
|
|
}
|
|
|
|
|
2012-03-30 11:42:18 -04:00
|
|
|
bool Server::checkPriv(const std::string &name, const std::string &priv)
|
2011-11-20 14:16:15 -05:00
|
|
|
{
|
2012-03-30 11:42:18 -04:00
|
|
|
std::set<std::string> privs = getPlayerEffectivePrivs(name);
|
|
|
|
return (privs.count(priv) != 0);
|
2011-11-20 14:16:15 -05:00
|
|
|
}
|
|
|
|
|
2012-03-31 09:23:26 -04:00
|
|
|
void Server::reportPrivsModified(const std::string &name)
|
|
|
|
{
|
2015-03-04 10:30:24 -05:00
|
|
|
if(name == "") {
|
|
|
|
std::vector<u16> clients = m_clients.getClientIDs();
|
|
|
|
for(std::vector<u16>::iterator i = clients.begin();
|
|
|
|
i != clients.end(); ++i) {
|
2014-01-30 18:24:00 -05:00
|
|
|
Player *player = m_env->getPlayer(*i);
|
2012-03-31 10:08:39 -04:00
|
|
|
reportPrivsModified(player->getName());
|
2012-03-31 09:23:26 -04:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
Player *player = m_env->getPlayer(name.c_str());
|
|
|
|
if(!player)
|
|
|
|
return;
|
|
|
|
SendPlayerPrivileges(player->peer_id);
|
2012-04-07 11:46:10 -04:00
|
|
|
PlayerSAO *sao = player->getPlayerSAO();
|
|
|
|
if(!sao)
|
|
|
|
return;
|
|
|
|
sao->updatePrivileges(
|
2012-04-01 06:19:50 -04:00
|
|
|
getPlayerEffectivePrivs(name),
|
|
|
|
isSingleplayer());
|
2012-03-31 09:23:26 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-19 07:09:16 -04:00
|
|
|
void Server::reportInventoryFormspecModified(const std::string &name)
|
|
|
|
{
|
|
|
|
Player *player = m_env->getPlayer(name.c_str());
|
|
|
|
if(!player)
|
|
|
|
return;
|
|
|
|
SendPlayerInventoryFormspec(player->peer_id);
|
|
|
|
}
|
|
|
|
|
2013-08-10 22:09:45 -04:00
|
|
|
void Server::setIpBanned(const std::string &ip, const std::string &name)
|
2011-10-12 06:53:38 -04:00
|
|
|
{
|
2013-08-10 22:09:45 -04:00
|
|
|
m_banmanager->add(ip, name);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Server::unsetIpBanned(const std::string &ip_or_name)
|
|
|
|
{
|
|
|
|
m_banmanager->remove(ip_or_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string Server::getBanDescription(const std::string &ip_or_name)
|
|
|
|
{
|
|
|
|
return m_banmanager->getBanDescription(ip_or_name);
|
2011-10-12 06:53:38 -04:00
|
|
|
}
|
|
|
|
|
2014-02-27 15:12:59 -05:00
|
|
|
void Server::notifyPlayer(const char *name, const std::wstring &msg)
|
2011-10-16 13:03:43 -04:00
|
|
|
{
|
2015-08-09 16:10:37 -04:00
|
|
|
// m_env will be NULL if the server is initializing
|
|
|
|
if (!m_env)
|
|
|
|
return;
|
|
|
|
|
2015-07-25 01:43:32 -04:00
|
|
|
if (m_admin_nick == name && !m_admin_nick.empty()) {
|
|
|
|
m_admin_chat->outgoing_queue.push_back(new ChatEventChat("", msg));
|
|
|
|
}
|
|
|
|
|
2011-11-11 12:33:17 -05:00
|
|
|
Player *player = m_env->getPlayer(name);
|
2015-07-25 01:43:32 -04:00
|
|
|
if (!player) {
|
2011-10-16 13:03:43 -04:00
|
|
|
return;
|
2015-07-25 01:43:32 -04:00
|
|
|
}
|
2014-02-01 19:55:24 -05:00
|
|
|
|
|
|
|
if (player->peer_id == PEER_ID_INEXISTENT)
|
|
|
|
return;
|
|
|
|
|
2014-02-24 20:41:40 -05:00
|
|
|
SendChatMessage(player->peer_id, msg);
|
2011-10-16 13:03:43 -04:00
|
|
|
}
|
|
|
|
|
2015-07-02 23:14:30 -04:00
|
|
|
bool Server::showFormspec(const char *playername, const std::string &formspec,
|
|
|
|
const std::string &formname)
|
2013-01-02 14:45:04 -05:00
|
|
|
{
|
2015-08-09 16:10:37 -04:00
|
|
|
// m_env will be NULL if the server is initializing
|
|
|
|
if (!m_env)
|
|
|
|
return false;
|
|
|
|
|
2013-01-02 14:45:04 -05:00
|
|
|
Player *player = m_env->getPlayer(playername);
|
2015-07-02 23:14:30 -04:00
|
|
|
if (!player)
|
2013-01-02 14:45:04 -05:00
|
|
|
return false;
|
|
|
|
|
2013-01-03 12:59:28 -05:00
|
|
|
SendShowFormspecMessage(player->peer_id, formspec, formname);
|
2013-01-02 14:45:04 -05:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-07-02 23:14:30 -04:00
|
|
|
u32 Server::hudAdd(Player *player, HudElement *form)
|
|
|
|
{
|
2013-04-13 18:20:22 -04:00
|
|
|
if (!player)
|
|
|
|
return -1;
|
2014-12-17 03:20:17 -05:00
|
|
|
|
2014-05-25 08:34:32 -04:00
|
|
|
u32 id = player->addHud(form);
|
|
|
|
|
2013-04-11 14:23:38 -04:00
|
|
|
SendHUDAdd(player->peer_id, id, form);
|
2014-05-25 08:34:32 -04:00
|
|
|
|
2013-04-13 18:20:22 -04:00
|
|
|
return id;
|
2013-04-11 14:23:38 -04:00
|
|
|
}
|
|
|
|
|
2013-04-13 18:20:22 -04:00
|
|
|
bool Server::hudRemove(Player *player, u32 id) {
|
2014-05-25 08:34:32 -04:00
|
|
|
if (!player)
|
2013-04-11 14:23:38 -04:00
|
|
|
return false;
|
|
|
|
|
2014-05-25 08:34:32 -04:00
|
|
|
HudElement* todel = player->removeHud(id);
|
|
|
|
|
|
|
|
if (!todel)
|
|
|
|
return false;
|
2014-12-17 03:20:17 -05:00
|
|
|
|
2014-05-25 08:34:32 -04:00
|
|
|
delete todel;
|
|
|
|
|
2013-04-13 18:20:22 -04:00
|
|
|
SendHUDRemove(player->peer_id, id);
|
2013-04-11 14:23:38 -04:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-07-02 23:14:30 -04:00
|
|
|
bool Server::hudChange(Player *player, u32 id, HudElementStat stat, void *data)
|
|
|
|
{
|
2013-04-13 18:20:22 -04:00
|
|
|
if (!player)
|
2013-04-11 14:23:38 -04:00
|
|
|
return false;
|
|
|
|
|
|
|
|
SendHUDChange(player->peer_id, id, stat, data);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-07-02 23:14:30 -04:00
|
|
|
bool Server::hudSetFlags(Player *player, u32 flags, u32 mask)
|
|
|
|
{
|
2013-04-24 06:52:46 -04:00
|
|
|
if (!player)
|
|
|
|
return false;
|
|
|
|
|
2013-04-25 19:27:22 -04:00
|
|
|
SendHUDSetFlags(player->peer_id, flags, mask);
|
2015-11-22 10:15:47 -05:00
|
|
|
player->hud_flags &= ~mask;
|
|
|
|
player->hud_flags |= flags;
|
2014-12-17 03:20:17 -05:00
|
|
|
|
2014-08-21 11:27:52 -04:00
|
|
|
PlayerSAO* playersao = player->getPlayerSAO();
|
2014-12-17 03:20:17 -05:00
|
|
|
|
2014-08-21 11:27:52 -04:00
|
|
|
if (playersao == NULL)
|
|
|
|
return false;
|
2014-04-28 17:41:27 -04:00
|
|
|
|
2014-08-21 11:27:52 -04:00
|
|
|
m_script->player_event(playersao, "hud_changed");
|
2013-04-24 06:52:46 -04:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-07-02 23:14:30 -04:00
|
|
|
bool Server::hudSetHotbarItemcount(Player *player, s32 hotbar_itemcount)
|
|
|
|
{
|
2013-05-03 20:08:52 -04:00
|
|
|
if (!player)
|
|
|
|
return false;
|
|
|
|
if (hotbar_itemcount <= 0 || hotbar_itemcount > HUD_HOTBAR_ITEMCOUNT_MAX)
|
|
|
|
return false;
|
|
|
|
|
2015-05-26 08:10:08 -04:00
|
|
|
player->setHotbarItemcount(hotbar_itemcount);
|
2013-05-03 20:08:52 -04:00
|
|
|
std::ostringstream os(std::ios::binary);
|
|
|
|
writeS32(os, hotbar_itemcount);
|
|
|
|
SendHUDSetParam(player->peer_id, HUD_PARAM_HOTBAR_ITEMCOUNT, os.str());
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-07-02 23:14:30 -04:00
|
|
|
s32 Server::hudGetHotbarItemcount(Player *player)
|
|
|
|
{
|
2015-05-26 08:10:08 -04:00
|
|
|
if (!player)
|
|
|
|
return 0;
|
|
|
|
return player->getHotbarItemcount();
|
|
|
|
}
|
|
|
|
|
2015-07-02 23:14:30 -04:00
|
|
|
void Server::hudSetHotbarImage(Player *player, std::string name)
|
|
|
|
{
|
2013-09-03 13:51:40 -04:00
|
|
|
if (!player)
|
|
|
|
return;
|
|
|
|
|
2015-05-26 08:10:08 -04:00
|
|
|
player->setHotbarImage(name);
|
2013-09-03 13:51:40 -04:00
|
|
|
SendHUDSetParam(player->peer_id, HUD_PARAM_HOTBAR_IMAGE, name);
|
|
|
|
}
|
|
|
|
|
2015-07-02 23:14:30 -04:00
|
|
|
std::string Server::hudGetHotbarImage(Player *player)
|
|
|
|
{
|
2015-05-26 08:10:08 -04:00
|
|
|
if (!player)
|
|
|
|
return "";
|
|
|
|
return player->getHotbarImage();
|
|
|
|
}
|
|
|
|
|
2015-07-02 23:14:30 -04:00
|
|
|
void Server::hudSetHotbarSelectedImage(Player *player, std::string name)
|
|
|
|
{
|
2013-09-03 13:51:40 -04:00
|
|
|
if (!player)
|
|
|
|
return;
|
|
|
|
|
2015-05-26 08:10:08 -04:00
|
|
|
player->setHotbarSelectedImage(name);
|
2013-09-03 13:51:40 -04:00
|
|
|
SendHUDSetParam(player->peer_id, HUD_PARAM_HOTBAR_SELECTED_IMAGE, name);
|
|
|
|
}
|
|
|
|
|
2015-07-02 23:14:30 -04:00
|
|
|
std::string Server::hudGetHotbarSelectedImage(Player *player)
|
|
|
|
{
|
2015-05-26 08:10:08 -04:00
|
|
|
if (!player)
|
|
|
|
return "";
|
|
|
|
|
|
|
|
return player->getHotbarSelectedImage();
|
|
|
|
}
|
|
|
|
|
2015-07-02 23:14:30 -04:00
|
|
|
bool Server::setLocalPlayerAnimations(Player *player,
|
|
|
|
v2s32 animation_frames[4], f32 frame_speed)
|
2014-01-08 07:47:53 -05:00
|
|
|
{
|
|
|
|
if (!player)
|
|
|
|
return false;
|
|
|
|
|
2015-05-26 08:10:08 -04:00
|
|
|
player->setLocalAnimations(animation_frames, frame_speed);
|
2014-01-08 07:47:53 -05:00
|
|
|
SendLocalPlayerAnimations(player->peer_id, animation_frames, frame_speed);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-04-11 09:32:46 -04:00
|
|
|
bool Server::setPlayerEyeOffset(Player *player, v3f first, v3f third)
|
|
|
|
{
|
|
|
|
if (!player)
|
|
|
|
return false;
|
|
|
|
|
2015-05-26 08:10:08 -04:00
|
|
|
player->eye_offset_first = first;
|
|
|
|
player->eye_offset_third = third;
|
2014-04-11 09:32:46 -04:00
|
|
|
SendEyeOffset(player->peer_id, first, third);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-05-02 16:52:50 -04:00
|
|
|
bool Server::setSky(Player *player, const video::SColor &bgcolor,
|
2015-07-02 23:14:30 -04:00
|
|
|
const std::string &type, const std::vector<std::string> ¶ms)
|
2013-05-02 16:52:50 -04:00
|
|
|
{
|
|
|
|
if (!player)
|
|
|
|
return false;
|
|
|
|
|
2015-05-26 08:10:08 -04:00
|
|
|
player->setSky(bgcolor, type, params);
|
2013-05-02 16:52:50 -04:00
|
|
|
SendSetSky(player->peer_id, bgcolor, type, params);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-10-18 04:53:19 -04:00
|
|
|
bool Server::overrideDayNightRatio(Player *player, bool do_override,
|
2015-07-02 23:14:30 -04:00
|
|
|
float ratio)
|
2013-10-18 04:53:19 -04:00
|
|
|
{
|
|
|
|
if (!player)
|
|
|
|
return false;
|
|
|
|
|
2015-05-26 08:10:08 -04:00
|
|
|
player->overrideDayNightRatio(do_override, ratio);
|
2013-10-18 04:53:19 -04:00
|
|
|
SendOverrideDayNightRatio(player->peer_id, do_override, ratio);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-02-27 15:12:59 -05:00
|
|
|
void Server::notifyPlayers(const std::wstring &msg)
|
2011-10-17 17:01:50 -04:00
|
|
|
{
|
2014-01-30 18:24:00 -05:00
|
|
|
SendChatMessage(PEER_ID_INEXISTENT,msg);
|
2011-10-17 17:01:50 -04:00
|
|
|
}
|
|
|
|
|
2015-07-25 05:56:24 -04:00
|
|
|
void Server::spawnParticle(const std::string &playername, v3f pos,
|
2015-07-02 23:14:30 -04:00
|
|
|
v3f velocity, v3f acceleration,
|
|
|
|
float expirationtime, float size, bool
|
2016-05-28 00:08:23 -04:00
|
|
|
collisiondetection, bool collision_removal,
|
|
|
|
bool vertical, const std::string &texture)
|
2013-01-23 12:32:02 -05:00
|
|
|
{
|
2015-08-09 16:10:37 -04:00
|
|
|
// m_env will be NULL if the server is initializing
|
|
|
|
if (!m_env)
|
|
|
|
return;
|
|
|
|
|
2015-07-25 05:56:24 -04:00
|
|
|
u16 peer_id = PEER_ID_INEXISTENT;
|
|
|
|
if (playername != "") {
|
|
|
|
Player* player = m_env->getPlayer(playername.c_str());
|
|
|
|
if (!player)
|
|
|
|
return;
|
|
|
|
peer_id = player->peer_id;
|
|
|
|
}
|
2013-01-23 12:32:02 -05:00
|
|
|
|
2015-07-25 05:56:24 -04:00
|
|
|
SendSpawnParticle(peer_id, pos, velocity, acceleration,
|
2016-05-28 00:08:23 -04:00
|
|
|
expirationtime, size, collisiondetection,
|
|
|
|
collision_removal, vertical, texture);
|
2013-01-23 12:32:02 -05:00
|
|
|
}
|
|
|
|
|
2015-07-25 05:56:24 -04:00
|
|
|
u32 Server::addParticleSpawner(u16 amount, float spawntime,
|
2015-07-02 23:14:30 -04:00
|
|
|
v3f minpos, v3f maxpos, v3f minvel, v3f maxvel, v3f minacc, v3f maxacc,
|
|
|
|
float minexptime, float maxexptime, float minsize, float maxsize,
|
2016-05-28 00:08:23 -04:00
|
|
|
bool collisiondetection, bool collision_removal,
|
|
|
|
bool vertical, const std::string &texture,
|
2015-07-25 05:56:24 -04:00
|
|
|
const std::string &playername)
|
2013-01-23 12:32:02 -05:00
|
|
|
{
|
2015-08-09 16:10:37 -04:00
|
|
|
// m_env will be NULL if the server is initializing
|
|
|
|
if (!m_env)
|
|
|
|
return -1;
|
|
|
|
|
2015-07-25 05:56:24 -04:00
|
|
|
u16 peer_id = PEER_ID_INEXISTENT;
|
|
|
|
if (playername != "") {
|
|
|
|
Player* player = m_env->getPlayer(playername.c_str());
|
|
|
|
if (!player)
|
|
|
|
return -1;
|
|
|
|
peer_id = player->peer_id;
|
2013-01-23 12:32:02 -05:00
|
|
|
}
|
|
|
|
|
2016-04-27 11:58:09 -04:00
|
|
|
u32 id = m_env->addParticleSpawner(spawntime);
|
2015-07-25 05:56:24 -04:00
|
|
|
SendAddParticleSpawner(peer_id, amount, spawntime,
|
2013-01-23 12:32:02 -05:00
|
|
|
minpos, maxpos, minvel, maxvel, minacc, maxacc,
|
|
|
|
minexptime, maxexptime, minsize, maxsize,
|
2016-05-28 00:08:23 -04:00
|
|
|
collisiondetection, collision_removal, vertical, texture, id);
|
2013-01-23 12:32:02 -05:00
|
|
|
|
|
|
|
return id;
|
|
|
|
}
|
|
|
|
|
2015-07-25 05:56:24 -04:00
|
|
|
void Server::deleteParticleSpawner(const std::string &playername, u32 id)
|
2013-01-23 12:32:02 -05:00
|
|
|
{
|
2015-08-09 16:10:37 -04:00
|
|
|
// m_env will be NULL if the server is initializing
|
|
|
|
if (!m_env)
|
|
|
|
throw ServerError("Can't delete particle spawners during initialisation!");
|
|
|
|
|
2015-07-25 05:56:24 -04:00
|
|
|
u16 peer_id = PEER_ID_INEXISTENT;
|
|
|
|
if (playername != "") {
|
|
|
|
Player* player = m_env->getPlayer(playername.c_str());
|
|
|
|
if (!player)
|
|
|
|
return;
|
|
|
|
peer_id = player->peer_id;
|
|
|
|
}
|
2013-01-23 12:32:02 -05:00
|
|
|
|
2016-04-27 11:58:09 -04:00
|
|
|
m_env->deleteParticleSpawner(id);
|
2015-07-25 05:56:24 -04:00
|
|
|
SendDeleteParticleSpawner(peer_id, id);
|
2013-01-23 12:32:02 -05:00
|
|
|
}
|
|
|
|
|
2016-04-27 11:58:09 -04:00
|
|
|
void Server::deleteParticleSpawnerAll(u32 id)
|
|
|
|
{
|
|
|
|
m_env->deleteParticleSpawner(id);
|
|
|
|
SendDeleteParticleSpawner(PEER_ID_INEXISTENT, id);
|
|
|
|
}
|
|
|
|
|
2012-07-24 13:57:17 -04:00
|
|
|
Inventory* Server::createDetachedInventory(const std::string &name)
|
|
|
|
{
|
|
|
|
if(m_detached_inventories.count(name) > 0){
|
|
|
|
infostream<<"Server clearing detached inventory \""<<name<<"\""<<std::endl;
|
|
|
|
delete m_detached_inventories[name];
|
|
|
|
} else {
|
|
|
|
infostream<<"Server creating detached inventory \""<<name<<"\""<<std::endl;
|
|
|
|
}
|
|
|
|
Inventory *inv = new Inventory(m_itemdef);
|
2015-03-06 05:21:51 -05:00
|
|
|
sanity_check(inv);
|
2012-07-24 13:57:17 -04:00
|
|
|
m_detached_inventories[name] = inv;
|
2014-01-30 18:24:00 -05:00
|
|
|
//TODO find a better way to do this
|
|
|
|
sendDetachedInventory(name,PEER_ID_INEXISTENT);
|
2012-07-24 13:57:17 -04:00
|
|
|
return inv;
|
|
|
|
}
|
|
|
|
|
2012-07-26 15:06:45 -04:00
|
|
|
// actions: time-reversed list
|
|
|
|
// Return value: success/failure
|
|
|
|
bool Server::rollbackRevertActions(const std::list<RollbackAction> &actions,
|
|
|
|
std::list<std::string> *log)
|
|
|
|
{
|
|
|
|
infostream<<"Server::rollbackRevertActions(len="<<actions.size()<<")"<<std::endl;
|
|
|
|
ServerMap *map = (ServerMap*)(&m_env->getMap());
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2012-07-26 15:06:45 -04:00
|
|
|
// Fail if no actions to handle
|
|
|
|
if(actions.empty()){
|
|
|
|
log->push_back("Nothing to do.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
int num_tried = 0;
|
|
|
|
int num_failed = 0;
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2012-07-26 15:06:45 -04:00
|
|
|
for(std::list<RollbackAction>::const_iterator
|
|
|
|
i = actions.begin();
|
2015-08-25 16:23:05 -04:00
|
|
|
i != actions.end(); ++i)
|
2012-07-26 15:06:45 -04:00
|
|
|
{
|
|
|
|
const RollbackAction &action = *i;
|
|
|
|
num_tried++;
|
|
|
|
bool success = action.applyRevert(map, this, this);
|
|
|
|
if(!success){
|
|
|
|
num_failed++;
|
|
|
|
std::ostringstream os;
|
|
|
|
os<<"Revert of step ("<<num_tried<<") "<<action.toString()<<" failed";
|
|
|
|
infostream<<"Map::rollbackRevertActions(): "<<os.str()<<std::endl;
|
|
|
|
if(log)
|
|
|
|
log->push_back(os.str());
|
|
|
|
}else{
|
|
|
|
std::ostringstream os;
|
2012-12-17 10:46:54 -05:00
|
|
|
os<<"Successfully reverted step ("<<num_tried<<") "<<action.toString();
|
2012-07-26 15:06:45 -04:00
|
|
|
infostream<<"Map::rollbackRevertActions(): "<<os.str()<<std::endl;
|
|
|
|
if(log)
|
|
|
|
log->push_back(os.str());
|
|
|
|
}
|
|
|
|
}
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2012-07-26 15:06:45 -04:00
|
|
|
infostream<<"Map::rollbackRevertActions(): "<<num_failed<<"/"<<num_tried
|
|
|
|
<<" failed"<<std::endl;
|
|
|
|
|
|
|
|
// Call it done if less than half failed
|
|
|
|
return num_failed <= num_tried/2;
|
|
|
|
}
|
|
|
|
|
2011-11-14 14:41:30 -05:00
|
|
|
// IGameDef interface
|
|
|
|
// Under envlock
|
2015-07-02 23:14:30 -04:00
|
|
|
IItemDefManager *Server::getItemDefManager()
|
2011-11-14 14:41:30 -05:00
|
|
|
{
|
2012-01-12 00:10:39 -05:00
|
|
|
return m_itemdef;
|
2011-11-14 14:41:30 -05:00
|
|
|
}
|
2015-07-02 23:14:30 -04:00
|
|
|
|
|
|
|
INodeDefManager *Server::getNodeDefManager()
|
2011-11-14 14:41:30 -05:00
|
|
|
{
|
2011-11-16 07:08:31 -05:00
|
|
|
return m_nodedef;
|
2011-11-14 14:41:30 -05:00
|
|
|
}
|
2015-07-02 23:14:30 -04:00
|
|
|
|
|
|
|
ICraftDefManager *Server::getCraftDefManager()
|
2011-11-16 19:28:46 -05:00
|
|
|
{
|
|
|
|
return m_craftdef;
|
|
|
|
}
|
2015-07-02 23:14:30 -04:00
|
|
|
ITextureSource *Server::getTextureSource()
|
2011-11-14 14:41:30 -05:00
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
2015-07-02 23:14:30 -04:00
|
|
|
IShaderSource *Server::getShaderSource()
|
2012-03-18 21:59:12 -04:00
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
2015-07-02 23:14:30 -04:00
|
|
|
scene::ISceneManager *Server::getSceneManager()
|
2014-10-20 23:12:15 -04:00
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-11-16 06:03:28 -05:00
|
|
|
u16 Server::allocateUnknownNodeId(const std::string &name)
|
|
|
|
{
|
2011-11-16 07:08:31 -05:00
|
|
|
return m_nodedef->allocateDummy(name);
|
2011-11-16 06:03:28 -05:00
|
|
|
}
|
2015-07-02 23:14:30 -04:00
|
|
|
|
|
|
|
ISoundManager *Server::getSoundManager()
|
2012-03-23 06:05:17 -04:00
|
|
|
{
|
|
|
|
return &dummySoundManager;
|
|
|
|
}
|
2015-07-02 23:14:30 -04:00
|
|
|
|
|
|
|
MtEventManager *Server::getEventManager()
|
2012-03-23 14:23:03 -04:00
|
|
|
{
|
|
|
|
return m_event;
|
|
|
|
}
|
2011-11-14 14:41:30 -05:00
|
|
|
|
2015-07-02 23:14:30 -04:00
|
|
|
IWritableItemDefManager *Server::getWritableItemDefManager()
|
2011-11-14 19:03:28 -05:00
|
|
|
{
|
2012-01-12 00:10:39 -05:00
|
|
|
return m_itemdef;
|
2011-11-14 19:03:28 -05:00
|
|
|
}
|
2015-07-02 23:14:30 -04:00
|
|
|
|
|
|
|
IWritableNodeDefManager *Server::getWritableNodeDefManager()
|
2011-11-14 19:03:28 -05:00
|
|
|
{
|
2011-11-16 07:08:31 -05:00
|
|
|
return m_nodedef;
|
2011-11-14 19:03:28 -05:00
|
|
|
}
|
2015-07-02 23:14:30 -04:00
|
|
|
|
|
|
|
IWritableCraftDefManager *Server::getWritableCraftDefManager()
|
2011-11-16 19:28:46 -05:00
|
|
|
{
|
|
|
|
return m_craftdef;
|
|
|
|
}
|
2011-11-14 19:03:28 -05:00
|
|
|
|
2015-07-02 23:14:30 -04:00
|
|
|
const ModSpec *Server::getModSpec(const std::string &modname) const
|
2011-12-11 09:49:40 -05:00
|
|
|
{
|
2015-07-02 23:14:30 -04:00
|
|
|
std::vector<ModSpec>::const_iterator it;
|
|
|
|
for (it = m_mods.begin(); it != m_mods.end(); ++it) {
|
|
|
|
const ModSpec &mod = *it;
|
|
|
|
if (mod.name == modname)
|
2011-12-11 09:49:40 -05:00
|
|
|
return &mod;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
2015-07-02 23:14:30 -04:00
|
|
|
|
2015-03-05 04:43:08 -05:00
|
|
|
void Server::getModNames(std::vector<std::string> &modlist)
|
2012-07-21 21:29:37 -04:00
|
|
|
{
|
2015-07-02 23:14:30 -04:00
|
|
|
std::vector<ModSpec>::iterator it;
|
|
|
|
for (it = m_mods.begin(); it != m_mods.end(); ++it)
|
|
|
|
modlist.push_back(it->name);
|
2012-07-21 21:29:37 -04:00
|
|
|
}
|
2015-07-02 23:14:30 -04:00
|
|
|
|
2012-04-01 03:08:52 -04:00
|
|
|
std::string Server::getBuiltinLuaPath()
|
|
|
|
{
|
|
|
|
return porting::path_share + DIR_DELIM + "builtin";
|
|
|
|
}
|
2011-12-11 09:49:40 -05:00
|
|
|
|
2015-04-03 03:04:02 -04:00
|
|
|
v3f Server::findSpawnPos()
|
2011-04-21 12:35:17 -04:00
|
|
|
{
|
2015-04-03 03:04:02 -04:00
|
|
|
ServerMap &map = m_env->getServerMap();
|
|
|
|
v3f nodeposf;
|
|
|
|
if (g_settings->getV3FNoEx("static_spawnpoint", nodeposf)) {
|
|
|
|
return nodeposf * BS;
|
|
|
|
}
|
2011-06-24 21:25:14 -04:00
|
|
|
|
2015-04-03 03:04:02 -04:00
|
|
|
bool is_good = false;
|
|
|
|
|
2011-04-21 12:35:17 -04:00
|
|
|
// Try to find a good place a few times
|
2016-02-03 20:03:31 -05:00
|
|
|
for(s32 i = 0; i < 4000 && !is_good; i++) {
|
2011-04-21 12:35:17 -04:00
|
|
|
s32 range = 1 + i;
|
|
|
|
// We're going to try to throw the player to this position
|
2013-04-21 15:39:34 -04:00
|
|
|
v2s16 nodepos2d = v2s16(
|
|
|
|
-range + (myrand() % (range * 2)),
|
|
|
|
-range + (myrand() % (range * 2)));
|
|
|
|
|
2016-02-03 20:03:31 -05:00
|
|
|
// 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)
|
2011-04-21 12:35:17 -04:00
|
|
|
continue;
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2016-02-03 20:03:31 -05:00
|
|
|
v3s16 nodepos(nodepos2d.X, spawn_level, nodepos2d.Y);
|
2015-04-03 03:04:02 -04:00
|
|
|
|
2011-11-12 20:17:42 -05:00
|
|
|
s32 air_count = 0;
|
2013-04-21 15:39:34 -04:00
|
|
|
for (s32 i = 0; i < 10; i++) {
|
2011-11-12 20:17:42 -05:00
|
|
|
v3s16 blockpos = getNodeBlockPos(nodepos);
|
|
|
|
map.emergeBlock(blockpos, true);
|
2013-04-21 15:39:34 -04:00
|
|
|
content_t c = map.getNodeNoEx(nodepos).getContent();
|
|
|
|
if (c == CONTENT_AIR || c == CONTENT_IGNORE) {
|
2011-11-12 20:17:42 -05:00
|
|
|
air_count++;
|
2015-09-29 11:26:07 -04:00
|
|
|
if (air_count >= 2) {
|
|
|
|
nodeposf = intToFloat(nodepos, BS);
|
|
|
|
// Don't spawn the player outside map boundaries
|
|
|
|
if (objectpos_over_limit(nodeposf))
|
|
|
|
continue;
|
2011-11-12 20:17:42 -05:00
|
|
|
is_good = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
nodepos.Y++;
|
|
|
|
}
|
2011-04-21 12:35:17 -04:00
|
|
|
}
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2015-09-29 11:26:07 -04:00
|
|
|
return nodeposf;
|
2011-04-21 12:35:17 -04:00
|
|
|
}
|
|
|
|
|
2015-07-17 10:40:41 -04:00
|
|
|
PlayerSAO* Server::emergePlayer(const char *name, u16 peer_id, u16 proto_version)
|
2011-01-14 20:28:19 -05:00
|
|
|
{
|
2012-03-18 22:04:16 -04:00
|
|
|
bool newplayer = false;
|
|
|
|
|
2011-01-14 20:28:19 -05:00
|
|
|
/*
|
|
|
|
Try to get an existing player
|
|
|
|
*/
|
2015-01-26 06:21:18 -05:00
|
|
|
RemotePlayer *player = static_cast<RemotePlayer*>(m_env->getPlayer(name));
|
2012-01-23 18:00:26 -05:00
|
|
|
|
2012-03-18 22:04:16 -04:00
|
|
|
// If player is already connected, cancel
|
|
|
|
if(player != NULL && player->peer_id != 0)
|
|
|
|
{
|
|
|
|
infostream<<"emergePlayer(): Player already connected"<<std::endl;
|
|
|
|
return NULL;
|
2011-01-14 20:28:19 -05:00
|
|
|
}
|
2011-01-17 17:26:09 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
If player with the wanted peer_id already exists, cancel.
|
|
|
|
*/
|
2011-11-11 12:33:17 -05:00
|
|
|
if(m_env->getPlayer(peer_id) != NULL)
|
2011-01-17 17:26:09 -05:00
|
|
|
{
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"emergePlayer(): Player with wrong name but same"
|
2011-01-17 17:26:09 -05:00
|
|
|
" peer_id already exists"<<std::endl;
|
|
|
|
return NULL;
|
|
|
|
}
|
2012-03-18 22:04:16 -04:00
|
|
|
|
2014-05-30 16:04:07 -04:00
|
|
|
// Load player if it isn't already loaded
|
|
|
|
if (!player) {
|
|
|
|
player = static_cast<RemotePlayer*>(m_env->loadPlayer(name));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create player if it doesn't exist
|
|
|
|
if (!player) {
|
2012-03-18 22:04:16 -04:00
|
|
|
newplayer = true;
|
2014-08-03 16:19:07 -04:00
|
|
|
player = new RemotePlayer(this, name);
|
2014-09-02 12:53:20 -04:00
|
|
|
// Set player position
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Server: Finding spawn place for player \""
|
2011-11-12 08:41:29 -05:00
|
|
|
<<name<<"\""<<std::endl;
|
2015-04-03 03:04:02 -04:00
|
|
|
v3f pos = findSpawnPos();
|
2012-03-18 22:04:16 -04:00
|
|
|
player->setPosition(pos);
|
2011-01-14 20:28:19 -05:00
|
|
|
|
2014-09-02 12:53:20 -04:00
|
|
|
// Make sure the player is saved
|
|
|
|
player->setModified(true);
|
|
|
|
|
|
|
|
// Add player to environment
|
2011-11-11 12:33:17 -05:00
|
|
|
m_env->addPlayer(player);
|
2015-09-29 11:26:07 -04:00
|
|
|
} else {
|
|
|
|
// If the player exists, ensure that they respawn inside legal bounds
|
|
|
|
// This fixes an assert crash when the player can't be added
|
|
|
|
// to the environment
|
|
|
|
if (objectpos_over_limit(player->getPosition())) {
|
|
|
|
actionstream << "Respawn position for player \""
|
|
|
|
<< name << "\" outside limits, resetting" << std::endl;
|
|
|
|
v3f pos = findSpawnPos();
|
|
|
|
player->setPosition(pos);
|
|
|
|
}
|
2012-03-18 22:04:16 -04:00
|
|
|
}
|
2011-01-14 20:28:19 -05:00
|
|
|
|
2014-05-30 16:04:07 -04:00
|
|
|
// Create a new player active object
|
2012-03-31 10:08:39 -04:00
|
|
|
PlayerSAO *playersao = new PlayerSAO(m_env, player, peer_id,
|
2012-04-01 06:19:50 -04:00
|
|
|
getPlayerEffectivePrivs(player->getName()),
|
|
|
|
isSingleplayer());
|
2011-11-25 20:20:19 -05:00
|
|
|
|
2015-07-17 10:40:41 -04:00
|
|
|
player->protocol_version = proto_version;
|
|
|
|
|
2013-05-09 21:10:33 -04:00
|
|
|
/* Clean up old HUD elements from previous sessions */
|
2014-05-25 08:34:32 -04:00
|
|
|
player->clearHud();
|
2013-05-09 21:10:33 -04:00
|
|
|
|
2012-03-18 22:04:16 -04:00
|
|
|
/* Add object to environment */
|
|
|
|
m_env->addActiveObject(playersao);
|
2011-01-14 20:28:19 -05:00
|
|
|
|
2012-03-18 22:04:16 -04:00
|
|
|
/* Run scripts */
|
2014-05-30 16:04:07 -04:00
|
|
|
if (newplayer) {
|
2013-05-24 18:51:02 -04:00
|
|
|
m_script->on_newplayer(playersao);
|
2014-05-30 16:04:07 -04:00
|
|
|
}
|
2012-03-18 22:04:16 -04:00
|
|
|
|
|
|
|
return playersao;
|
2011-01-14 20:28:19 -05:00
|
|
|
}
|
|
|
|
|
2011-02-15 09:11:24 -05:00
|
|
|
void dedicated_server_loop(Server &server, bool &kill)
|
2011-01-23 10:29:15 -05:00
|
|
|
{
|
2015-10-14 02:39:30 -04:00
|
|
|
DSTACK(FUNCTION_NAME);
|
2012-11-25 21:16:48 -05:00
|
|
|
|
2012-03-10 21:15:45 -05:00
|
|
|
verbosestream<<"dedicated_server_loop()"<<std::endl;
|
2011-05-30 17:15:43 -04:00
|
|
|
|
|
|
|
IntervalLimiter m_profiler_interval;
|
2011-01-23 10:29:15 -05:00
|
|
|
|
2015-09-02 15:21:55 -04:00
|
|
|
static const float steplen = g_settings->getFloat("dedicated_server_step");
|
|
|
|
static const float profiler_print_interval =
|
|
|
|
g_settings->getFloat("profiler_print_interval");
|
|
|
|
|
|
|
|
for(;;) {
|
2011-01-23 10:29:15 -05:00
|
|
|
// This is kind of a hack but can be done like this
|
|
|
|
// because server.step() is very light
|
2011-05-30 17:15:43 -04:00
|
|
|
{
|
2011-10-12 06:53:38 -04:00
|
|
|
ScopeProfiler sp(g_profiler, "dedicated server sleep");
|
2012-03-07 14:44:53 -05:00
|
|
|
sleep_ms((int)(steplen*1000.0));
|
2011-05-30 17:15:43 -04:00
|
|
|
}
|
2012-03-07 14:44:53 -05:00
|
|
|
server.step(steplen);
|
2011-01-23 10:29:15 -05:00
|
|
|
|
2011-02-15 09:11:24 -05:00
|
|
|
if(server.getShutdownRequested() || kill)
|
|
|
|
{
|
2012-03-10 21:15:45 -05:00
|
|
|
infostream<<"Dedicated server quitting"<<std::endl;
|
2013-02-21 17:00:44 -05:00
|
|
|
#if USE_CURL
|
2015-01-21 14:32:12 -05:00
|
|
|
if(g_settings->getBool("server_announce"))
|
|
|
|
ServerList::sendAnnounce("delete", server.m_bind_addr.getPort());
|
2013-02-21 17:00:44 -05:00
|
|
|
#endif
|
2011-02-15 09:11:24 -05:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-05-30 17:15:43 -04:00
|
|
|
/*
|
|
|
|
Profiler
|
|
|
|
*/
|
2015-09-02 15:21:55 -04:00
|
|
|
if (profiler_print_interval != 0) {
|
2012-03-07 14:44:53 -05:00
|
|
|
if(m_profiler_interval.step(steplen, profiler_print_interval))
|
2011-05-30 17:15:43 -04:00
|
|
|
{
|
2011-10-16 07:57:53 -04:00
|
|
|
infostream<<"Profiler:"<<std::endl;
|
|
|
|
g_profiler->print(infostream);
|
2011-10-12 06:53:38 -04:00
|
|
|
g_profiler->clear();
|
2011-05-30 17:15:43 -04:00
|
|
|
}
|
|
|
|
}
|
2011-01-23 10:29:15 -05:00
|
|
|
}
|
|
|
|
}
|