void MapBlock::serialize(std::ostream &os, u8 version, bool disk) { if(!ser_ver_supported(version)) throw VersionMismatchException("ERROR: MapBlock format not supported"); if(data == NULL) { throw SerializationError("ERROR: Not writing dummy block."); } // Can't do this anymore; we have 16-bit dynamically allocated node IDs // in memory; conversion just won't work in this direction. if(version < 24) throw SerializationError("MapBlock::serialize: serialization to " "version < 24 not possible"); // First byte u8 flags = 0; if(is_underground) flags |= 0x01; if(getDayNightDiff()) flags |= 0x02; if(m_lighting_expired) flags |= 0x04; if(m_generated == false) flags |= 0x08; writeU8(os, flags); /* Bulk node data */ NameIdMapping nimap; u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; if(disk) { MapNode *tmp_nodes = new MapNode[nodecount]; for(u32 i=0; i<nodecount; i++) tmp_nodes[i] = data[i]; getBlockNodeIdMapping(&nimap, tmp_nodes, m_gamedef->ndef()); u8 content_width = 2; u8 params_width = 2; writeU8(os, content_width); writeU8(os, params_width); MapNode::serializeBulk(os, version, tmp_nodes, nodecount, content_width, params_width, true); delete[] tmp_nodes; } else { u8 content_width = 2; u8 params_width = 2; writeU8(os, content_width); writeU8(os, params_width); MapNode::serializeBulk(os, version, data, nodecount, content_width, params_width, true); } /* Node metadata */ std::ostringstream oss(std::ios_base::binary); m_node_metadata.serialize(oss); compressZlib(oss.str(), os); /* Data that goes to disk, but not the network */ if(disk) { if(version <= 24){ // Node timers m_node_timers.serialize(os, version); } // Static objects m_static_objects.serialize(os); // Timestamp writeU32(os, getTimestamp()); // Write block-specific node definition id mapping nimap.serialize(os); if(version >= 25){ // Node timers m_node_timers.serialize(os, version); } } }
void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const { if(protocol_version < 24){ //serializeOld(os, protocol_version); return; } writeU8(os, 7); // version os<<serializeString(name); writeU16(os, groups.size()); for(ItemGroupList::const_iterator i = groups.begin(); i != groups.end(); ++i){ os<<serializeString(i->first); writeS16(os, i->second); } writeU8(os, drawtype); writeF1000(os, visual_scale); writeU8(os, 6); for(u32 i = 0; i < 6; i++) tiledef[i].serialize(os, protocol_version); writeU8(os, CF_SPECIAL_COUNT); for(u32 i = 0; i < CF_SPECIAL_COUNT; i++){ tiledef_special[i].serialize(os, protocol_version); } writeU8(os, alpha); writeU8(os, post_effect_color.getAlpha()); writeU8(os, post_effect_color.getRed()); writeU8(os, post_effect_color.getGreen()); writeU8(os, post_effect_color.getBlue()); writeU8(os, param_type); writeU8(os, param_type_2); writeU8(os, is_ground_content); writeU8(os, light_propagates); writeU8(os, sunlight_propagates); writeU8(os, walkable); writeU8(os, pointable); writeU8(os, diggable); writeU8(os, climbable); writeU8(os, buildable_to); os<<serializeString(""); // legacy: used to be metadata_name writeU8(os, liquid_type); os<<serializeString(liquid_alternative_flowing); os<<serializeString(liquid_alternative_source); writeU8(os, liquid_viscosity); writeU8(os, liquid_renewable); writeU8(os, light_source); writeU32(os, damage_per_second); node_box.serialize(os, protocol_version); selection_box.serialize(os, protocol_version); writeU8(os, legacy_facedir_simple); writeU8(os, legacy_wallmounted); serializeSimpleSoundSpec(sound_footstep, os); serializeSimpleSoundSpec(sound_dig, os); serializeSimpleSoundSpec(sound_dug, os); writeU8(os, rightclickable); writeU8(os, drowning); writeU8(os, leveled); writeU8(os, liquid_range); writeU8(os, waving); // Stuff below should be moved to correct place in a version that otherwise changes // the protocol version os<<serializeString(mesh); collision_box.serialize(os, protocol_version); }
void ContentFeatures::serialize(std::ostream &os) { writeU8(os, 3); // version os<<serializeString(name); writeU16(os, groups.size()); for(ItemGroupList::const_iterator i = groups.begin(); i != groups.end(); i++) { os<<serializeString(i->first); writeS16(os, i->second); } writeU8(os, drawtype); writeF1000(os, visual_scale); writeU8(os, 6); for(u32 i=0; i<6; i++) os<<serializeString(tname_tiles[i]); writeU8(os, CF_SPECIAL_COUNT); for(u32 i=0; i<CF_SPECIAL_COUNT; i++) { mspec_special[i].serialize(os); } writeU8(os, alpha); writeU8(os, post_effect_color.getAlpha()); writeU8(os, post_effect_color.getRed()); writeU8(os, post_effect_color.getGreen()); writeU8(os, post_effect_color.getBlue()); writeU8(os, param_type); writeU8(os, param_type_2); writeU8(os, is_ground_content); writeU8(os, light_propagates); writeU8(os, sunlight_propagates); writeU8(os, walkable); writeU8(os, pointable); writeU8(os, diggable); writeU8(os, climbable); writeU8(os, buildable_to); os<<serializeString(metadata_name); writeU8(os, liquid_type); os<<serializeString(liquid_alternative_flowing); os<<serializeString(liquid_alternative_source); writeU8(os, liquid_viscosity); writeU8(os, light_source); writeU32(os, damage_per_second); selection_box.serialize(os); writeU8(os, legacy_facedir_simple); writeU8(os, legacy_wallmounted); serializeSimpleSoundSpec(sound_footstep, os); serializeSimpleSoundSpec(sound_dig, os); serializeSimpleSoundSpec(sound_dug, os); }
void MaterialSpec::serialize(std::ostream &os) const { os<<serializeString(tname); writeU8(os, backface_culling); }
void wasm::writeLimits(raw_ostream &OS, const WasmLimits &Limits) { writeU8(OS, Limits.Flags, "limits flags"); writeUleb128(OS, Limits.Initial, "limits initial"); if (Limits.Flags & WASM_LIMITS_FLAG_HAS_MAX) writeUleb128(OS, Limits.Maximum, "limits max"); }
//// Serialization of old ContentFeatures formats void ContentFeatures::serializeOld(std::ostream &os, u16 protocol_version) const { if (protocol_version == 13) { writeU8(os, 5); // version os<<serializeString(name); writeU16(os, groups.size()); for (ItemGroupList::const_iterator i = groups.begin(); i != groups.end(); ++i) { os<<serializeString(i->first); writeS16(os, i->second); } writeU8(os, drawtype); writeF1000(os, visual_scale); writeU8(os, 6); for (u32 i = 0; i < 6; i++) tiledef[i].serialize(os, protocol_version); //CF_SPECIAL_COUNT = 2 before cf ver. 7 and protocol ver. 24 writeU8(os, 2); for (u32 i = 0; i < 2; i++) tiledef_special[i].serialize(os, protocol_version); writeU8(os, alpha); writeU8(os, post_effect_color.getAlpha()); writeU8(os, post_effect_color.getRed()); writeU8(os, post_effect_color.getGreen()); writeU8(os, post_effect_color.getBlue()); writeU8(os, param_type); writeU8(os, param_type_2); writeU8(os, is_ground_content); writeU8(os, light_propagates); writeU8(os, sunlight_propagates); writeU8(os, walkable); writeU8(os, pointable); writeU8(os, diggable); writeU8(os, climbable); writeU8(os, buildable_to); os<<serializeString(""); // legacy: used to be metadata_name writeU8(os, liquid_type); os<<serializeString(liquid_alternative_flowing); os<<serializeString(liquid_alternative_source); writeU8(os, liquid_viscosity); writeU8(os, light_source); writeU32(os, damage_per_second); node_box.serialize(os, protocol_version); selection_box.serialize(os, protocol_version); writeU8(os, legacy_facedir_simple); writeU8(os, legacy_wallmounted); serializeSimpleSoundSpec(sound_footstep, os); serializeSimpleSoundSpec(sound_dig, os); serializeSimpleSoundSpec(sound_dug, os); } else if (protocol_version > 13 && protocol_version < 24) { writeU8(os, 6); // version os<<serializeString(name); writeU16(os, groups.size()); for (ItemGroupList::const_iterator i = groups.begin(); i != groups.end(); ++i) { os<<serializeString(i->first); writeS16(os, i->second); } writeU8(os, drawtype); writeF1000(os, visual_scale); writeU8(os, 6); for (u32 i = 0; i < 6; i++) tiledef[i].serialize(os, protocol_version); //CF_SPECIAL_COUNT = 2 before cf ver. 7 and protocol ver. 24 writeU8(os, 2); for (u32 i = 0; i < 2; i++) tiledef_special[i].serialize(os, protocol_version); writeU8(os, alpha); writeU8(os, post_effect_color.getAlpha()); writeU8(os, post_effect_color.getRed()); writeU8(os, post_effect_color.getGreen()); writeU8(os, post_effect_color.getBlue()); writeU8(os, param_type); writeU8(os, param_type_2); writeU8(os, is_ground_content); writeU8(os, light_propagates); writeU8(os, sunlight_propagates); writeU8(os, walkable); writeU8(os, pointable); writeU8(os, diggable); writeU8(os, climbable); writeU8(os, buildable_to); os<<serializeString(""); // legacy: used to be metadata_name writeU8(os, liquid_type); os<<serializeString(liquid_alternative_flowing); os<<serializeString(liquid_alternative_source); writeU8(os, liquid_viscosity); writeU8(os, liquid_renewable); writeU8(os, light_source); writeU32(os, damage_per_second); node_box.serialize(os, protocol_version); selection_box.serialize(os, protocol_version); writeU8(os, legacy_facedir_simple); writeU8(os, legacy_wallmounted); serializeSimpleSoundSpec(sound_footstep, os); serializeSimpleSoundSpec(sound_dig, os); serializeSimpleSoundSpec(sound_dug, os); writeU8(os, rightclickable); writeU8(os, drowning); writeU8(os, leveled); writeU8(os, liquid_range); } else throw SerializationError("ContentFeatures::serialize(): " "Unsupported version requested"); }
void wasm::writeTableType(raw_ostream &OS, const llvm::wasm::WasmTable &Type) { writeU8(OS, WASM_TYPE_FUNCREF, "table type"); writeLimits(OS, Type.Limits); }
void wasm::writeValueType(raw_ostream &OS, ValType Type, const Twine &Msg) { writeU8(OS, static_cast<uint8_t>(Type), Msg + "[type: " + toString(Type) + "]"); }
int writeU16( FILE *f, u16 w ) { writeU8(f,w); writeU8(f,w>>8); }
void wasm::writeGlobalType(raw_ostream &OS, const WasmGlobalType &Type) { // TODO: Update WasmGlobalType to use ValType and remove this cast. writeValueType(OS, ValType(Type.Type), "global type"); writeU8(OS, Type.Mutable, "global mutable"); }
void CraftDefinition::serialize(std::ostream &os) const { writeU8(os, 1); // version os<<serializeString(getName()); serializeBody(os); }
void MapBlock::serialize(std::ostream &os, u8 version, bool disk) { if(!ser_ver_supported(version)) throw VersionMismatchException("ERROR: MapBlock format not supported"); if(data == NULL) { throw SerializationError("ERROR: Not writing dummy block."); } FATAL_ERROR_IF(version < SER_FMT_CLIENT_VER_LOWEST, "Serialize version error"); // First byte u8 flags = 0; if(is_underground) flags |= 0x01; if(getDayNightDiff()) flags |= 0x02; if(m_lighting_expired) flags |= 0x04; if(m_generated == false) flags |= 0x08; writeU8(os, flags); /* Bulk node data */ NameIdMapping nimap; if(disk) { MapNode *tmp_nodes = new MapNode[nodecount]; for(u32 i=0; i<nodecount; i++) tmp_nodes[i] = data[i]; getBlockNodeIdMapping(&nimap, tmp_nodes, m_gamedef->ndef()); u8 content_width = 2; u8 params_width = 2; writeU8(os, content_width); writeU8(os, params_width); MapNode::serializeBulk(os, version, tmp_nodes, nodecount, content_width, params_width, true); delete[] tmp_nodes; } else { u8 content_width = 2; u8 params_width = 2; writeU8(os, content_width); writeU8(os, params_width); MapNode::serializeBulk(os, version, data, nodecount, content_width, params_width, true); } /* Node metadata */ std::ostringstream oss(std::ios_base::binary); m_node_metadata.serialize(oss); compressZlib(oss.str(), os); /* Data that goes to disk, but not the network */ if(disk) { if(version <= 24){ // Node timers m_node_timers.serialize(os, version); } // Static objects m_static_objects.serialize(os); // Timestamp writeU32(os, getTimestamp()); // Write block-specific node definition id mapping nimap.serialize(os); if(version >= 25){ // Node timers m_node_timers.serialize(os, version); } } }
void ContentFeatures::serialize(std::ostream &os, u16 protocol_version) const { const u8 version = CONTENTFEATURES_VERSION; writeU8(os, version); // general os << serializeString(name); writeU16(os, groups.size()); for (const auto &group : groups) { os << serializeString(group.first); writeS16(os, group.second); } writeU8(os, param_type); writeU8(os, param_type_2); // visual writeU8(os, drawtype); os << serializeString(mesh); writeF32(os, visual_scale); writeU8(os, 6); for (const TileDef &td : tiledef) td.serialize(os, protocol_version); for (const TileDef &td : tiledef_overlay) td.serialize(os, protocol_version); writeU8(os, CF_SPECIAL_COUNT); for (const TileDef &td : tiledef_special) { td.serialize(os, protocol_version); } writeU8(os, alpha); writeU8(os, color.getRed()); writeU8(os, color.getGreen()); writeU8(os, color.getBlue()); os << serializeString(palette_name); writeU8(os, waving); writeU8(os, connect_sides); writeU16(os, connects_to_ids.size()); for (u16 connects_to_id : connects_to_ids) writeU16(os, connects_to_id); writeARGB8(os, post_effect_color); writeU8(os, leveled); // lighting writeU8(os, light_propagates); writeU8(os, sunlight_propagates); writeU8(os, light_source); // map generation writeU8(os, is_ground_content); // interaction writeU8(os, walkable); writeU8(os, pointable); writeU8(os, diggable); writeU8(os, climbable); writeU8(os, buildable_to); writeU8(os, rightclickable); writeU32(os, damage_per_second); // liquid writeU8(os, liquid_type); os << serializeString(liquid_alternative_flowing); os << serializeString(liquid_alternative_source); writeU8(os, liquid_viscosity); writeU8(os, liquid_renewable); writeU8(os, liquid_range); writeU8(os, drowning); writeU8(os, floodable); // node boxes node_box.serialize(os, protocol_version); selection_box.serialize(os, protocol_version); collision_box.serialize(os, protocol_version); // sound sound_footstep.serialize(os, version); sound_dig.serialize(os, version); sound_dug.serialize(os, version); // legacy writeU8(os, legacy_facedir_simple); writeU8(os, legacy_wallmounted); os << serializeString(node_dig_prediction); }
void Client::step(float dtime) { DSTACK(__FUNCTION_NAME); // Limit a bit 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; //infostream<<"Client steps "<<dtime<<std::endl; { //TimeTaker timer("ReceiveAll()", m_device); // 0ms ReceiveAll(); } { //TimeTaker timer("m_con_mutex + m_con.RunTimeouts()", m_device); // 0ms //JMutexAutoLock lock(m_con_mutex); //bulk comment-out m_con.RunTimeouts(dtime); } /* Packet counter */ { float &counter = m_packetcounter_timer; counter -= dtime; if(counter <= 0.0) { counter = 20.0; infostream<<"Client packetcounter (20s):"<<std::endl; m_packetcounter.print(infostream); m_packetcounter.clear(); } } // Get connection status bool connected = connectedAndInitialized(); #if 0 { /* Delete unused sectors 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) { // 3 minute interval //counter = 180.0; counter = 60.0; //JMutexAutoLock lock(m_env_mutex); //bulk comment-out core::list<v3s16> deleted_blocks; 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, &deleted_blocks); if(deleted_blocks.size() > 0) { /*infostream<<"Client: Deleted blocks of "<<num <<" 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(;;) { if(sendlist.size() == 255 || i == deleted_blocks.end()) { if(sendlist.size() == 0) break; /* [0] u16 command [2] u8 count [3] v3s16 pos_0 [3+6] v3s16 pos_1 ... */ u32 replysize = 2+1+6*sendlist.size(); SharedBuffer<u8> reply(replysize); writeU16(&reply[0], TOSERVER_DELETEDBLOCKS); reply[2] = sendlist.size(); u32 k = 0; for(core::list<v3s16>::Iterator j = sendlist.begin(); j != sendlist.end(); j++) { writeV3S16(&reply[2+1+6*k], *j); k++; } m_con.Send(PEER_ID_SERVER, 1, reply, true); if(i == deleted_blocks.end()) break; sendlist.clear(); } sendlist.push_back(*i); i++; } } } } #endif if(connected == false) { float &counter = m_connection_reinit_timer; counter -= dtime; if(counter <= 0.0) { counter = 2.0; //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out Player *myplayer = m_env.getLocalPlayer(); assert(myplayer != NULL); // Send TOSERVER_INIT // [0] u16 TOSERVER_INIT // [2] u8 SER_FMT_VER_HIGHEST // [3] u8[20] player_name // [23] u8[28] password (new in some version) // [51] u16 client network protocol version (new in some version) SharedBuffer<u8> data(2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2); writeU16(&data[0], TOSERVER_INIT); writeU8(&data[2], SER_FMT_VER_HIGHEST); memset((char*)&data[3], 0, PLAYERNAME_SIZE); snprintf((char*)&data[3], PLAYERNAME_SIZE, "%s", myplayer->getName()); /*infostream<<"Client: sending initial password hash: \""<<m_password<<"\"" <<std::endl;*/ memset((char*)&data[23], 0, PASSWORD_SIZE); snprintf((char*)&data[23], PASSWORD_SIZE, "%s", m_password.c_str()); // This should be incremented in each version writeU16(&data[51], 3); // Send as unreliable Send(0, data, false); } // Not connected, return return; } /* Do stuff if connected */ /* Run Map's timers and unload unused data */ const float map_timer_and_unload_dtime = 5.25; if(m_map_timer_and_unload_interval.step(dtime, map_timer_and_unload_dtime)) { ScopeProfiler sp(g_profiler, "Client: map timer and unload"); core::list<v3s16> deleted_blocks; 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. */ core::list<v3s16>::Iterator i = deleted_blocks.begin(); core::list<v3s16> sendlist; for(;;) { if(sendlist.size() == 255 || i == deleted_blocks.end()) { if(sendlist.size() == 0) break; /* [0] u16 command [2] u8 count [3] v3s16 pos_0 [3+6] v3s16 pos_1 ... */ u32 replysize = 2+1+6*sendlist.size(); SharedBuffer<u8> reply(replysize); writeU16(&reply[0], TOSERVER_DELETEDBLOCKS); reply[2] = sendlist.size(); u32 k = 0; for(core::list<v3s16>::Iterator j = sendlist.begin(); j != sendlist.end(); j++) { writeV3S16(&reply[2+1+6*k], *j); k++; } m_con.Send(PEER_ID_SERVER, 1, reply, true); if(i == deleted_blocks.end()) break; sendlist.clear(); } sendlist.push_back(*i); i++; } } /* Handle environment */ { // 0ms //JMutexAutoLock lock(m_env_mutex); //bulk comment-out // Control local player (0ms) LocalPlayer *player = m_env.getLocalPlayer(); assert(player != NULL); player->applyControl(dtime); //TimeTaker envtimer("env step", m_device); // Step environment m_env.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; sendDamage(damage); // Add to ClientEvent queue ClientEvent event; event.type = CE_PLAYER_DAMAGE; event.player_damage.amount = damage; m_client_event_queue.push_back(event); } } } } /* Print some info */ { float &counter = m_avg_rtt_timer; counter += dtime; if(counter >= 10) { counter = 0.0; //JMutexAutoLock lock(m_con_mutex); //bulk comment-out // connectedAndInitialized() is true, peer exists. float avg_rtt = m_con.GetPeerAvgRTT(PEER_ID_SERVER); infostream<<"Client: avg_rtt="<<avg_rtt<<std::endl; } } /* Send player position to server */ { float &counter = m_playerpos_send_timer; counter += dtime; if(counter >= 0.2) { counter = 0.0; sendPlayerPos(); } } /* Replace updated meshes */ { //JMutexAutoLock lock(m_env_mutex); //bulk comment-out //TimeTaker timer("** Processing mesh update result queue"); // 0ms /*infostream<<"Mesh update result queue size is " <<m_mesh_update_thread.m_queue_out.size() <<std::endl;*/ while(m_mesh_update_thread.m_queue_out.size() > 0) { MeshUpdateResult r = m_mesh_update_thread.m_queue_out.pop_front(); MapBlock *block = m_env.getMap().getBlockNoCreateNoEx(r.p); if(block) { block->replaceMesh(r.mesh); } if(r.ack_block_to_server) { /*infostream<<"Client: ACK block ("<<r.p.X<<","<<r.p.Y <<","<<r.p.Z<<")"<<std::endl;*/ /* Acknowledge block */ /* [0] u16 command [2] u8 count [3] v3s16 pos_0 [3+6] v3s16 pos_1 ... */ u32 replysize = 2+1+6; SharedBuffer<u8> reply(replysize); writeU16(&reply[0], TOSERVER_GOTBLOCKS); reply[2] = 1; writeV3S16(&reply[3], r.p); // Send as reliable m_con.Send(PEER_ID_SERVER, 1, reply, true); } } } }
void MapBlock::serialize_pre22(std::ostream &os, u8 version, bool disk) { u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; MapNode *tmp_data = new MapNode[nodecount]; // Legacy data changes // This code has to change from post-22 to pre-22 format. INodeDefManager *nodedef = m_gamedef->ndef(); for(u32 i=0; i<nodecount; i++) { const ContentFeatures &f = nodedef->get(tmp_data[i].getContent()); // Mineral if(nodedef->getId("default:stone_with_coal") == tmp_data[i].getContent()) { tmp_data[i].setContent(nodedef->getId("default:stone")); tmp_data[i].setParam1(1); // MINERAL_COAL } else if(nodedef->getId("default:stone_with_iron") == tmp_data[i].getContent()) { tmp_data[i].setContent(nodedef->getId("default:stone")); tmp_data[i].setParam1(2); // MINERAL_IRON } // facedir_simple if(f.legacy_facedir_simple) { tmp_data[i].setParam1(tmp_data[i].getParam2()); tmp_data[i].setParam2(0); } // wall_mounted if(f.legacy_wallmounted) { u8 wallmounted_new_to_old[8] = {0x04, 0x08, 0x01, 0x02, 0x10, 0x20, 0, 0}; u8 dir_new_format = tmp_data[i].getParam2() & 7; // lowest 3 bits u8 dir_old_format = wallmounted_new_to_old[dir_new_format]; tmp_data[i].setParam2(dir_old_format); } } // Serialize nodes u32 ser_length = MapNode::serializedLength(version); SharedBuffer<u8> databuf_nodelist(nodecount * ser_length); for(u32 i=0; i<nodecount; i++) { tmp_data[i].serialize(&databuf_nodelist[i*ser_length], version); } delete[] tmp_data; // These have no compression if(version <= 3 || version == 5 || version == 6) { writeU8(os, is_underground); os.write((char*)*databuf_nodelist, databuf_nodelist.getSize()); } else if(version <= 10) { /* With compression. Compress the materials and the params separately. */ // First byte writeU8(os, is_underground); // Get and compress materials SharedBuffer<u8> materialdata(nodecount); for(u32 i=0; i<nodecount; i++) { materialdata[i] = databuf_nodelist[i*ser_length]; } compress(materialdata, os, version); // Get and compress lights SharedBuffer<u8> lightdata(nodecount); for(u32 i=0; i<nodecount; i++) { lightdata[i] = databuf_nodelist[i*ser_length+1]; } compress(lightdata, os, version); if(version >= 10) { // Get and compress param2 SharedBuffer<u8> param2data(nodecount); for(u32 i=0; i<nodecount; i++) { param2data[i] = databuf_nodelist[i*ser_length+2]; } compress(param2data, os, version); } } // All other versions (newest) else { // First byte u8 flags = 0; if(is_underground) flags |= 0x01; if(getDayNightDiff()) flags |= 0x02; if(m_lighting_expired) flags |= 0x04; if(version >= 18) { if(m_generated == false) flags |= 0x08; } writeU8(os, flags); /* Get data */ // Create buffer with different parameters sorted SharedBuffer<u8> databuf(nodecount*3); for(u32 i=0; i<nodecount; i++) { databuf[i] = databuf_nodelist[i*ser_length]; databuf[i+nodecount] = databuf_nodelist[i*ser_length+1]; databuf[i+nodecount*2] = databuf_nodelist[i*ser_length+2]; } /* Compress data to output stream */ compress(databuf, os, version); /* NodeMetadata */ if(version >= 14) { if(version <= 15) { try{ std::ostringstream oss(std::ios_base::binary); m_node_metadata->serialize(oss); os<<serializeString(oss.str()); } // This will happen if the string is longer than 65535 catch(SerializationError &e) { // Use an empty string os<<serializeString(""); } } else { std::ostringstream oss(std::ios_base::binary); m_node_metadata->serialize(oss); compressZlib(oss.str(), os); //os<<serializeLongString(oss.str()); } } } if(disk) { // Versions up from 9 have block objects. (DEPRECATED) if(version >= 9) { // count=0 writeU16(os, 0); } // Versions up from 15 have static objects. if(version >= 15) { m_static_objects.serialize(os); } // Timestamp if(version >= 17) { writeU32(os, getTimestamp()); } // Scan and write node definition id mapping if(version >= 21) { NameIdMapping nimap; getBlockNodeIdMapping_pre22(&nimap, data, m_gamedef->ndef()); nimap.serialize(os); } } }