#include "database-sqlite3.h"
#include "serialization.h"
#include "guiscalingfilter.h"
-#include "script/clientscripting.h"
+#include "script/scripting_client.h"
#include "game.h"
extern gui::IGUIEnvironment* guienv;
-/*
- QueuedMeshUpdate
-*/
-
-QueuedMeshUpdate::QueuedMeshUpdate():
- p(-1337,-1337,-1337),
- data(NULL),
- ack_block_to_server(false)
-{
-}
-
-QueuedMeshUpdate::~QueuedMeshUpdate()
-{
- if(data)
- delete data;
-}
-
-/*
- MeshUpdateQueue
-*/
-
-MeshUpdateQueue::MeshUpdateQueue()
-{
-}
-
-MeshUpdateQueue::~MeshUpdateQueue()
-{
- MutexAutoLock lock(m_mutex);
-
- for(std::vector<QueuedMeshUpdate*>::iterator
- i = m_queue.begin();
- i != m_queue.end(); ++i)
- {
- QueuedMeshUpdate *q = *i;
- delete q;
- }
-}
-
-/*
- peer_id=0 adds with nobody to send to
-*/
-void MeshUpdateQueue::addBlock(v3s16 p, MeshMakeData *data, bool ack_block_to_server, bool urgent)
-{
- DSTACK(FUNCTION_NAME);
-
- assert(data); // pre-condition
-
- MutexAutoLock lock(m_mutex);
-
- if(urgent)
- m_urgents.insert(p);
-
- /*
- Find if block is already in queue.
- If it is, update the data and quit.
- */
- for(std::vector<QueuedMeshUpdate*>::iterator
- i = m_queue.begin();
- i != m_queue.end(); ++i)
- {
- QueuedMeshUpdate *q = *i;
- if(q->p == p)
- {
- if(q->data)
- delete q->data;
- q->data = data;
- if(ack_block_to_server)
- q->ack_block_to_server = true;
- return;
- }
- }
-
- /*
- Add the block
- */
- QueuedMeshUpdate *q = new QueuedMeshUpdate;
- q->p = p;
- q->data = data;
- q->ack_block_to_server = ack_block_to_server;
- m_queue.push_back(q);
-}
-
-// Returned pointer must be deleted
-// Returns NULL if queue is empty
-QueuedMeshUpdate *MeshUpdateQueue::pop()
-{
- MutexAutoLock lock(m_mutex);
-
- bool must_be_urgent = !m_urgents.empty();
- for(std::vector<QueuedMeshUpdate*>::iterator
- i = m_queue.begin();
- i != m_queue.end(); ++i)
- {
- QueuedMeshUpdate *q = *i;
- if(must_be_urgent && m_urgents.count(q->p) == 0)
- continue;
- m_queue.erase(i);
- m_urgents.erase(q->p);
- return q;
- }
- return NULL;
-}
-
-/*
- MeshUpdateThread
-*/
-
-MeshUpdateThread::MeshUpdateThread() : UpdateThread("Mesh")
-{
- m_generation_interval = g_settings->getU16("mesh_generation_interval");
- m_generation_interval = rangelim(m_generation_interval, 0, 50);
-}
-
-void MeshUpdateThread::enqueueUpdate(v3s16 p, MeshMakeData *data,
- bool ack_block_to_server, bool urgent)
-{
- m_queue_in.addBlock(p, data, ack_block_to_server, urgent);
- deferUpdate();
-}
-
-void MeshUpdateThread::doUpdate()
-{
- QueuedMeshUpdate *q;
- while ((q = m_queue_in.pop())) {
- if (m_generation_interval)
- sleep_ms(m_generation_interval);
- ScopeProfiler sp(g_profiler, "Client: Mesh making");
-
- MapBlockMesh *mesh_new = new MapBlockMesh(q->data, m_camera_offset);
-
- MeshUpdateResult r;
- r.p = q->p;
- r.mesh = mesh_new;
- r.ack_block_to_server = q->ack_block_to_server;
-
- m_queue_out.push_back(r);
-
- delete q;
- }
-}
-
/*
Client
*/
Client::Client(
IrrlichtDevice *device,
const char *playername,
- std::string password,
+ const std::string &password,
+ const std::string &address_name,
MapDrawControl &control,
IWritableTextureSource *tsrc,
IWritableShaderSource *shsrc,
m_nodedef(nodedef),
m_sound(sound),
m_event(event),
- m_mesh_update_thread(),
+ m_mesh_update_thread(this),
m_env(
new ClientMap(this, control,
device->getSceneManager()->getRootSceneNode(),
),
m_particle_manager(&m_env),
m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, ipv6, this),
+ m_address_name(address_name),
m_device(device),
m_camera(NULL),
+ m_minimap(NULL),
m_minimap_disabled_by_server(false),
m_server_ser_ver(SER_FMT_VER_INVALID),
m_proto_ver(0),
m_animation_time(0),
m_crack_level(-1),
m_crack_pos(0,0,0),
+ m_last_chat_message_sent(time(NULL)),
+ m_chat_message_allowance(5.0f),
m_map_seed(0),
m_password(password),
m_chosen_auth_mech(AUTH_MECHANISM_NONE),
// 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(device, this);
+ }
m_cache_save_interval = g_settings->getU16("server_map_save_interval");
- m_cache_smooth_lighting = g_settings->getBool("smooth_lighting");
- m_cache_enable_shaders = g_settings->getBool("enable_shaders");
- m_cache_use_tangent_vertices = m_cache_enable_shaders && (
- g_settings->getBool("enable_bumpmapping") ||
- g_settings->getBool("enable_parallax_occlusion"));
-
m_modding_enabled = g_settings->getBool("enable_client_modding");
m_script = new ClientScripting(this);
m_env.setScript(m_script);
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.");
}
std::string script_path = mod.path + DIR_DELIM + "init.lua";
infostream << " [" << padStringRight(mod.name, 12) << "] [\""
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
*/
// Step environment
m_env.step(dtime);
+ m_sound->step(dtime);
/*
Get events
*/
- for(;;) {
- ClientEnvEvent event = m_env.getClientEvent();
- if(event.type == CEE_NONE) {
- break;
- }
- else if(event.type == CEE_PLAYER_DAMAGE) {
- if(m_ignore_damage_timer <= 0) {
- u8 damage = event.player_damage.amount;
+ while (m_env.hasClientEnvEvents()) {
+ ClientEnvEvent envEvent = m_env.getClientEnvEvent();
- if(event.player_damage.send_to_server)
+ if (envEvent.type == CEE_PLAYER_DAMAGE) {
+ if (m_ignore_damage_timer <= 0) {
+ u8 damage = envEvent.player_damage.amount;
+
+ if (envEvent.player_damage.send_to_server)
sendDamage(damage);
// Add to ClientEvent queue
}
}
// Protocol v29 or greater obsoleted this event
- else if (event.type == CEE_PLAYER_BREATH && m_proto_ver < 29) {
- u16 breath = event.player_breath.amount;
+ else if (envEvent.type == CEE_PLAYER_BREATH && m_proto_ver < 29) {
+ u16 breath = envEvent.player_breath.amount;
sendBreath(breath);
}
}
minimap_mapblock = r.mesh->moveMinimapMapblock();
if (minimap_mapblock == NULL)
do_mapper_update = false;
- }
- if (r.mesh && r.mesh->getMesh()->getMeshBufferCount() == 0) {
- delete r.mesh;
- } else {
- // Replace with the new mesh
- block->mesh = r.mesh;
+ bool is_empty = true;
+ for (int l = 0; l < MAX_TILE_LAYERS; l++)
+ if (r.mesh->getMesh(l)->getMeshBufferCount() != 0)
+ is_empty = false;
+
+ if (is_empty)
+ delete r.mesh;
+ else
+ // Replace with the new mesh
+ block->mesh = r.mesh;
}
} else {
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) {
if (m_media_downloader && m_media_downloader->isStarted()) {
m_media_downloader->step(this);
if (m_media_downloader->isDone()) {
- received_media();
delete m_media_downloader;
m_media_downloader = NULL;
}
<< file_requests.size() << " files. packet size)" << std::endl;
}
-void Client::received_media()
-{
- NetworkPacket pkt(TOSERVER_RECEIVED_MEDIA, 0);
- Send(&pkt);
- infostream << "Client: Notifying server that we received all media"
- << std::endl;
-}
-
void Client::initLocalMapSaving(const Address &address,
const std::string &hostname,
bool is_local_server)
fs::CreateAllDirs(world_path);
- m_localdb = new Database_SQLite3(world_path);
+ m_localdb = new MapDatabaseSQLite3(world_path);
m_localdb->beginSave();
actionstream << "Local map saving started, map will be saved at '" << world_path << "'" << std::endl;
}
void Client::ReceiveAll()
{
DSTACK(FUNCTION_NAME);
- u32 start_ms = porting::getTimeMs();
+ u64 start_ms = porting::getTimeMs();
for(;;)
{
// Limit time even if there would be huge amounts of data to
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,
return m_crack_level;
}
+v3s16 Client::getCrackPos()
+{
+ return m_crack_pos;
+}
+
void Client::setCrack(int level, v3s16 pos)
{
int old_crack_level = m_crack_level;
void Client::addUpdateMeshTask(v3s16 p, bool ack_to_server, bool urgent)
{
+ // Check if the block exists to begin with. In the case when a non-existing
+ // neighbor is automatically added, it may not. In that case we don't want
+ // to tell the mesh update thread about it.
MapBlock *b = m_env.getMap().getBlockNoCreateNoEx(p);
- if(b == NULL)
+ if (b == NULL)
return;
- /*
- Create a task to update the mesh of the block
- */
-
- MeshMakeData *data = new MeshMakeData(this, m_cache_enable_shaders,
- m_cache_use_tangent_vertices);
-
- {
- //TimeTaker timer("data fill");
- // Release: ~0ms
- // Debug: 1-6ms, avg=2ms
- data->fill(b);
- data->setCrack(m_crack_level, m_crack_pos);
- data->setSmoothLighting(m_cache_smooth_lighting);
- }
-
- // Add task to queue
- m_mesh_update_thread.enqueueUpdate(p, data, ack_to_server, urgent);
+ m_mesh_update_thread.updateBlock(&m_env.getMap(), p, ack_to_server, urgent);
}
void Client::addUpdateMeshTaskWithEdge(v3s16 blockpos, bool ack_to_server, bool urgent)
ClientEvent Client::getClientEvent()
{
- ClientEvent event;
- if (m_client_event_queue.empty()) {
- event.type = CE_NONE;
- }
- else {
- event = m_client_event_queue.front();
- m_client_event_queue.pop();
- }
+ FATAL_ERROR_IF(m_client_event_queue.empty(),
+ "Cannot getClientEvent, queue is empty.");
+
+ ClientEvent event = m_client_event_queue.front();
+ m_client_event_queue.pop();
return event;
}
typedef struct TextureUpdateArgs {
IrrlichtDevice *device;
gui::IGUIEnvironment *guienv;
- u32 last_time_ms;
+ u64 last_time_ms;
u16 last_percent;
const wchar_t* text_base;
+ ITextureSource *tsrc;
} TextureUpdateArgs;
void texture_update_progress(void *args, u32 progress, u32 max_progress)
// update the loading menu -- if neccessary
bool do_draw = false;
- u32 time_ms = targs->last_time_ms;
+ u64 time_ms = targs->last_time_ms;
if (cur_percent != targs->last_percent) {
targs->last_percent = cur_percent;
- time_ms = getTimeMs();
+ time_ms = porting::getTimeMs();
// only draw when the user will notice something:
do_draw = (time_ms - targs->last_time_ms > 100);
}
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, 0,
- 72 + (u16) ((18. / 100.) * (double) targs->last_percent));
+ draw_load_screen(strm.str(), targs->device, targs->guienv, targs->tsrc, 0,
+ 72 + (u16) ((18. / 100.) * (double) targs->last_percent), true);
}
}
// Rebuild inherited images and recreate textures
infostream<<"- Rebuilding images and textures"<<std::endl;
- draw_load_screen(text,device, guienv, 0, 70);
+ draw_load_screen(text,device, 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, 0, 71);
+ draw_load_screen(text, device, 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, 0, 72);
+ draw_load_screen(text, device, 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))
TextureUpdateArgs tu_args;
tu_args.device = device;
tu_args.guienv = guienv;
- tu_args.last_time_ms = getTimeMs();
+ tu_args.last_time_ms = porting::getTimeMs();
tu_args.last_percent = 0;
tu_args.text_base = wgettext("Initializing nodes");
+ tu_args.tsrc = m_tsrc;
m_nodedef->updateTextures(this, texture_update_progress, &tu_args);
delete[] tu_args.text_base;
m_state = LC_Ready;
sendReady();
- if (g_settings->getBool("enable_client_modding"))
+ if (g_settings->getBool("enable_client_modding")) {
+ m_script->on_client_ready(m_env.getLocalPlayer());
m_script->on_connect();
+ }
text = wgettext("Done!");
- draw_load_screen(text, device, guienv, 0, 100);
+ draw_load_screen(text, device, 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));
}
{
return porting::path_user + DIR_DELIM + "client" + DIR_DELIM + "mod_storage";
}
-