commit before content-tile separation

makepackage_binary.sh

@@ -34,8 +34,8 @@ cp -r data/sign_back.png $PACKAGEPATH/data/
 cp -r data/rat.png $PACKAGEPATH/data/
 cp -r data/mud.png $PACKAGEPATH/data/
 cp -r data/torch.png $PACKAGEPATH/data/
-cp -r data/torch_floor.png $PACKAGEPATH/data/
-cp -r data/torch_ceiling.png $PACKAGEPATH/data/
+cp -r data/torch_on_floor.png $PACKAGEPATH/data/
+cp -r data/torch_on_ceiling.png $PACKAGEPATH/data/
 cp -r data/skybox1.png $PACKAGEPATH/data/
 cp -r data/skybox2.png $PACKAGEPATH/data/
 cp -r data/skybox3.png $PACKAGEPATH/data/

minetest.conf.example

@@ -57,5 +57,6 @@
 #max_block_generate_distance = 6
 
 #disable_water_climb = true
+# Note that this gets applied at map generation time
 #endless_water = true
 

src/constants.h

@@ -41,6 +41,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #define SERVERMAP_DELETE_UNUSED_SECTORS_TIMEOUT (60*10)
 #define SERVER_MAP_SAVE_INTERVAL (60)
+/*#define SERVERMAP_DELETE_UNUSED_SECTORS_TIMEOUT (10)
+#define SERVER_MAP_SAVE_INTERVAL (10)*/
 
 #define FOV_ANGLE (PI/2.5)
 

src/main.cpp

@@ -172,25 +172,23 @@ TODO: Remove LazyMeshUpdater. It is not used as supposed.
 
 FIXME: Rats somehow go underground sometimes (you can see it in water)
        - Does their position get saved to a border value or something?
+	   - Does this happen anymore?
 
 SUGG: MovingObject::move and Player::move are basically the same.
       combine them.
 
-TODO: Transfer sign texts as metadata of block and not as data of
-      object
-
 SUGG: Implement a "Fast check queue" (a queue with a map for checking
       if something is already in it)
-      - TODO: Use it in active block queue in water flowing
+      - Use it in active block queue in water flowing
 
-TODO: Proper looking torches.
-      - Signs could be done in the same way?
-
-TODO: A mapper to map contents to tile names (for each side)
+SUGG: Signs could be done in the same way as torches. For this, blocks
+      need an additional metadata field for the texts
 
 Doing now:
 ======================================================================
 
+TODO: A mapper to map contents to tile names (for each side)
+
 ======================================================================
 
 */

src/map.cpp

@@ -1504,7 +1504,8 @@ MapSector * ServerMap::emergeSector(v2s16 p2d)
 		sector->setHeightmap(p_in_sector, hm);
 
 		//TODO: Make these values configurable
-		hm->generateContinued(1.0, 0.2, corners);
+		hm->generateContinued(0.0, 0.0, corners);
+		//hm->generateContinued(1.0, 0.2, corners);
 		//hm->generateContinued(2.0, 0.2, corners);
 
 		//hm->print();
@@ -3242,8 +3243,8 @@ MapVoxelManipulator::MapVoxelManipulator(Map *map)
 
 MapVoxelManipulator::~MapVoxelManipulator()
 {
-	dstream<<"MapVoxelManipulator: blocks: "<<m_loaded_blocks.size()
-			<<std::endl;
+	/*dstream<<"MapVoxelManipulator: blocks: "<<m_loaded_blocks.size()
+			<<std::endl;*/
 }
 
 #if 1
@@ -3358,7 +3359,7 @@ void MapVoxelManipulator::blitBack
 	if(m_area.getExtent() == v3s16(0,0,0))
 		return;
 	
