/*
MeshUpdateQueue
*/
-
+
MeshUpdateQueue::MeshUpdateQueue()
{
}
return;
}
}
-
+
/*
Add the block
*/
log_register_thread("MeshUpdateThread");
DSTACK(__FUNCTION_NAME);
-
+
BEGIN_DEBUG_EXCEPTION_HANDLER
porting::setThreadName("MeshUpdateThread");
IrrlichtDevice *device,
const char *playername,
std::string password,
- bool is_simple_singleplayer_game,
MapDrawControl &control,
IWritableTextureSource *tsrc,
IWritableShaderSource *shsrc,
device->getSceneManager(),
tsrc, this, device
),
+ m_particle_manager(&m_env),
m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, ipv6, this),
m_device(device),
m_server_ser_ver(SER_FMT_VER_INVALID),
m_inventory_updated(false),
m_inventory_from_server(NULL),
m_inventory_from_server_age(0.0),
- m_show_hud(true),
+ m_show_highlighted(false),
m_animation_time(0),
m_crack_level(-1),
m_crack_pos(0,0,0),
+ m_highlighted_pos(0,0,0),
m_map_seed(0),
m_password(password),
m_access_denied(false),
m_env.addPlayer(player);
}
- if (g_settings->getBool("enable_local_map_saving")
- && !is_simple_singleplayer_game) {
- const std::string world_path = porting::path_user + DIR_DELIM + "worlds"
- + DIR_DELIM + "server_" + g_settings->get("address")
- + "_" + g_settings->get("remote_port");
-
- SubgameSpec gamespec;
- if (!getWorldExists(world_path)) {
- gamespec = findSubgame(g_settings->get("default_game"));
- if (!gamespec.isValid())
- gamespec = findSubgame("minimal");
- } else {
- std::string world_gameid = getWorldGameId(world_path, false);
- gamespec = findWorldSubgame(world_path);
- }
- if (!gamespec.isValid()) {
- errorstream << "Couldn't find subgame for local map saving." << std::endl;
- return;
- }
-
- localserver = new Server(world_path, gamespec, false, false);
- localdb = new Database_SQLite3(&(ServerMap&)localserver->getMap(), world_path);
- localdb->beginSave();
- actionstream << "Local map saving started, map will be saved at '" << world_path << "'" << std::endl;
- } else {
- localdb = NULL;
- }
+ m_cache_smooth_lighting = g_settings->getBool("smooth_lighting");
}
void Client::Stop()
if (localdb != NULL) {
actionstream << "Local map saving ended" << std::endl;
localdb->endSave();
+ delete localserver;
}
}
}
}
-void Client::connect(Address address)
+void Client::connect(Address address,
+ const std::string &address_name,
+ bool is_local_server)
{
DSTACK(__FUNCTION_NAME);
+
+ initLocalMapSaving(address, address_name, is_local_server);
+
m_con.SetTimeoutMs(0);
m_con.Connect(address);
}
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;
if(counter <= 0.0)
{
counter = 20.0;
-
+
infostream << "Client packetcounter (" << m_packetcounter_timer
<< "):"<<std::endl;
m_packetcounter.print(infostream);
NOTE: This jams the game for a while because deleting sectors
clear caches
*/
-
+
float &counter = m_delete_unused_sectors_timer;
counter -= dtime;
if(counter <= 0.0)
float delete_unused_sectors_timeout =
g_settings->getFloat("client_delete_unused_sectors_timeout");
-
+
// Delete sector blocks
/*u32 num = m_env.getMap().unloadUnusedData
(delete_unused_sectors_timeout,
true, &deleted_blocks);*/
-
+
// Delete whole sectors
m_env.getMap().unloadUnusedData
(delete_unused_sectors_timeout,
<<" unused sectors"<<std::endl;*/
/*infostream<<"Client: Deleted "<<num
<<" unused sectors"<<std::endl;*/
-
+
/*
Send info to server
*/
// Env is locked so con can be locked.
//JMutexAutoLock lock(m_con_mutex); //bulk comment-out
-
+
core::list<v3s16>::Iterator i = deleted_blocks.begin();
core::list<v3s16> sendlist;
for(;;)
counter = 2.0;
//JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
-
+
Player *myplayer = m_env.getLocalPlayer();
assert(myplayer != NULL);
// Send TOSERVER_INIT
memset((char*)&data[23], 0, PASSWORD_SIZE);
snprintf((char*)&data[23], PASSWORD_SIZE, "%s", m_password.c_str());
-
+
writeU16(&data[51], CLIENT_PROTOCOL_VERSION_MIN);
writeU16(&data[53], CLIENT_PROTOCOL_VERSION_MAX);
/*
Do stuff if connected
*/
-
+
/*
Run Map's timers and unload unused data
*/
m_env.getMap().timerUpdate(map_timer_and_unload_dtime,
g_settings->getFloat("client_unload_unused_data_timeout"),
&deleted_blocks);
-
+
/*if(deleted_blocks.size() > 0)
infostream<<"Client: Unloaded "<<deleted_blocks.size()
<<" unused blocks"<<std::endl;*/
-
+
/*
Send info to server
NOTE: This loop is intentionally iterated the way it is.
{
if(sendlist.size() == 255 || i == deleted_blocks.end())
{
- if(sendlist.size() == 0)
+ if(sendlist.empty())
break;
/*
[0] u16 command
// Step environment
m_env.step(dtime);
-
+
/*
Get events
*/
if(m_ignore_damage_timer <= 0)
{
u8 damage = event.player_damage.amount;
-
+
if(event.player_damage.send_to_server)
sendDamage(damage);
m_sound->updateSoundPosition(client_id, pos);
}
}
-
+
/*
Handle removed remotely initiated sounds
*/
}
}
// Sync to server
- if(removed_server_ids.size() != 0)
+ if(!removed_server_ids.empty())
{
std::ostringstream os(std::ios_base::binary);
writeU16(os, TOSERVER_REMOVED_SOUNDS);
{
// Silly irrlicht's const-incorrectness
Buffer<char> data_rw(data.c_str(), data.size());
-
+
std::string name;
const char *image_ext[] = {
<<std::endl;
}
+void Client::initLocalMapSaving(const Address &address,
+ const std::string &hostname,
+ bool is_local_server)
+{
+ localdb = NULL;
+
+ if (!g_settings->getBool("enable_local_map_saving") || is_local_server)
+ return;
+
+ const std::string world_path = porting::path_user
+ + DIR_DELIM + "worlds"
+ + DIR_DELIM + "server_"
+ + hostname + "_" + to_string(address.getPort());
+
+ SubgameSpec gamespec;
+
+ if (!getWorldExists(world_path)) {
+ gamespec = findSubgame(g_settings->get("default_game"));
+ if (!gamespec.isValid())
+ gamespec = findSubgame("minimal");
+ } else {
+ gamespec = findWorldSubgame(world_path);
+ }
+
+ if (!gamespec.isValid()) {
+ errorstream << "Couldn't find subgame for local map saving." << std::endl;
+ return;
+ }
+
+ localserver = new Server(world_path, gamespec, false, false);
+ localdb = new Database_SQLite3(&(ServerMap&)localserver->getMap(), world_path);
+ localdb->beginSave();
+ actionstream << "Local map saving started, map will be saved at '" << world_path << "'" << std::endl;
+}
+
void Client::ReceiveAll()
{
DSTACK(__FUNCTION_NAME);
// process
if(porting::getTimeMs() > start_ms + 100)
break;
-
+
try{
Receive();
g_profiler->graphAdd("client_received_packets", 1);
//infostream<<"Client: received command="<<command<<std::endl;
m_packetcounter.add((u16)command);
-
+
/*
If this check is removed, be sure to change the queue
system to know the ids
<<"unsupported ser_fmt_ver"<<std::endl;
return;
}
-
+
m_server_ser_ver = deployed;
// Get player position
playerpos_s16 = readV3S16(&data[2+1]);
v3f playerpos_f = intToFloat(playerpos_s16, BS) - v3f(0, BS/2, 0);
-
+
// Set player position
Player *player = m_env.getLocalPlayer();
assert(player != NULL);
player->setPosition(playerpos_f);
-
+
if(datasize >= 2+1+6+8)
{
// Get map seed
infostream<<"Client: received recommended send interval "
<<m_recommended_send_interval<<std::endl;
}
-
+
// Reply to server
u32 replysize = 2;
SharedBuffer<u8> reply(replysize);
" Skipping incoming command="<<command<<std::endl;
return;
}
-
+
/*
Handle runtime commands
*/
MapNode n;
n.deSerialize(&data[8], ser_version);
-
+
bool remove_metadata = true;
u32 index = 8 + MapNode::serializedLength(ser_version);
if ((datasize >= index+1) && data[index]){
remove_metadata = false;
}
-
+
addNode(p, n, remove_metadata);
}
else if(command == TOCLIENT_BLOCKDATA)
// Ignore too small packet
if(datasize < 8)
return;
-
+
v3s16 p;
p.X = readS16(&data[2]);
p.Y = readS16(&data[4]);
p.Z = readS16(&data[6]);
-
+
std::string datastring((char*)&data[8], datasize-8);
std::istringstream istr(datastring, std::ios_base::binary);
-
+
MapSector *sector;
MapBlock *block;
-
+
v2s16 p2d(p.X, p.Z);
sector = m_env.getMap().emergeSector(p2d);
-
+
assert(sector->getPos() == p2d);
-
+
block = sector->getBlockNoCreateNoEx(p.Y);
if(block)
{
{
if(datasize < 4)
return;
-
+
u16 time_of_day = readU16(&data[2]);
time_of_day = time_of_day % 24000;
float time_speed = 0;
<<" time_diff="<<time_diff<<std::endl;
}
}
-
+
// Update environment
m_env.setTimeOfDay(time_of_day);
m_env.setTimeOfDaySpeed(time_speed);
u8 buf[6];
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
-
+
// Read stuff
is.read((char*) buf, 2);
u16 len = readU16(buf);
-
+
std::wstring message;
for(unsigned int i=0; i<len; i++)
{
is.read((char*)buf, 2);
message += (wchar_t)readU16(buf);
}
-
+
m_chat_queue.push_back(message);
}
else if(command == TOCLIENT_ACTIVE_OBJECT_REMOVE_ADD)
{
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
-
+
bool set_camera_point_target = readU8(is);
v3f camera_point_target = readV3F1000(is);
-
+
ClientEvent event;
event.type = CE_DEATHSCREEN;
event.deathscreen.set_camera_point_target = set_camera_point_target;
std::istringstream is(datastring, std::ios_base::binary);
int num_files = readU16(is);
-
+
infostream<<"Client: Received media announcement: packet size: "
<<datasize<<std::endl;
{
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
-
+
m_privileges.clear();
infostream<<"Client: Privileges updated: ";
u16 num_privileges = readU16(is);
std::istringstream is(datastring, std::ios_base::binary);
std::string name = deSerializeString(is);
-
+
infostream<<"Client: Detached inventory update: \""<<name<<"\""<<std::endl;
Inventory *inv = NULL;
v3f v3fdata;
u32 intdata = 0;
v2s32 v2s32data;
-
+
std::string datastring((char *)&data[2], datasize - 2);
std::istringstream is(datastring, std::ios_base::binary);
u32 id = readU32(is);
u8 stat = (HudElementStat)readU8(is);
-
+
if (stat == HUD_STAT_POS || stat == HUD_STAT_SCALE ||
stat == HUD_STAT_ALIGN || stat == HUD_STAT_OFFSET)
v2fdata = readV2F1000(is);
v2s32data = readV2S32(is);
else
intdata = readU32(is);
-
+
ClientEvent event;
event.type = CE_HUDCHANGE;
event.hudchange.id = id;
u32 flags = readU32(is);
u32 mask = readU32(is);
-
+
player->hud_flags &= ~mask;
player->hud_flags |= flags;
}
// Send as reliable
Send(0, data, true);
}
-
+
void Client::sendInventoryFields(const std::string &formname,
const std::map<std::string, std::string> &fields)
{
{
std::ostringstream os(std::ios_base::binary);
u8 buf[12];
-
+
// Write command
writeU16(buf, TOSERVER_INVENTORY_ACTION);
os.write((char*)buf, 2);
a->serialize(os);
-
+
// Make data buffer
std::string s = os.str();
SharedBuffer<u8> data((u8*)s.c_str(), s.size());
{
std::ostringstream os(std::ios_base::binary);
u8 buf[12];
-
+
// Write command
writeU16(buf, TOSERVER_CHAT_MESSAGE);
os.write((char*)buf, 2);
-
+
// Write length
size_t messagesize = message.size();
if (messagesize > 0xFFFF) {
}
writeU16(buf, (u16) messagesize);
os.write((char*)buf, 2);
-
+
// Write string
for(unsigned int i=0; i<message.size(); i++)
{
writeU16(buf, w);
os.write((char*)buf, 2);
}
-
+
// Make data buffer
std::string s = os.str();
SharedBuffer<u8> data((u8*)s.c_str(), s.size());
//JMutexAutoLock 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;
// Check that an existing peer_id is the same as the connection's
assert(myplayer->peer_id == our_peer_id);
-
+
v3f pf = myplayer->getPosition();
v3f sf = myplayer->getSpeed();
s32 pitch = myplayer->getPitch() * 100;
catch(InvalidPositionException &e)
{
}
-
+
for(std::map<v3s16, MapBlock * >::iterator
i = modified_blocks.begin();
i != modified_blocks.end(); ++i)
{
- addUpdateMeshTask(i->first, false, false);
+ addUpdateMeshTaskWithEdge(i->first, false, true);
}
- // add urgent task to update the modified node
- addUpdateMeshTaskForNode(p, false, true);
}
void Client::addNode(v3s16 p, MapNode n, bool remove_metadata)
}
catch(InvalidPositionException &e)
{}
-
+
for(std::map<v3s16, MapBlock * >::iterator
i = modified_blocks.begin();
i != modified_blocks.end(); ++i)
{
- addUpdateMeshTask(i->first, false, false);
+ addUpdateMeshTaskWithEdge(i->first, false, true);
}
}
-
+
void Client::setPlayerControl(PlayerControl &control)
{
LocalPlayer *player = m_env.getLocalPlayer();
std::vector<DistanceSortedActiveObject> objects;
m_env.getActiveObjects(from_pos_f_on_map, max_d, objects);
-
+
// Sort them.
// After this, the closest object is the first in the array.
std::sort(objects.begin(), objects.end());
for(unsigned int i=0; i<objects.size(); i++)
{
ClientActiveObject *obj = objects[i].obj;
-
+
core::aabbox3d<f32> *selection_box = obj->getSelectionBox();
if(selection_box == NULL)
continue;
return m_crack_level;
}
-void Client::setHighlighted(v3s16 pos, bool show_hud)
+void Client::setHighlighted(v3s16 pos, bool show_highlighted)
{
- m_show_hud = show_hud;
+ m_show_highlighted = show_highlighted;
v3s16 old_highlighted_pos = m_highlighted_pos;
m_highlighted_pos = pos;
addUpdateMeshTaskForNode(old_highlighted_pos, false, true);
// Debug: 1-6ms, avg=2ms
data->fill(b);
data->setCrack(m_crack_level, m_crack_pos);
- data->setHighlighted(m_highlighted_pos, m_show_hud);
- data->setSmoothLighting(g_settings->getBool("smooth_lighting"));
+ data->setHighlighted(m_highlighted_pos, m_show_highlighted);
+ data->setSmoothLighting(m_cache_smooth_lighting);
}
// Add task to queue
void Client::addUpdateMeshTaskWithEdge(v3s16 blockpos, bool ack_to_server, bool urgent)
{
try{
- v3s16 p = blockpos + v3s16(0,0,0);
- //MapBlock *b = m_env.getMap().getBlockNoCreate(p);
- addUpdateMeshTask(p, ack_to_server, urgent);
+ addUpdateMeshTask(blockpos, ack_to_server, urgent);
}
catch(InvalidPositionException &e){}
v3s16 blockpos_relative = blockpos * MAP_BLOCKSIZE;
try{
- v3s16 p = blockpos + v3s16(0,0,0);
- addUpdateMeshTask(p, ack_to_server, urgent);
+ addUpdateMeshTask(blockpos, ack_to_server, urgent);
}
catch(InvalidPositionException &e){}
assert(m_itemdef_received);
assert(m_nodedef_received);
assert(mediaReceived());
-
+
+ wchar_t* text = wgettext("Loading textures...");
+
// Rebuild inherited images and recreate textures
infostream<<"- Rebuilding images and textures"<<std::endl;
+ draw_load_screen(text,device, guienv, 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, 75);
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, 80);
m_nodedef->updateAliases(m_itemdef);
+ m_nodedef->setNodeRegistrationStatus(true);
+ m_nodedef->runNodeResolverCallbacks();
+ delete[] text;
// Update node textures and assign shaders to each tile
infostream<<"- Updating node textures"<<std::endl;
if(g_settings->getBool("preload_item_visuals"))
{
verbosestream<<"Updating item textures and meshes"<<std::endl;
- wchar_t* text = wgettext("Item textures...");
+ text = wgettext("Item textures...");
draw_load_screen(text, device, guienv, 0, 0);
std::set<std::string> names = m_itemdef->getAll();
size_t size = names.size();
size_t count = 0;
int percent = 0;
for(std::set<std::string>::const_iterator
- i = names.begin(); i != names.end(); ++i){
+ i = names.begin(); i != names.end(); ++i)
+ {
// Asking for these caches the result
m_itemdef->getInventoryTexture(*i, this);
m_itemdef->getWieldMesh(*i, this);
count++;
- percent = count*100/size;
- if (count%50 == 0) // only update every 50 item
- draw_load_screen(text, device, guienv, 0, percent);
+ percent = (count * 100 / size * 0.2) + 80;
+ draw_load_screen(text, device, guienv, 0, percent);
}
delete[] text;
}
// Start mesh update thread after setting up content definitions
infostream<<"- Starting mesh update thread"<<std::endl;
m_mesh_update_thread.Start();
-
+
m_state = LC_Ready;
sendReady();
+ text = wgettext("Done!");
+ draw_load_screen(text, device, guienv, 0, 100);
infostream<<"Client::afterContentReceived() done"<<std::endl;
+ delete[] text;
}
float Client::getRTT(void)
snprintf(filename, sizeof(filename), "%s" DIR_DELIM "screenshot_%u.png",
g_settings->get("screenshot_path").c_str(),
device->getTimer()->getRealTime());
- std::stringstream sstr;
+ std::ostringstream sstr;
if (driver->writeImageToFile(image, filename)) {
sstr << "Saved screenshot to '" << filename << "'";
} else {
sstr << "Failed to save screenshot '" << filename << "'";
}
m_chat_queue.push_back(narrow_to_wide(sstr.str()));
- infostream << sstr << std::endl;
+ infostream << sstr.str() << std::endl;
image->drop();
}
raw_image->drop();
return m_event;
}
+ParticleManager* Client::getParticleManager()
+{
+ return &m_particle_manager;
+}
+
scene::IAnimatedMesh* Client::getMesh(const std::string &filename)
{
std::map<std::string, std::string>::const_iterator i =
projects / minetest.git / blobdiff