#include <cmath>
#include <IFileSystem.h>
#include "threading/mutex_auto_lock.h"
+#include "client/renderingengine.h"
#include "util/auth.h"
#include "util/directiontables.h"
#include "util/pointedthing.h"
#include "clientmap.h"
#include "clientmedia.h"
#include "version.h"
-#include "drawscene.h"
#include "database-sqlite3.h"
#include "serialization.h"
#include "guiscalingfilter.h"
#include "script/scripting_client.h"
#include "game.h"
+#include "chatmessage.h"
extern gui::IGUIEnvironment* guienv;
*/
Client::Client(
- IrrlichtDevice *device,
const char *playername,
const std::string &password,
+ const std::string &address_name,
MapDrawControl &control,
IWritableTextureSource *tsrc,
IWritableShaderSource *shsrc,
bool ipv6,
GameUIFlags *game_ui_flags
):
- m_packetcounter_timer(0.0),
- m_connection_reinit_timer(0.1),
- m_avg_rtt_timer(0.0),
- m_playerpos_send_timer(0.0),
- m_ignore_damage_timer(0.0),
m_tsrc(tsrc),
m_shsrc(shsrc),
m_itemdef(itemdef),
m_event(event),
m_mesh_update_thread(this),
m_env(
- new ClientMap(this, control,
- device->getSceneManager()->getRootSceneNode(),
- device->getSceneManager(), 666),
- device->getSceneManager(),
- tsrc, this, device
+ new ClientMap(this, control, 666),
+ tsrc, this
),
m_particle_manager(&m_env),
m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, ipv6, this),
- m_device(device),
- m_camera(NULL),
- m_minimap_disabled_by_server(false),
+ m_address_name(address_name),
m_server_ser_ver(SER_FMT_VER_INVALID),
- m_proto_ver(0),
- m_playeritem(0),
- m_inventory_updated(false),
- m_inventory_from_server(NULL),
- m_inventory_from_server_age(0.0),
- m_animation_time(0),
- m_crack_level(-1),
- m_crack_pos(0,0,0),
- m_map_seed(0),
+ m_last_chat_message_sent(time(NULL)),
m_password(password),
m_chosen_auth_mech(AUTH_MECHANISM_NONE),
- m_auth_data(NULL),
- m_access_denied(false),
- m_access_denied_reconnect(false),
- m_itemdef_received(false),
- m_nodedef_received(false),
m_media_downloader(new ClientMediaDownloader()),
- m_time_of_day_set(false),
- m_last_time_of_day_f(-1),
- m_time_of_day_update_timer(0),
- m_recommended_send_interval(0.1),
- m_removed_sounds_check_timer(0),
m_state(LC_Created),
- m_localdb(NULL),
- m_script(NULL),
- m_mod_storage_save_timer(10.0f),
- m_game_ui_flags(game_ui_flags),
- m_shutdown(false)
+ m_game_ui_flags(game_ui_flags)
{
// Add local player
m_env.setLocalPlayer(new LocalPlayer(this, playername));
- m_minimap = new Minimap(device, this);
+ if (g_settings->getBool("enable_minimap")) {
+ m_minimap = new Minimap(this);
+ }
m_cache_save_interval = g_settings->getU16("server_map_save_interval");
m_modding_enabled = g_settings->getBool("enable_client_modding");
m_script->setEnv(&m_env);
}
-void Client::initMods()
+void Client::loadMods()
{
- m_script->loadMod(getBuiltinLuaPath() + DIR_DELIM "init.lua", BUILTIN_MOD_NAME);
+ // Load builtin
+ scanModIntoMemory(BUILTIN_MOD_NAME, getBuiltinLuaPath());
// If modding is not enabled, don't load mods, just builtin
if (!m_modding_enabled) {
return;
}
-
ClientModConfiguration modconf(getClientModsLuaPath());
- std::vector<ModSpec> mods = modconf.getMods();
+ m_mods = modconf.getMods();
std::vector<ModSpec> unsatisfied_mods = modconf.getUnsatisfiedMods();
// complain about mods with unsatisfied dependencies
if (!modconf.isConsistent()) {
// Print mods
infostream << "Client Loading mods: ";
- for (std::vector<ModSpec>::const_iterator i = mods.begin();
- i != mods.end(); ++i) {
- infostream << (*i).name << " ";
- }
-
+ for (const ModSpec &mod : m_mods)
+ infostream << mod.name << " ";
infostream << std::endl;
+
// Load and run "mod" scripts
- for (std::vector<ModSpec>::const_iterator it = mods.begin();
- it != mods.end(); ++it) {
- const ModSpec &mod = *it;
+ for (const ModSpec &mod : m_mods) {
if (!string_allowed(mod.name, MODNAME_ALLOWED_CHARS)) {
throw ModError("Error loading mod \"" + mod.name +
"\": Mod name does not follow naming conventions: "
- "Only chararacters [a-z0-9_] are allowed.");
+ "Only characters [a-z0-9_] are allowed.");
+ }
+ scanModIntoMemory(mod.name, mod.path);
+ }
+}
+
+void Client::scanModSubfolder(const std::string &mod_name, const std::string &mod_path,
+ std::string mod_subpath)
+{
+ std::string full_path = mod_path + DIR_DELIM + mod_subpath;
+ std::vector<fs::DirListNode> mod = fs::GetDirListing(full_path);
+ for (unsigned int j=0; j < mod.size(); j++){
+ std::string filename = mod[j].name;
+ if (mod[j].dir) {
+ scanModSubfolder(mod_name, mod_path, mod_subpath
+ + filename + DIR_DELIM);
+ continue;
}
- std::string script_path = mod.path + DIR_DELIM + "init.lua";
- infostream << " [" << padStringRight(mod.name, 12) << "] [\""
- << script_path << "\"]" << std::endl;
- m_script->loadMod(script_path, mod.name);
+ std::replace( mod_subpath.begin(), mod_subpath.end(), DIR_DELIM_CHAR, '/');
+ m_mod_files[mod_name + ":" + mod_subpath + filename] = full_path + filename;
}
}
+void Client::initMods()
+{
+ m_script->loadModFromMemory(BUILTIN_MOD_NAME);
+
+ // If modding is not enabled, don't load mods, just builtin
+ if (!m_modding_enabled) {
+ return;
+ }
+
+ // Load and run "mod" scripts
+ for (const ModSpec &mod : m_mods)
+ m_script->loadModFromMemory(mod.name);
+}
+
const std::string &Client::getBuiltinLuaPath()
{
static const std::string builtin_dir = porting::path_share + DIR_DELIM + "builtin";
delete m_inventory_from_server;
// Delete detached inventories
- for (UNORDERED_MAP<std::string, Inventory*>::iterator
+ for (std::unordered_map<std::string, Inventory*>::iterator
i = m_detached_inventories.begin();
i != m_detached_inventories.end(); ++i) {
delete i->second;
}
// cleanup 3d model meshes on client shutdown
- while (m_device->getSceneManager()->getMeshCache()->getMeshCount() != 0) {
- scene::IAnimatedMesh *mesh =
- m_device->getSceneManager()->getMeshCache()->getMeshByIndex(0);
+ while (RenderingEngine::get_mesh_cache()->getMeshCount() != 0) {
+ scene::IAnimatedMesh *mesh = RenderingEngine::get_mesh_cache()->getMeshByIndex(0);
- if (mesh != NULL)
- m_device->getSceneManager()->getMeshCache()->removeMesh(mesh);
+ if (mesh)
+ RenderingEngine::get_mesh_cache()->removeMesh(mesh);
}
delete m_minimap;
}
-void Client::connect(Address address,
- const std::string &address_name,
- bool is_local_server)
+void Client::connect(Address address, bool is_local_server)
{
DSTACK(FUNCTION_NAME);
- initLocalMapSaving(address, address_name, is_local_server);
+ initLocalMapSaving(address, m_address_name, is_local_server);
m_con.SetTimeoutMs(0);
m_con.Connect(address);
}
}
+ /*
+ Send pending messages on out chat queue
+ */
+ if (!m_out_chat_queue.empty() && canSendChatMessage()) {
+ sendChatMessage(m_out_chat_queue.front());
+ m_out_chat_queue.pop();
+ }
+
/*
Handle environment
*/
// Control local player (0ms)
LocalPlayer *player = m_env.getLocalPlayer();
- assert(player != NULL);
- player->applyControl(dtime);
+ assert(player);
+ player->applyControl(dtime, &m_env);
// Step environment
m_env.step(dtime);
MapBlock *block = m_env.getMap().getBlockNoCreateNoEx(r.p);
if (block) {
// Delete the old mesh
- if (block->mesh != NULL) {
- delete block->mesh;
- block->mesh = NULL;
- }
+ delete block->mesh;
+ block->mesh = nullptr;
if (r.mesh) {
minimap_mapblock = r.mesh->moveMinimapMapblock();
delete r.mesh;
}
- if (do_mapper_update)
+ if (m_minimap && do_mapper_update)
m_minimap->addBlock(r.p, minimap_mapblock);
if (r.ack_block_to_server) {
Update positions of sounds attached to objects
*/
{
- for(UNORDERED_MAP<int, u16>::iterator i = m_sounds_to_objects.begin();
+ for(std::unordered_map<int, u16>::iterator i = m_sounds_to_objects.begin();
i != m_sounds_to_objects.end(); ++i) {
int client_id = i->first;
u16 object_id = i->second;
m_removed_sounds_check_timer = 0;
// Find removed sounds and clear references to them
std::vector<s32> removed_server_ids;
- for(UNORDERED_MAP<s32, int>::iterator i = m_sounds_server_to_client.begin();
+ for (std::unordered_map<s32, int>::iterator i = m_sounds_server_to_client.begin();
i != m_sounds_server_to_client.end();) {
s32 server_id = i->first;
int client_id = i->second;
if (m_mod_storage_save_timer <= 0.0f) {
verbosestream << "Saving registered mod storages." << std::endl;
m_mod_storage_save_timer = g_settings->getFloat("server_map_save_interval");
- for (UNORDERED_MAP<std::string, ModMetadata *>::const_iterator
+ for (std::unordered_map<std::string, ModMetadata *>::const_iterator
it = m_mod_storages.begin(); it != m_mod_storages.end(); ++it) {
if (it->second->isModified()) {
it->second->save(getModStoragePath());
verbosestream<<"Client: Attempting to load image "
<<"file \""<<filename<<"\""<<std::endl;
- io::IFileSystem *irrfs = m_device->getFileSystem();
- video::IVideoDriver *vdrv = m_device->getVideoDriver();
+ io::IFileSystem *irrfs = RenderingEngine::get_filesystem();
+ video::IVideoDriver *vdrv = RenderingEngine::get_video_driver();
// Create an irrlicht memory file
io::IReadFile *rfile = irrfs->createMemoryReadFile(
Send(&pkt);
}
+bool Client::canSendChatMessage() const
+{
+ u32 now = time(NULL);
+ float time_passed = now - m_last_chat_message_sent;
+
+ float virt_chat_message_allowance = m_chat_message_allowance + time_passed *
+ (CLIENT_CHAT_MESSAGE_LIMIT_PER_10S / 8.0f);
+
+ if (virt_chat_message_allowance < 1.0f)
+ return false;
+
+ return true;
+}
+
void Client::sendChatMessage(const std::wstring &message)
{
- NetworkPacket pkt(TOSERVER_CHAT_MESSAGE, 2 + message.size() * sizeof(u16));
+ const s16 max_queue_size = g_settings->getS16("max_out_chat_queue_size");
+ if (canSendChatMessage()) {
+ u32 now = time(NULL);
+ float time_passed = now - m_last_chat_message_sent;
+ m_last_chat_message_sent = time(NULL);
- pkt << message;
+ m_chat_message_allowance += time_passed * (CLIENT_CHAT_MESSAGE_LIMIT_PER_10S / 8.0f);
+ if (m_chat_message_allowance > CLIENT_CHAT_MESSAGE_LIMIT_PER_10S)
+ m_chat_message_allowance = CLIENT_CHAT_MESSAGE_LIMIT_PER_10S;
- Send(&pkt);
+ m_chat_message_allowance -= 1.0f;
+
+ NetworkPacket pkt(TOSERVER_CHAT_MESSAGE, 2 + message.size() * sizeof(u16));
+
+ pkt << message;
+
+ Send(&pkt);
+ } else if (m_out_chat_queue.size() < (u16) max_queue_size || max_queue_size == -1) {
+ m_out_chat_queue.push(message);
+ } else {
+ infostream << "Could not queue chat message because maximum out chat queue size ("
+ << max_queue_size << ") is reached." << std::endl;
+ }
+}
+
+void Client::clearOutChatQueue()
+{
+ m_out_chat_queue = std::queue<std::wstring>();
}
void Client::sendChangePassword(const std::string &oldpassword,
}
}
+/**
+ * Helper function for Client Side Modding
+ * Flavour is applied there, this should not be used for core engine
+ * @param p
+ * @param is_valid_position
+ * @return
+ */
MapNode Client::getNode(v3s16 p, bool *is_valid_position)
{
+ if (checkCSMFlavourLimit(CSMFlavourLimit::CSM_FL_LOOKUP_NODES)) {
+ v3s16 ppos = floatToInt(m_env.getLocalPlayer()->getPosition(), BS);
+ if ((u32) ppos.getDistanceFrom(p) > m_csm_noderange_limit) {
+ *is_valid_position = false;
+ return MapNode();
+ }
+ }
return m_env.getMap().getNodeNoEx(p, is_valid_position);
}
void Client::setPlayerControl(PlayerControl &control)
{
LocalPlayer *player = m_env.getLocalPlayer();
- assert(player != NULL);
+ assert(player);
player->control = control;
}
void Client::getLocalInventory(Inventory &dst)
{
LocalPlayer *player = m_env.getLocalPlayer();
- assert(player != NULL);
+ assert(player);
dst = player->inventory;
}
case InventoryLocation::CURRENT_PLAYER:
{
LocalPlayer *player = m_env.getLocalPlayer();
- assert(player != NULL);
+ assert(player);
return &player->inventory;
}
break;
u16 Client::getHP()
{
LocalPlayer *player = m_env.getLocalPlayer();
- assert(player != NULL);
+ assert(player);
return player->hp;
}
-bool Client::getChatMessage(std::wstring &message)
+bool Client::getChatMessage(std::wstring &res)
{
- if(m_chat_queue.size() == 0)
+ if (m_chat_queue.empty())
return false;
- message = m_chat_queue.front();
+
+ ChatMessage *chatMessage = m_chat_queue.front();
m_chat_queue.pop();
+
+ res = L"";
+
+ switch (chatMessage->type) {
+ case CHATMESSAGE_TYPE_RAW:
+ case CHATMESSAGE_TYPE_ANNOUNCE:
+ case CHATMESSAGE_TYPE_SYSTEM:
+ res = chatMessage->message;
+ break;
+ case CHATMESSAGE_TYPE_NORMAL: {
+ if (!chatMessage->sender.empty())
+ res = L"<" + chatMessage->sender + L"> " + chatMessage->message;
+ else
+ res = chatMessage->message;
+ break;
+ }
+ default:
+ break;
+ }
+
+ delete chatMessage;
return true;
}
sendChatMessage(message);
// Show locally
- if (message[0] != L'/')
- {
+ if (message[0] != L'/') {
// compatibility code
if (m_proto_ver < 29) {
LocalPlayer *player = m_env.getLocalPlayer();
- assert(player != NULL);
+ assert(player);
std::wstring name = narrow_to_wide(player->getName());
- pushToChatQueue((std::wstring)L"<" + name + L"> " + message);
+ pushToChatQueue(new ChatMessage(CHATMESSAGE_TYPE_NORMAL, message, name));
}
}
}
}
typedef struct TextureUpdateArgs {
- IrrlichtDevice *device;
gui::IGUIEnvironment *guienv;
u64 last_time_ms;
u16 last_percent;
targs->last_time_ms = time_ms;
std::basic_stringstream<wchar_t> strm;
strm << targs->text_base << " " << targs->last_percent << "%...";
- draw_load_screen(strm.str(), targs->device, targs->guienv, targs->tsrc, 0,
+ RenderingEngine::draw_load_screen(strm.str(), targs->guienv, targs->tsrc, 0,
72 + (u16) ((18. / 100.) * (double) targs->last_percent), true);
}
}
-void Client::afterContentReceived(IrrlichtDevice *device)
+void Client::afterContentReceived()
{
infostream<<"Client::afterContentReceived() started"<<std::endl;
assert(m_itemdef_received); // pre-condition
// Clear cached pre-scaled 2D GUI images, as this cache
// might have images with the same name but different
// content from previous sessions.
- guiScalingCacheClear(device->getVideoDriver());
+ guiScalingCacheClear();
// Rebuild inherited images and recreate textures
infostream<<"- Rebuilding images and textures"<<std::endl;
- draw_load_screen(text,device, guienv, m_tsrc, 0, 70);
+ RenderingEngine::draw_load_screen(text, guienv, m_tsrc, 0, 70);
m_tsrc->rebuildImagesAndTextures();
delete[] text;
// Rebuild shaders
infostream<<"- Rebuilding shaders"<<std::endl;
text = wgettext("Rebuilding shaders...");
- draw_load_screen(text, device, guienv, m_tsrc, 0, 71);
+ RenderingEngine::draw_load_screen(text, guienv, m_tsrc, 0, 71);
m_shsrc->rebuildShaders();
delete[] text;
// Update node aliases
infostream<<"- Updating node aliases"<<std::endl;
text = wgettext("Initializing nodes...");
- draw_load_screen(text, device, guienv, m_tsrc, 0, 72);
+ RenderingEngine::draw_load_screen(text, guienv, m_tsrc, 0, 72);
m_nodedef->updateAliases(m_itemdef);
std::string texture_path = g_settings->get("texture_path");
if (texture_path != "" && fs::IsDir(texture_path))
// Update node textures and assign shaders to each tile
infostream<<"- Updating node textures"<<std::endl;
TextureUpdateArgs tu_args;
- tu_args.device = device;
tu_args.guienv = guienv;
tu_args.last_time_ms = porting::getTimeMs();
tu_args.last_percent = 0;
}
text = wgettext("Done!");
- draw_load_screen(text, device, guienv, m_tsrc, 0, 100);
+ RenderingEngine::draw_load_screen(text, guienv, m_tsrc, 0, 100);
infostream<<"Client::afterContentReceived() done"<<std::endl;
delete[] text;
}
float Client::getCurRate()
{
- return ( m_con.getLocalStat(con::CUR_INC_RATE) +
+ return (m_con.getLocalStat(con::CUR_INC_RATE) +
m_con.getLocalStat(con::CUR_DL_RATE));
}
-void Client::makeScreenshot(IrrlichtDevice *device)
+void Client::makeScreenshot()
{
- irr::video::IVideoDriver *driver = device->getVideoDriver();
+ irr::video::IVideoDriver *driver = RenderingEngine::get_video_driver();
irr::video::IImage* const raw_image = driver->createScreenShot();
if (!raw_image)
} else {
sstr << "Failed to save screenshot '" << filename << "'";
}
- pushToChatQueue(narrow_to_wide(sstr.str()));
+ pushToChatQueue(new ChatMessage(CHATMESSAGE_TYPE_SYSTEM,
+ narrow_to_wide(sstr.str())));
infostream << sstr.str() << std::endl;
image->drop();
}
{
return m_shsrc;
}
-scene::ISceneManager* Client::getSceneManager()
-{
- return m_device->getSceneManager();
-}
+
u16 Client::allocateUnknownNodeId(const std::string &name)
{
errorstream << "Client::allocateUnknownNodeId(): "
return NULL;
}
const std::string &data = it->second;
- scene::ISceneManager *smgr = m_device->getSceneManager();
// Create the mesh, remove it from cache and return it
// This allows unique vertex colors and other properties for each instance
Buffer<char> data_rw(data.c_str(), data.size()); // Const-incorrect Irrlicht
- io::IFileSystem *irrfs = m_device->getFileSystem();
- io::IReadFile *rfile = irrfs->createMemoryReadFile(
+ io::IReadFile *rfile = RenderingEngine::get_filesystem()->createMemoryReadFile(
*data_rw, data_rw.getSize(), filename.c_str());
FATAL_ERROR_IF(!rfile, "Could not create/open RAM file");
- scene::IAnimatedMesh *mesh = smgr->getMesh(rfile);
+ scene::IAnimatedMesh *mesh = RenderingEngine::get_scene_manager()->getMesh(rfile);
rfile->drop();
// NOTE: By playing with Irrlicht refcounts, maybe we could cache a bunch
// of uniquely named instances and re-use them
mesh->grab();
- smgr->getMeshCache()->removeMesh(mesh);
+ RenderingEngine::get_mesh_cache()->removeMesh(mesh);
return mesh;
}
+const std::string* Client::getModFile(const std::string &filename)
+{
+ StringMap::const_iterator it = m_mod_files.find(filename);
+ if (it == m_mod_files.end()) {
+ errorstream << "Client::getModFile(): File not found: \"" << filename
+ << "\"" << std::endl;
+ return NULL;
+ }
+ return &it->second;
+}
+
bool Client::registerModStorage(ModMetadata *storage)
{
if (m_mod_storages.find(storage->getModName()) != m_mod_storages.end()) {
void Client::unregisterModStorage(const std::string &name)
{
- UNORDERED_MAP<std::string, ModMetadata *>::const_iterator it = m_mod_storages.find(name);
+ std::unordered_map<std::string, ModMetadata *>::const_iterator it =
+ m_mod_storages.find(name);
if (it != m_mod_storages.end()) {
// Save unconditionaly on unregistration
it->second->save(getModStoragePath());
{
return porting::path_user + DIR_DELIM + "client" + DIR_DELIM + "mod_storage";
}
-
projects / oweals / minetest.git / blobdiff