-	TimeTaker timer1("blitBack", g_device);
+	//TimeTaker timer1("blitBack", g_device);
 	
 	/*
 		Initialize block cache

src/mapblock.cpp

@@ -68,7 +68,7 @@ void MapBlock::setNodeParent(v3s16 p, MapNode & n)
 	}
 }
 
-FastFace * MapBlock::makeFastFace(u8 material, u8 light, v3f p,
+FastFace * MapBlock::makeFastFace(u16 tile, u8 light, v3f p,
 		v3f dir, v3f scale, v3f posRelative_f)
 {
 	FastFace *f = new FastFace;
@@ -111,7 +111,9 @@ FastFace * MapBlock::makeFastFace(u8 material, u8 light, v3f p,
 
 	u8 alpha = 255;
 
-	if(material == CONTENT_WATER || material == CONTENT_OCEAN)
+	//if(material == CONTENT_WATER || material == CONTENT_OCEAN)
+	if(tile == CONTENT_WATER || tile == CONTENT_OCEAN)
+	//if(tile == TILE_WATER)
 	{
 		alpha = 128;
 	}
@@ -135,7 +137,7 @@ FastFace * MapBlock::makeFastFace(u8 material, u8 light, v3f p,
 	f->vertices[3] = video::S3DVertex(vertex_pos[3], zerovector, c,
 			core::vector2d<f32>(0,0));
 
-	f->material = material;
+	f->tile = tile;
 
 	return f;
 }
@@ -475,7 +477,9 @@ void MapBlock::updateMesh()
 
 			const u16 indices[] = {0,1,2,2,3,0};
 
-			collector.append(g_materials[f->material], f->vertices, 4,
+			/*collector.append(g_materials[f->material], f->vertices, 4,
+					indices, 6);*/
+			collector.append(g_materials[f->tile], f->vertices, 4,
 					indices, 6);
 		}
 
@@ -817,8 +821,7 @@ void MapBlock::serialize(std::ostream &os, u8 version)
 		
 		os.write((char*)*dest, dest.getSize());
 	}
-	// All otherversions
-	else
+	else if(version <= 10)
 	{
 		/*
 			With compression.
@@ -857,6 +860,44 @@ void MapBlock::serialize(std::ostream &os, u8 version)
 			compress(pressuredata, os, version);
 		}
 	}
+	// All other versions (newest)
+	else
+	{
+		// First byte
+		os.write((char*)&is_underground, 1);
+
+		u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
+
+		/*
+			Get data
+		*/
+
+		SharedBuffer<u8> databuf(nodecount*3);
+
+		// Get contents
+		for(u32 i=0; i<nodecount; i++)
+		{
+			databuf[i] = data[i].d;
+		}
+
+		// Get params
+		for(u32 i=0; i<nodecount; i++)
+		{
+			databuf[i+nodecount] = data[i].param;
+		}
+
+		// Get pressure
+		for(u32 i=0; i<nodecount; i++)
+		{
+			databuf[i+nodecount*2] = data[i].pressure;
+		}
+
+		/*
+			Compress data to output stream
+		*/
+
+		compress(databuf, os, version);
+	}
 }
 
 void MapBlock::deSerialize(std::istream &is, u8 version)
@@ -885,8 +926,7 @@ void MapBlock::deSerialize(std::istream &is, u8 version)
 			data[i].deSerialize(*d, version);
 		}
 	}
-	// All other versions
-	else
+	else if(version <= 10)
 	{
 		u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
 
@@ -936,6 +976,39 @@ void MapBlock::deSerialize(std::istream &is, u8 version)
 			}
 		}
 	}
+	// All other versions (newest)
+	else
+	{
+		u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
+
+		u8 t8;
+		is.read((char*)&t8, 1);
+		is_underground = t8;
+
+		// Uncompress data
+		std::ostringstream os(std::ios_base::binary);
+		decompress(is, os, version);
+		std::string s = os.str();
+		if(s.size() != nodecount*3)
+			throw SerializationError
+					("MapBlock::deSerialize: invalid format");
+
+		// Set contents
+		for(u32 i=0; i<nodecount; i++)
+		{
+			data[i].d = s[i];
+		}
+		// Set params
+		for(u32 i=0; i<nodecount; i++)
+		{
+			data[i].param = s[i+nodecount];
+		}
+		// Set pressure
+		for(u32 i=0; i<nodecount; i++)
+		{
+			data[i].pressure = s[i+nodecount*2];
+		}
+	}
 }
 
 

src/mapblock.h

@@ -46,7 +46,7 @@ enum{
 
 struct FastFace
 {
-	u8 material;
+	u16 tile;
 	video::S3DVertex vertices[4]; // Precalculated vertices
 };
 
@@ -283,7 +283,7 @@ public:
 					setNode(x0+x, y0+y, z0+z, node);
 	}
 
