#include "network/connection.h"
#include "network/networkpacket.h"
#include "threading/mutex_auto_lock.h"
+#include "client/clientevent.h"
+#include "client/gameui.h"
#include "client/renderingengine.h"
+#include "client/tile.h"
#include "util/auth.h"
#include "util/directiontables.h"
#include "util/pointedthing.h"
#include "mapblock_mesh.h"
#include "mapblock.h"
#include "minimap.h"
+#include "modchannels.h"
#include "mods.h"
#include "profiler.h"
#include "shader.h"
#include "clientmap.h"
#include "clientmedia.h"
#include "version.h"
-#include "database-sqlite3.h"
+#include "database/database-sqlite3.h"
#include "serialization.h"
#include "guiscalingfilter.h"
#include "script/scripting_client.h"
#include "game.h"
#include "chatmessage.h"
+#include "translation.h"
extern gui::IGUIEnvironment* guienv;
ISoundManager *sound,
MtEventManager *event,
bool ipv6,
- GameUIFlags *game_ui_flags
+ GameUI *game_ui
):
m_tsrc(tsrc),
m_shsrc(shsrc),
m_chosen_auth_mech(AUTH_MECHANISM_NONE),
m_media_downloader(new ClientMediaDownloader()),
m_state(LC_Created),
- m_game_ui_flags(game_ui_flags)
+ m_game_ui(game_ui),
+ m_modchannel_mgr(new ModChannelMgr())
{
// Add local player
m_env.setLocalPlayer(new LocalPlayer(this, playername));
m_script->setEnv(&m_env);
}
-void Client::loadMods()
+void Client::loadBuiltin()
{
// Load builtin
scanModIntoMemory(BUILTIN_MOD_NAME, getBuiltinLuaPath());
- // If modding is not enabled, don't load mods, just builtin
+ m_script->loadModFromMemory(BUILTIN_MOD_NAME);
+}
+
+void Client::loadMods()
+{
+ // Don't permit to load mods twice
+ if (m_mods_loaded) {
+ return;
+ }
+
+ // If modding is not enabled or flavour disable it, don't load mods, just builtin
if (!m_modding_enabled) {
+ warningstream << "Client side mods are disabled by configuration." << std::endl;
return;
}
+
+ if (checkCSMFlavourLimit(CSMFlavourLimit::CSM_FL_LOAD_CLIENT_MODS)) {
+ warningstream << "Client side mods are disabled by server." << std::endl;
+ // If mods loading is disabled and builtin integrity is wrong, disconnect user.
+ if (!checkBuiltinIntegrity()) {
+ // @TODO disconnect user
+ }
+ return;
+ }
+
ClientModConfiguration modconf(getClientModsLuaPath());
m_mods = modconf.getMods();
- std::vector<ModSpec> unsatisfied_mods = modconf.getUnsatisfiedMods();
// complain about mods with unsatisfied dependencies
if (!modconf.isConsistent()) {
modconf.printUnsatisfiedModsError();
}
scanModIntoMemory(mod.name, mod.path);
}
+
+ // Load and run "mod" scripts
+ for (const ModSpec &mod : m_mods)
+ m_script->loadModFromMemory(mod.name);
+
+ m_mods_loaded = true;
+}
+
+bool Client::checkBuiltinIntegrity()
+{
+ // @TODO
+ return true;
}
void Client::scanModSubfolder(const std::string &mod_name, const std::string &mod_path,
}
}
-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";
void Client::connect(Address address, bool is_local_server)
{
- DSTACK(FUNCTION_NAME);
-
initLocalMapSaving(address, m_address_name, is_local_server);
m_con->SetTimeoutMs(0);
void Client::step(float dtime)
{
- DSTACK(FUNCTION_NAME);
-
// Limit a bit
- if(dtime > 2.0)
+ if (dtime > 2.0)
dtime = 2.0;
- if(m_ignore_damage_timer > dtime)
- m_ignore_damage_timer -= dtime;
- else
- m_ignore_damage_timer = 0.0;
-
m_animation_time += dtime;
if(m_animation_time > 60.0)
m_animation_time -= 60.0;
LocalPlayer *myplayer = m_env.getLocalPlayer();
FATAL_ERROR_IF(myplayer == NULL, "Local player not found in environment.");
- u16 proto_version_min = g_settings->getFlag("send_pre_v25_init") ?
- CLIENT_PROTOCOL_VERSION_MIN_LEGACY : CLIENT_PROTOCOL_VERSION_MIN;
-
- if (proto_version_min < 25) {
- // Send TOSERVER_INIT_LEGACY
- // [0] u16 TOSERVER_INIT_LEGACY
- // [2] u8 SER_FMT_VER_HIGHEST_READ
- // [3] u8[20] player_name
- // [23] u8[28] password (new in some version)
- // [51] u16 minimum supported network protocol version (added sometime)
- // [53] u16 maximum supported network protocol version (added later than the previous one)
-
- char pName[PLAYERNAME_SIZE];
- char pPassword[PASSWORD_SIZE];
- memset(pName, 0, PLAYERNAME_SIZE * sizeof(char));
- memset(pPassword, 0, PASSWORD_SIZE * sizeof(char));
-
- std::string hashed_password = translate_password(myplayer->getName(), m_password);
- snprintf(pName, PLAYERNAME_SIZE, "%s", myplayer->getName());
- snprintf(pPassword, PASSWORD_SIZE, "%s", hashed_password.c_str());
-
- sendLegacyInit(pName, pPassword);
- }
- if (CLIENT_PROTOCOL_VERSION_MAX >= 25)
- sendInit(myplayer->getName());
+ sendInit(myplayer->getName());
}
// Not connected, return
ClientEnvEvent envEvent = m_env.getClientEnvEvent();
if (envEvent.type == CEE_PLAYER_DAMAGE) {
- if (m_ignore_damage_timer <= 0) {
- u8 damage = envEvent.player_damage.amount;
+ u8 damage = envEvent.player_damage.amount;
- if (envEvent.player_damage.send_to_server)
- sendDamage(damage);
+ if (envEvent.player_damage.send_to_server)
+ sendDamage(damage);
- // Add to ClientEvent queue
- ClientEvent event;
- event.type = CE_PLAYER_DAMAGE;
- event.player_damage.amount = damage;
- m_client_event_queue.push(event);
- }
- }
- // Protocol v29 or greater obsoleted this event
- else if (envEvent.type == CEE_PLAYER_BREATH && m_proto_ver < 29) {
- u16 breath = envEvent.player_breath.amount;
- sendBreath(breath);
+ // Add to ClientEvent queue
+ ClientEvent *event = new ClientEvent();
+ event->type = CE_PLAYER_DAMAGE;
+ event->player_damage.amount = damage;
+ m_client_event_queue.push(event);
}
}
return true;
}
- errorstream<<"Client: Don't know how to load file \""
- <<filename<<"\""<<std::endl;
+ const char *translate_ext[] = {
+ ".tr", NULL
+ };
+ name = removeStringEnd(filename, translate_ext);
+ if (!name.empty()) {
+ verbosestream << "Client: Loading translation: "
+ << "\"" << filename << "\"" << std::endl;
+ g_translations->loadTranslation(data);
+ return true;
+ }
+
+ errorstream << "Client: Don't know how to load file \""
+ << filename << "\"" << std::endl;
return false;
}
void Client::ReceiveAll()
{
- DSTACK(FUNCTION_NAME);
u64 start_ms = porting::getTimeMs();
for(;;)
{
void Client::Receive()
{
- DSTACK(FUNCTION_NAME);
NetworkPacket pkt;
m_con->Receive(&pkt);
ProcessData(&pkt);
*/
void Client::ProcessData(NetworkPacket *pkt)
{
- DSTACK(FUNCTION_NAME);
-
ToClientCommand command = (ToClientCommand) pkt->getCommand();
u32 sender_peer_id = pkt->getPeerId();
return AUTH_MECHANISM_NONE;
}
-void Client::sendLegacyInit(const char* playerName, const char* playerPassword)
-{
- NetworkPacket pkt(TOSERVER_INIT_LEGACY,
- 1 + PLAYERNAME_SIZE + PASSWORD_SIZE + 2 + 2);
-
- u16 proto_version_min = g_settings->getFlag("send_pre_v25_init") ?
- CLIENT_PROTOCOL_VERSION_MIN_LEGACY : CLIENT_PROTOCOL_VERSION_MIN;
-
- pkt << (u8) SER_FMT_VER_HIGHEST_READ;
- pkt.putRawString(playerName,PLAYERNAME_SIZE);
- pkt.putRawString(playerPassword, PASSWORD_SIZE);
- pkt << (u16) proto_version_min << (u16) CLIENT_PROTOCOL_VERSION_MAX;
-
- Send(&pkt);
-}
-
void Client::sendInit(const std::string &playerName)
{
NetworkPacket pkt(TOSERVER_INIT, 1 + 2 + 2 + (1 + playerName.size()));
// we don't support network compression yet
u16 supp_comp_modes = NETPROTO_COMPRESSION_NONE;
- u16 proto_version_min = g_settings->getFlag("send_pre_v25_init") ?
- CLIENT_PROTOCOL_VERSION_MIN_LEGACY : CLIENT_PROTOCOL_VERSION_MIN;
-
pkt << (u8) SER_FMT_VER_HIGHEST_READ << (u16) supp_comp_modes;
- pkt << (u16) proto_version_min << (u16) CLIENT_PROTOCOL_VERSION_MAX;
+ pkt << (u16) CLIENT_PROTOCOL_VERSION_MIN << (u16) CLIENT_PROTOCOL_VERSION_MAX;
pkt << playerName;
Send(&pkt);
if (player == NULL)
return;
- std::string playername = player->getName();
- if (m_proto_ver >= 25) {
- // get into sudo mode and then send new password to server
- m_password = oldpassword;
- m_new_password = newpassword;
- startAuth(choseAuthMech(m_sudo_auth_methods));
- } else {
- std::string oldpwd = translate_password(playername, oldpassword);
- std::string newpwd = translate_password(playername, newpassword);
-
- NetworkPacket pkt(TOSERVER_PASSWORD_LEGACY, 2 * PASSWORD_SIZE);
-
- for (u8 i = 0; i < PASSWORD_SIZE; i++) {
- pkt << (u8) (i < oldpwd.length() ? oldpwd[i] : 0);
- }
-
- for (u8 i = 0; i < PASSWORD_SIZE; i++) {
- pkt << (u8) (i < newpwd.length() ? newpwd[i] : 0);
- }
- Send(&pkt);
- }
+ // get into sudo mode and then send new password to server
+ m_password = oldpassword;
+ m_new_password = newpassword;
+ startAuth(choseAuthMech(m_sudo_auth_methods));
}
void Client::sendDamage(u8 damage)
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket pkt(TOSERVER_DAMAGE, sizeof(u8));
pkt << damage;
Send(&pkt);
}
-void Client::sendBreath(u16 breath)
-{
- DSTACK(FUNCTION_NAME);
-
- // Protocol v29 make this obsolete
- if (m_proto_ver >= 29)
- return;
-
- NetworkPacket pkt(TOSERVER_BREATH, sizeof(u16));
- pkt << breath;
- Send(&pkt);
-}
-
void Client::sendRespawn()
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket pkt(TOSERVER_RESPAWN, 0);
Send(&pkt);
}
void Client::sendReady()
{
- DSTACK(FUNCTION_NAME);
-
NetworkPacket pkt(TOSERVER_CLIENT_READY,
1 + 1 + 1 + 1 + 2 + sizeof(char) * strlen(g_version_hash));
void Client::sendPlayerPos()
{
LocalPlayer *myplayer = m_env.getLocalPlayer();
- if(myplayer == NULL)
+ if (!myplayer)
return;
ClientMap &map = m_env.getClientMap();
myplayer->last_camera_fov = camera_fov;
myplayer->last_wanted_range = wanted_range;
- //infostream << "Sending Player Position information" << std::endl;
-
- u16 our_peer_id;
- {
- //MutexAutoLock lock(m_con_mutex); //bulk comment-out
- our_peer_id = m_con->GetPeerID();
- }
-
- // Set peer id if not set already
- if(myplayer->peer_id == PEER_ID_INEXISTENT)
- myplayer->peer_id = our_peer_id;
-
- assert(myplayer->peer_id == our_peer_id);
-
NetworkPacket pkt(TOSERVER_PLAYERPOS, 12 + 12 + 4 + 4 + 4 + 1 + 1);
writePlayerPos(myplayer, &map, &pkt);
void Client::sendPlayerItem(u16 item)
{
LocalPlayer *myplayer = m_env.getLocalPlayer();
- if(myplayer == NULL)
+ if (!myplayer)
return;
- u16 our_peer_id = m_con->GetPeerID();
-
- // Set peer id if not set already
- if(myplayer->peer_id == PEER_ID_INEXISTENT)
- myplayer->peer_id = our_peer_id;
- assert(myplayer->peer_id == our_peer_id);
-
NetworkPacket pkt(TOSERVER_PLAYERITEM, 2);
pkt << item;
}
}
-ClientEvent Client::getClientEvent()
+ClientEvent *Client::getClientEvent()
{
FATAL_ERROR_IF(m_client_event_queue.empty(),
"Cannot getClientEvent, queue is empty.");
- ClientEvent event = m_client_event_queue.front();
+ ClientEvent *event = m_client_event_queue.front();
m_client_event_queue.pop();
return event;
}
text = wgettext("Initializing nodes...");
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.empty() && fs::IsDir(texture_path))
- m_nodedef->applyTextureOverrides(texture_path + DIR_DELIM + "override.txt");
+ for (const auto &path : getTextureDirs())
+ m_nodedef->applyTextureOverrides(path + DIR_DELIM + "override.txt");
m_nodedef->setNodeRegistrationStatus(true);
m_nodedef->runNodeResolveCallbacks();
delete[] text;
return !m_minimap_disabled_by_server;
}
-void Client::showGameChat(const bool show)
+void Client::pushToEventQueue(ClientEvent *event)
{
- m_game_ui_flags->show_chat = show;
-}
-
-void Client::showGameHud(const bool show)
-{
- m_game_ui_flags->show_hud = show;
+ m_client_event_queue.push(event);
}
void Client::showMinimap(const bool show)
{
- m_game_ui_flags->show_minimap = show;
-}
-
-void Client::showProfiler(const bool show)
-{
- m_game_ui_flags->show_profiler_graph = show;
-}
-
-void Client::showGameFog(const bool show)
-{
- m_game_ui_flags->force_fog_off = !show;
-}
-
-void Client::showGameDebug(const bool show)
-{
- m_game_ui_flags->show_debug = show;
+ m_game_ui->showMinimap(show);
}
// IGameDef interface
return &m_particle_manager;
}
-scene::IAnimatedMesh* Client::getMesh(const std::string &filename)
+scene::IAnimatedMesh* Client::getMesh(const std::string &filename, bool cache)
{
StringMap::const_iterator it = m_mesh_data.find(filename);
if (it == m_mesh_data.end()) {
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();
- RenderingEngine::get_mesh_cache()->removeMesh(mesh);
+ if (!cache)
+ RenderingEngine::get_mesh_cache()->removeMesh(mesh);
return mesh;
}
{
return porting::path_user + DIR_DELIM + "client" + DIR_DELIM + "mod_storage";
}
+
+/*
+ * Mod channels
+ */
+
+bool Client::joinModChannel(const std::string &channel)
+{
+ if (m_modchannel_mgr->channelRegistered(channel))
+ return false;
+
+ NetworkPacket pkt(TOSERVER_MODCHANNEL_JOIN, 2 + channel.size());
+ pkt << channel;
+ Send(&pkt);
+
+ m_modchannel_mgr->joinChannel(channel, 0);
+ return true;
+}
+
+bool Client::leaveModChannel(const std::string &channel)
+{
+ if (!m_modchannel_mgr->channelRegistered(channel))
+ return false;
+
+ NetworkPacket pkt(TOSERVER_MODCHANNEL_LEAVE, 2 + channel.size());
+ pkt << channel;
+ Send(&pkt);
+
+ m_modchannel_mgr->leaveChannel(channel, 0);
+ return true;
+}
+
+bool Client::sendModChannelMessage(const std::string &channel, const std::string &message)
+{
+ if (!m_modchannel_mgr->canWriteOnChannel(channel))
+ return false;
+
+ if (message.size() > STRING_MAX_LEN) {
+ warningstream << "ModChannel message too long, dropping before sending "
+ << " (" << message.size() << " > " << STRING_MAX_LEN << ", channel: "
+ << channel << ")" << std::endl;
+ return false;
+ }
+
+ // @TODO: do some client rate limiting
+ NetworkPacket pkt(TOSERVER_MODCHANNEL_MSG, 2 + channel.size() + 2 + message.size());
+ pkt << channel << message;
+ Send(&pkt);
+ return true;
+}
+
+ModChannel* Client::getModChannel(const std::string &channel)
+{
+ return m_modchannel_mgr->getModChannel(channel);
+}
projects / minetest.git / blobdiff