#include "log.h"
#include "nodemetadata.h"
#include "nodedef.h"
-#include "tooldef.h"
-#include "craftitemdef.h"
+#include "itemdef.h"
#include <IFileSystem.h>
#include "sha1.h"
#include "base64.h"
std::string password,
MapDrawControl &control,
IWritableTextureSource *tsrc,
- IWritableToolDefManager *tooldef,
- IWritableNodeDefManager *nodedef,
- IWritableCraftItemDefManager *craftitemdef
+ IWritableItemDefManager *itemdef,
+ IWritableNodeDefManager *nodedef
):
m_tsrc(tsrc),
- m_tooldef(tooldef),
+ m_itemdef(itemdef),
m_nodedef(nodedef),
- m_craftitemdef(craftitemdef),
m_mesh_update_thread(this),
m_env(
new ClientMap(this, this, control,
m_server_ser_ver(SER_FMT_VER_INVALID),
m_playeritem(0),
m_inventory_updated(false),
+ m_inventory_from_server(NULL),
+ m_inventory_from_server_age(0.0),
m_time_of_day(0),
m_map_seed(0),
m_password(password),
m_access_denied(false),
m_texture_receive_progress(0),
m_textures_received(false),
- m_tooldef_received(false),
- m_nodedef_received(false),
- m_craftitemdef_received(false)
+ m_itemdef_received(false),
+ m_nodedef_received(false)
{
m_packetcounter_timer = 0.0;
//m_delete_unused_sectors_timer = 0.0;
else
infostream<<"Not building texture atlas."<<std::endl;
- // Update node textures
- m_nodedef->updateTextures(m_tsrc);
-
- // Start threads after setting up content definitions
- m_mesh_update_thread.Start();
-
/*
Add local player
*/
player->updateName(playername);
m_env.addPlayer(player);
-
- // Initialize player in the inventory context
- m_inventory_context.current_player = player;
}
}
m_mesh_update_thread.setRun(false);
while(m_mesh_update_thread.IsRunning())
sleep_ms(100);
+
+ delete m_inventory_from_server;
}
void Client::connect(Address address)
}
}
}
+
+ /*
+ If the server didn't update the inventory in a while, revert
+ the local inventory (so the player notices the lag problem
+ and knows something is wrong).
+ */
+ if(m_inventory_from_server)
+ {
+ float interval = 10.0;
+ float count_before = floor(m_inventory_from_server_age / interval);
+
+ m_inventory_from_server_age += dtime;
+
+ float count_after = floor(m_inventory_from_server_age / interval);
+
+ if(count_after != count_before)
+ {
+ // Do this every <interval> seconds after TOCLIENT_INVENTORY
+ // Reset the locally changed inventory to the authoritative inventory
+ Player *player = m_env.getLocalPlayer();
+ player->inventory = *m_inventory_from_server;
+ m_inventory_updated = true;
+ }
+ }
}
// Virtual methods from con::PeerHandler
Update an existing block
*/
//infostream<<"Updating"<<std::endl;
- block->deSerialize(istr, ser_version);
+ block->deSerialize(istr, ser_version, false);
}
else
{
*/
//infostream<<"Creating new"<<std::endl;
block = new MapBlock(&m_env.getMap(), p, this);
- block->deSerialize(istr, ser_version);
+ block->deSerialize(istr, ser_version, false);
sector->insertBlock(block);
}
//t4.stop();
//TimeTaker t1("inventory.deSerialize()", m_device);
- player->inventory.deSerialize(is, this);
+ player->inventory.deSerialize(is);
//t1.stop();
m_inventory_updated = true;
+ delete m_inventory_from_server;
+ m_inventory_from_server = new Inventory(player->inventory);
+ m_inventory_from_server_age = 0.0;
+
//infostream<<"Client got player inventory:"<<std::endl;
//player->inventory.print(infostream);
}
} else {
InventoryList *inv = player->inventory.getList("main");
std::string itemstring(deSerializeString(is));
- if (itemstring.empty()) {
- inv->deleteItem(0);
- infostream
- <<"Client: empty player item for peer "
- << peer_id << std::endl;
- } else {
- std::istringstream iss(itemstring);
- delete inv->changeItem(0,
- InventoryItem::deSerialize(iss, this));
- infostream<<"Client: player item for peer " << peer_id << ": ";
- player->getWieldItem()->serialize(infostream);
- infostream<<std::endl;
+ ItemStack item;
+ item.deSerialize(itemstring, m_itemdef);
+ inv->changeItem(0, item);
+ if(itemstring.empty())
+ {
+ infostream<<"Client: empty player item for peer "
+ <<peer_id<<std::endl;
+ }
+ else
+ {
+ infostream<<"Client: player item for peer "
+ <<peer_id<<": "<<itemstring<<std::endl;
}
}
}
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
-
- // Stop threads while updating content definitions
- m_mesh_update_thread.setRun(false);
- // Process the remaining TextureSource queue to let MeshUpdateThread
- // get it's remaining textures and thus let it stop
- while(m_mesh_update_thread.IsRunning()){
- m_tsrc->processQueue();
- }
+ // Mesh update thread must be stopped while
+ // updating content definitions
+ assert(!m_mesh_update_thread.IsRunning());
int num_textures = readU16(is);
//read texture from cache
std::string name = deSerializeString(is);
std::string sha1_texture = deSerializeString(is);
+
+ // if name contains illegal characters, ignore the texture
+ if(!string_allowed(name, TEXTURENAME_ALLOWED_CHARS)){
+ errorstream<<"Client: ignoring illegal texture name "
+ <<"sent by server: \""<<name<<"\""<<std::endl;
+ continue;
+ }
std::string tpath = getTextureCacheDir() + DIR_DELIM + name;
// Read data
<<name << ": server ->"<<sha1_texture <<" client -> "<<digest_string<<std::endl;
}
- delete(digest);
+ free(digest);
}
}
}
}
- // Resume threads
- m_mesh_update_thread.setRun(true);
- m_mesh_update_thread.Start();
ClientEvent event;
event.type = CE_TEXTURES_UPDATED;
for each texture {
u16 length of name
string name
- u16 length of path
- string path
}
*/
std::ostringstream os(std::ios_base::binary);
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
- // Stop threads while updating content definitions
- m_mesh_update_thread.setRun(false);
- // Process the remaining TextureSource queue to let MeshUpdateThread
- // get it's remaining textures and thus let it stop
- while(m_mesh_update_thread.IsRunning()){
- m_tsrc->processQueue();
- }
-
+ // Mesh update thread must be stopped while
+ // updating content definitions
+ assert(!m_mesh_update_thread.IsRunning());
+
/*
u16 command
u16 total number of texture bunches
for(int i=0; i<num_textures; i++){
std::string name = deSerializeString(is);
std::string data = deSerializeLongString(is);
+
+ // if name contains illegal characters, ignore the texture
+ if(!string_allowed(name, TEXTURENAME_ALLOWED_CHARS)){
+ errorstream<<"Client: ignoring illegal texture name "
+ <<"sent by server: \""<<name<<"\""<<std::endl;
+ continue;
+ }
+
// Silly irrlicht's const-incorrectness
Buffer<char> data_rw(data.c_str(), data.size());
// Create an irrlicht memory file
img->drop();
rfile->drop();
}
-
- if(m_nodedef_received && m_textures_received){
- // Rebuild inherited images and recreate textures
- m_tsrc->rebuildImagesAndTextures();
-
- // Update texture atlas
- if(g_settings->getBool("enable_texture_atlas"))
- m_tsrc->buildMainAtlas(this);
-
- // Update node textures
- m_nodedef->updateTextures(m_tsrc);
- }
-
- // Resume threads
- m_mesh_update_thread.setRun(true);
- m_mesh_update_thread.Start();
ClientEvent event;
event.type = CE_TEXTURES_UPDATED;
}
else if(command == TOCLIENT_TOOLDEF)
{
- infostream<<"Client: Received tool definitions: packet size: "
- <<datasize<<std::endl;
-
- std::string datastring((char*)&data[2], datasize-2);
- std::istringstream is(datastring, std::ios_base::binary);
-
- m_tooldef_received = true;
-
- // Stop threads while updating content definitions
- m_mesh_update_thread.setRun(false);
- // Process the remaining TextureSource queue to let MeshUpdateThread
- // get it's remaining textures and thus let it stop
- while(m_mesh_update_thread.IsRunning()){
- m_tsrc->processQueue();
- }
-
- std::istringstream tmp_is(deSerializeLongString(is), std::ios::binary);
- m_tooldef->deSerialize(tmp_is);
-
- // Resume threads
- m_mesh_update_thread.setRun(true);
- m_mesh_update_thread.Start();
+ infostream<<"Client: WARNING: Ignoring TOCLIENT_TOOLDEF"<<std::endl;
}
else if(command == TOCLIENT_NODEDEF)
{
infostream<<"Client: Received node definitions: packet size: "
<<datasize<<std::endl;
+ // Mesh update thread must be stopped while
+ // updating content definitions
+ assert(!m_mesh_update_thread.IsRunning());
+
+ // Decompress node definitions
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
-
- m_nodedef_received = true;
-
- // Stop threads while updating content definitions
- m_mesh_update_thread.stop();
-
std::istringstream tmp_is(deSerializeLongString(is), std::ios::binary);
- m_nodedef->deSerialize(tmp_is, this);
-
- if(m_textures_received){
- // Update texture atlas
- if(g_settings->getBool("enable_texture_atlas"))
- m_tsrc->buildMainAtlas(this);
-
- // Update node textures
- m_nodedef->updateTextures(m_tsrc);
- }
+ std::ostringstream tmp_os;
+ decompressZlib(tmp_is, tmp_os);
- // Resume threads
- m_mesh_update_thread.setRun(true);
- m_mesh_update_thread.Start();
+ // Deserialize node definitions
+ std::istringstream tmp_is2(tmp_os.str());
+ m_nodedef->deSerialize(tmp_is2);
+ m_nodedef_received = true;
}
else if(command == TOCLIENT_CRAFTITEMDEF)
{
- infostream<<"Client: Received CraftItem definitions: packet size: "
+ infostream<<"Client: WARNING: Ignoring TOCLIENT_CRAFTITEMDEF"<<std::endl;
+ }
+ else if(command == TOCLIENT_ITEMDEF)
+ {
+ infostream<<"Client: Received item definitions: packet size: "
<<datasize<<std::endl;
+ // Mesh update thread must be stopped while
+ // updating content definitions
+ assert(!m_mesh_update_thread.IsRunning());
+
+ // Decompress item definitions
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
-
- m_craftitemdef_received = true;
-
- // Stop threads while updating content definitions
- m_mesh_update_thread.setRun(false);
- // Process the remaining TextureSource queue to let MeshUpdateThread
- // get it's remaining textures and thus let it stop
- while(m_mesh_update_thread.IsRunning()){
- m_tsrc->processQueue();
- }
-
std::istringstream tmp_is(deSerializeLongString(is), std::ios::binary);
- m_craftitemdef->deSerialize(tmp_is);
-
- // Resume threads
- m_mesh_update_thread.setRun(true);
- m_mesh_update_thread.Start();
+ std::ostringstream tmp_os;
+ decompressZlib(tmp_is, tmp_os);
+
+ // Deserialize node definitions
+ std::istringstream tmp_is2(tmp_os.str());
+ m_itemdef->deSerialize(tmp_is2);
+ m_itemdef_received = true;
}
else
{
try
{
//TimeTaker timer3("Client::addNode(): addNodeAndUpdate");
- std::string st = std::string("");
- m_env.getMap().addNodeAndUpdate(p, n, modified_blocks, st);
+ m_env.getMap().addNodeAndUpdate(p, n, modified_blocks);
}
catch(InvalidPositionException &e)
{}
//JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
m_playeritem = item;
m_inventory_updated = true;
-
- LocalPlayer *player = m_env.getLocalPlayer();
- assert(player != NULL);
- player->wieldItem(item);
-
sendPlayerItem(item);
}
dst = player->inventory;
}
-InventoryContext *Client::getInventoryContext()
-{
- return &m_inventory_context;
-}
-
Inventory* Client::getInventory(const InventoryLocation &loc)
{
switch(loc.type){
case InventoryLocation::UNDEFINED:
{}
break;
+ case InventoryLocation::CURRENT_PLAYER:
+ {
+ Player *player = m_env.getLocalPlayer();
+ assert(player != NULL);
+ return &player->inventory;
+ }
+ break;
case InventoryLocation::PLAYER:
{
Player *player = m_env.getPlayer(loc.name.c_str());
}
return NULL;
}
-#if 0
-Inventory* Client::getInventory(InventoryContext *c, std::string id)
-{
- if(id == "current_player")
- {
- assert(c->current_player);
- return &(c->current_player->inventory);
- }
-
- Strfnd fn(id);
- std::string id0 = fn.next(":");
-
- if(id0 == "nodemeta")
- {
- v3s16 p;
- p.X = stoi(fn.next(","));
- p.Y = stoi(fn.next(","));
- p.Z = stoi(fn.next(","));
- NodeMetadata* meta = getNodeMetadata(p);
- if(meta)
- return meta->getInventory();
- infostream<<"nodemeta at ("<<p.X<<","<<p.Y<<","<<p.Z<<"): "
- <<"no metadata found"<<std::endl;
- return NULL;
- }
-
- infostream<<__FUNCTION_NAME<<": unknown id "<<id<<std::endl;
- return NULL;
-}
-#endif
void Client::inventoryAction(InventoryAction *a)
{
+ /*
+ Send it to the server
+ */
sendInventoryAction(a);
+
+ /*
+ Predict some local inventory changes
+ */
+ a->clientApply(this, this);
}
ClientActiveObject * Client::getSelectedActiveObject(
return m_client_event_queue.pop_front();
}
+void Client::afterContentReceived()
+{
+ assert(m_itemdef_received);
+ assert(m_nodedef_received);
+ assert(m_textures_received);
+
+ // Rebuild inherited images and recreate textures
+ m_tsrc->rebuildImagesAndTextures();
+
+ // Update texture atlas
+ if(g_settings->getBool("enable_texture_atlas"))
+ m_tsrc->buildMainAtlas(this);
+
+ // Update node aliases
+ m_nodedef->updateAliases(m_itemdef);
+
+ // Update node textures
+ m_nodedef->updateTextures(m_tsrc);
+
+ // Update item textures and meshes
+ m_itemdef->updateTexturesAndMeshes(this);
+
+ // Start mesh update thread after setting up content definitions
+ m_mesh_update_thread.Start();
+}
+
float Client::getRTT(void)
{
try{
// IGameDef interface
// Under envlock
-IToolDefManager* Client::getToolDefManager()
+IItemDefManager* Client::getItemDefManager()
{
- return m_tooldef;
+ return m_itemdef;
}
INodeDefManager* Client::getNodeDefManager()
{
return NULL;
//return m_craftdef;
}
-ICraftItemDefManager* Client::getCraftItemDefManager()
-{
- return m_craftitemdef;
-}
ITextureSource* Client::getTextureSource()
{
return m_tsrc;
projects / minetest.git / blobdiff