-	static FastFace * makeFastFace(u8 material, u8 light, v3f p,
+	static FastFace * makeFastFace(u16 tile, u8 light, v3f p,
 			v3f dir, v3f scale, v3f posRelative_f);
 	
 	u8 getFaceLight(v3s16 p, v3s16 face_dir);

src/mapnode.h

@@ -66,23 +66,23 @@ enum Content
 {
 	CONTENT_STONE=0,
 
-	CONTENT_GRASS,
+	CONTENT_GRASS=1,
 
-	CONTENT_WATER,
+	CONTENT_WATER=2,
 
-	CONTENT_LIGHT,
+	CONTENT_LIGHT=3,
 
-	CONTENT_TREE,
+	CONTENT_TREE=4,
 	
-	CONTENT_LEAVES,
+	CONTENT_LEAVES=5,
 
-	CONTENT_GRASS_FOOTSTEPS,
+	CONTENT_GRASS_FOOTSTEPS=6,
 	
-	CONTENT_MESE,
+	CONTENT_MESE=7,
 
-	CONTENT_MUD,
+	CONTENT_MUD=8,
 
-	CONTENT_OCEAN,
+	CONTENT_OCEAN=9,
 	
 	// This is set to the number of the actual values in this enum
 	USEFUL_CONTENT_COUNT

src/serialization.cpp

@@ -17,15 +17,181 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
-/*
-(c) 2010 Perttu Ahola <celeron55@gmail.com>
-*/
-
 #include "serialization.h"
 #include "utility.h"
+#include "zlib.h"
+
+/* report a zlib or i/o error */
+void zerr(int ret)
+{   
+    fputs("zerr: ", stderr);
+    switch (ret) {
+    case Z_ERRNO:
+        if (ferror(stdin))
+            fputs("error reading stdin\n", stderr);
+        if (ferror(stdout))
+            fputs("error writing stdout\n", stderr);
+        break;
+    case Z_STREAM_ERROR:
+        fputs("invalid compression level\n", stderr);
+        break;
+    case Z_DATA_ERROR:
+        fputs("invalid or incomplete deflate data\n", stderr);
+        break;
+    case Z_MEM_ERROR:
+        fputs("out of memory\n", stderr);
+        break;
+    case Z_VERSION_ERROR:
+        fputs("zlib version mismatch!\n", stderr);
+		break;
+	default:
+		dstream<<"return value = "<<ret<<"\n";
+    }
+}
+
+void compressZlib(SharedBuffer<u8> data, std::ostream &os)
+{
+	z_stream z;
+	const s32 bufsize = 16384;
+	//char input_buffer[bufsize];
+	char output_buffer[bufsize];
+	int input_i = 0;
+	int status = 0;
+	int ret;
+
+	z.zalloc = Z_NULL;
+	z.zfree = Z_NULL;
+	z.opaque = Z_NULL;
+
+	ret = deflateInit(&z, -1);
+	if(ret != Z_OK)
+		throw SerializationError("compressZlib: deflateInit failed");
+	
+	z.avail_in = 0;
+	
+	for(;;)
+	{
+		int flush = Z_NO_FLUSH;
+		z.next_out = (Bytef*)output_buffer;
+		z.avail_out = bufsize;
+
+		if(z.avail_in == 0)
+		{
+			//z.next_in = (char*)&data[input_i];
+			z.next_in = (Bytef*)&data[input_i];
+			z.avail_in = data.getSize() - input_i;
+			input_i += z.avail_in;
+			if(input_i == (int)data.getSize())
+				flush = Z_FINISH;
+		}
+		if(z.avail_in == 0)
+			break;
+		status = deflate(&z, flush);
+		if(status == Z_NEED_DICT || status == Z_DATA_ERROR
+				|| status == Z_MEM_ERROR)
+		{
+			zerr(status);
+			throw SerializationError("compressZlib: deflate failed");
+		}
+		int count = bufsize - z.avail_out;
+		if(count)
+			os.write(output_buffer, count);
+	}
+
+	deflateEnd(&z);
+
+}
+
+void decompressZlib(std::istream &is, std::ostream &os)
+{
+	z_stream z;
+	const s32 bufsize = 16384;
+	char input_buffer[bufsize];
+	char output_buffer[bufsize];
+	int status = 0;
+	int ret;
+	int bytes_read = 0;
+	int input_buffer_len = 0;
+
+	z.zalloc = Z_NULL;
+	z.zfree = Z_NULL;
+	z.opaque = Z_NULL;
+
+	ret = inflateInit(&z);
+	if(ret != Z_OK)
+		throw SerializationError("compressZlib: inflateInit failed");
+	
+	z.avail_in = 0;
+	
+	//dstream<<"initial fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
+
+	for(;;)
+	{
+		z.next_out = (Bytef*)output_buffer;
+		z.avail_out = bufsize;
+
+		if(z.avail_in == 0)
+		{
+			z.next_in = (Bytef*)input_buffer;
+			input_buffer_len = is.readsome(input_buffer, bufsize);
+			z.avail_in = input_buffer_len;
+			//dstream<<"read fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
+		}
+		if(z.avail_in == 0)
+		{
+			//dstream<<"z.avail_in == 0"<<std::endl;
+			break;
+		}
+			
+		//dstream<<"1 z.avail_in="<<z.avail_in<<std::endl;
+		status = inflate(&z, Z_NO_FLUSH);
+		//dstream<<"2 z.avail_in="<<z.avail_in<<std::endl;
+		bytes_read += is.gcount() - z.avail_in;
+		//dstream<<"bytes_read="<<bytes_read<<std::endl;
+
+		if(status == Z_NEED_DICT || status == Z_DATA_ERROR
+				|| status == Z_MEM_ERROR)
+		{
+			zerr(status);
+			throw SerializationError("compressZlib: inflate failed");
+		}
+		int count = bufsize - z.avail_out;
+		//dstream<<"count="<<count<<std::endl;
+		if(count)
+			os.write(output_buffer, count);
+		if(status == Z_STREAM_END)
+		{
+			//dstream<<"Z_STREAM_END"<<std::endl;
+			
+			//dstream<<"z.avail_in="<<z.avail_in<<std::endl;
+			//dstream<<"fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
+			// Unget all the data that inflate didn't take
+			for(u32 i=0; i < z.avail_in; i++)
+			{
+				is.unget();
+				if(is.fail() || is.bad())
+				{
+					dstream<<"unget #"<<i<<" failed"<<std::endl;
+					dstream<<"fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
+					throw SerializationError("compressZlib: unget failed");
+				}
+			}
+			
+			break;
+		}
+	}
+
+	inflateEnd(&z);
+}
 
 void compress(SharedBuffer<u8> data, std::ostream &os, u8 version)
 {
+	if(version >= 11)
+	{
+		compressZlib(data, os);
+		return;
+	}
+
 	if(data.getSize() == 0)
 		return;
 	
@@ -63,6 +229,12 @@ void compress(SharedBuffer<u8> data, std::ostream &os, u8 version)
 
 void decompress(std::istream &is, std::ostream &os, u8 version)
 {
+	if(version >= 11)
+	{
+		decompressZlib(is, os);
+		return;
+	}
+
 	// Read length (u32)
 
 	u8 tmp[4];

src/serialization.h

@@ -17,10 +17,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
-/*
-(c) 2010 Perttu Ahola <celeron55@gmail.com>
-*/
-
 #ifndef SERIALIZATION_HEADER
 #define SERIALIZATION_HEADER
 
@@ -47,11 +43,12 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 	8: (dev) server-initiated block transfers and all kinds of stuff
 	9: (dev) block objects
 	10: (dev) water pressure
+	11: (dev) zlib'd blocks
 */
 // This represents an uninitialized or invalid format
 #define SER_FMT_VER_INVALID 255
 // Highest supported serialization version
-#define SER_FMT_VER_HIGHEST 10
+#define SER_FMT_VER_HIGHEST 11
 // Lowest supported serialization version
 #define SER_FMT_VER_LOWEST 2
 

src/server.cpp

@@ -412,8 +412,10 @@ void RemoteClient::GetNextBlocks(Server *server, float dtime,
 					maximum_simultaneous_block_sends;
 			
 			if(d <= BLOCK_SEND_DISABLE_LIMITS_MAX_D)
+			{
 				maximum_simultaneous_block_sends_now =
 						maximum_simultaneous_block_sends_setting;
+			}
 
 			{
 				JMutexAutoLock lock(m_blocks_sending_mutex);
@@ -971,8 +973,16 @@ void Server::AsyncRunStep()
 	{
 		JMutexAutoLock lock1(m_step_dtime_mutex);
 		dtime = m_step_dtime;
+	}
+	
+	// Send blocks to clients
+	SendBlocks(dtime);
+	
 	if(dtime < 0.001)
 		return;
+	
+	{
+		JMutexAutoLock lock1(m_step_dtime_mutex);
 		m_step_dtime = 0.0;
 	}
 
@@ -1098,9 +1108,6 @@ void Server::AsyncRunStep()
 		}
 	}*/
 
-	// Send blocks to clients
-	SendBlocks(dtime);
-	
 	// Send object positions
 	{
 		static float counter = 0.0;
@@ -1876,7 +1883,8 @@ void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver)
 	writeS16(&reply[6], p.Z);
 	memcpy(&reply[8], *blockdata, blockdata.getSize());
 
-	//dstream<<"Sending block: packet size: "<<replysize<<std::endl;
+	dstream<<"Sending block ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
+			<<":  \tpacket size: "<<replysize<<std::endl;
 	
 	/*
 		Send packet

src/test.cpp

@@ -72,6 +72,8 @@ struct TestCompress
 {
 	void Run()
 	{
+		{ // ver 0
+
 		SharedBuffer<u8> fromdata(4);
 		fromdata[0]=1;
 		fromdata[1]=5;
@@ -123,6 +125,64 @@ struct TestCompress
 		{
 			assert(str_out2[i] == fromdata[i]);
 		}
+
+		}
+
+		{ // ver HIGHEST
+
+		SharedBuffer<u8> fromdata(4);
+		fromdata[0]=1;
+		fromdata[1]=5;
+		fromdata[2]=5;
+		fromdata[3]=1;
+		
+		std::ostringstream os(std::ios_base::binary);
+		compress(fromdata, os, SER_FMT_VER_HIGHEST);
+
+		std::string str_out = os.str();
+		
+		dstream<<"str_out.size()="<<str_out.size()<<std::endl;
+		dstream<<"TestCompress: 1,5,5,1 -> ";
+		for(u32 i=0; i<str_out.size(); i++)
+		{
+			dstream<<(u32)str_out[i]<<",";
+		}
+		dstream<<std::endl;
+
+		/*assert(str_out.size() == 10);
+
+		assert(str_out[0] == 0);
+		assert(str_out[1] == 0);
+		assert(str_out[2] == 0);
+		assert(str_out[3] == 4);
+		assert(str_out[4] == 0);
+		assert(str_out[5] == 1);
+		assert(str_out[6] == 1);
+		assert(str_out[7] == 5);
+		assert(str_out[8] == 0);
+		assert(str_out[9] == 1);*/
+
+		std::istringstream is(str_out, std::ios_base::binary);
+		std::ostringstream os2(std::ios_base::binary);
+
+		decompress(is, os2, SER_FMT_VER_HIGHEST);
+		std::string str_out2 = os2.str();
+
+		dstream<<"decompress: ";
+		for(u32 i=0; i<str_out2.size(); i++)
+		{
+			dstream<<(u32)str_out2[i]<<",";
+		}
+		dstream<<std::endl;
+
+		assert(str_out2.size() == fromdata.getSize());
+
+		for(u32 i=0; i<str_out2.size(); i++)
+		{
+			assert(str_out2[i] == fromdata[i]);
+		}
+
+		}
 	}
 };
 
@@ -273,8 +333,8 @@ struct TestVoxelManipulator
 		
 		active_nodes.clear();
 		active_nodes[v3s16(9,1,0)] = 1;
-		//v.flowWater(active_nodes, 0, false);
-		v.flowWater(active_nodes, 0, true, 1000);
+		//v.flowWater(active_nodes, 0, true, 1000);
+		v.flowWater(active_nodes, 0, false, 1000);
 		
 		dstream<<"Final result of flowWater:"<<std::endl;
 		v.print(dstream, VOXELPRINT_WATERPRESSURE);

src/utility.h

@@ -461,12 +461,12 @@ inline void getFacePositions(core::list<v3s16> &list, u16 d)
 		/*
 			This is an optimized sequence of coordinates.
 		*/
+		list.push_back(v3s16( 0, 1, 0)); // top
 		list.push_back(v3s16( 0, 0, 1)); // back
 		list.push_back(v3s16(-1, 0, 0)); // left
 		list.push_back(v3s16( 1, 0, 0)); // right
 		list.push_back(v3s16( 0, 0,-1)); // front
 		list.push_back(v3s16( 0,-1, 0)); // bottom
-		list.push_back(v3s16( 0, 1, 0)); // top
 		// 6
 		list.push_back(v3s16(-1, 0, 1)); // back left
 		list.push_back(v3s16( 1, 0, 1)); // back right

src/voxel.h

@@ -25,6 +25,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "debug.h"
 #include "mapnode.h"
 
+// For VC++
 #undef min
 #undef max