X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fmapnode.cpp;h=d52677be07540def4fc0a15b8b3e0022c6887b4f;hb=a020d1b653f94fbcaac06c15f9dbab4521fda355;hp=0479d2e55e9e00a3f670c507c1ea8e7c9c055f1f;hpb=ea62ee4b61371107ef3d693bda4c410ba02ca7e6;p=oweals%2Fminetest.git

diff --git a/src/mapnode.cpp b/src/mapnode.cpp
index 0479d2e55..d52677be0 100644
--- a/src/mapnode.cpp
+++ b/src/mapnode.cpp
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
@@ -25,9 +25,19 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "content_mapnode.h" // For mapnode_translate_*_internal
 #include "serialization.h" // For ser_ver_supported
 #include "util/serialize.h"
+#include "log.h"
 #include <string>
 #include <sstream>
 
+static const Rotation wallmounted_to_rot[] = {
+	ROTATE_0, ROTATE_180, ROTATE_90, ROTATE_270
+};
+
+static const u8 rot_to_wallmounted[] = {
+	2, 4, 3, 5
+};
+
+
 /*
 	MapNode
 */
@@ -107,7 +117,7 @@ u8 MapNode::getFaceDir(INodeDefManager *nodemgr) const
 {
 	const ContentFeatures &f = nodemgr->get(*this);
 	if(f.param_type_2 == CPT2_FACEDIR)
-		return getParam2() & 0x03;
+		return getParam2() & 0x1F;
 	return 0;
 }
 
@@ -132,37 +142,162 @@ v3s16 MapNode::getWallMountedDir(INodeDefManager *nodemgr) const
 	}
 }
 
+void MapNode::rotateAlongYAxis(INodeDefManager *nodemgr, Rotation rot) {
+	ContentParamType2 cpt2 = nodemgr->get(*this).param_type_2;
+
+	if (cpt2 == CPT2_FACEDIR) {
+		u8 newrot = param2 & 3;
+		param2 &= ~3;
+		param2 |= (newrot + rot) & 3;
+	} else if (cpt2 == CPT2_WALLMOUNTED) {
+		u8 wmountface = (param2 & 7);
+		if (wmountface <= 1)
+			return;
+			
+		Rotation oldrot = wallmounted_to_rot[wmountface - 2];
+		param2 &= ~7;
+		param2 |= rot_to_wallmounted[(oldrot - rot) & 3];
+	}
+}
+
 static std::vector<aabb3f> transformNodeBox(const MapNode &n,
 		const NodeBox &nodebox, INodeDefManager *nodemgr)
 {
 	std::vector<aabb3f> boxes;
-	if(nodebox.type == NODEBOX_FIXED)
+	if(nodebox.type == NODEBOX_FIXED || nodebox.type == NODEBOX_LEVELED)
 	{
 		const std::vector<aabb3f> &fixed = nodebox.fixed;
 		int facedir = n.getFaceDir(nodemgr);
+		u8 axisdir = facedir>>2;
+		facedir&=0x03;
 		for(std::vector<aabb3f>::const_iterator
 				i = fixed.begin();
 				i != fixed.end(); i++)
 		{
 			aabb3f box = *i;
-			if(facedir == 1)
-			{
-				box.MinEdge.rotateXZBy(-90);
-				box.MaxEdge.rotateXZBy(-90);
-				box.repair();
-			}
-			else if(facedir == 2)
-			{
-				box.MinEdge.rotateXZBy(180);
-				box.MaxEdge.rotateXZBy(180);
-				box.repair();
+
+			if (nodebox.type == NODEBOX_LEVELED) {
+				box.MaxEdge.Y = -BS/2 + BS*((float)1/LEVELED_MAX) * n.getLevel(nodemgr);
 			}
-			else if(facedir == 3)
+
+			switch (axisdir)
 			{
-				box.MinEdge.rotateXZBy(90);
-				box.MaxEdge.rotateXZBy(90);
-				box.repair();
+			case 0:
+				if(facedir == 1)
+				{
+					box.MinEdge.rotateXZBy(-90);
+					box.MaxEdge.rotateXZBy(-90);
+				}
+				else if(facedir == 2)
+				{
+					box.MinEdge.rotateXZBy(180);
+					box.MaxEdge.rotateXZBy(180);
+				}
+				else if(facedir == 3)
+				{
+					box.MinEdge.rotateXZBy(90);
+					box.MaxEdge.rotateXZBy(90);
+				}
+				break;
+			case 1: // z+
+				box.MinEdge.rotateYZBy(90);
+				box.MaxEdge.rotateYZBy(90);
+				if(facedir == 1)
+				{
+					box.MinEdge.rotateXYBy(90);
+					box.MaxEdge.rotateXYBy(90);
+				}
+				else if(facedir == 2)
+				{
+					box.MinEdge.rotateXYBy(180);
+					box.MaxEdge.rotateXYBy(180);
+				}
+				else if(facedir == 3)
+				{
+					box.MinEdge.rotateXYBy(-90);
+					box.MaxEdge.rotateXYBy(-90);
+				}
+				break;
+			case 2: //z-
+				box.MinEdge.rotateYZBy(-90);
+				box.MaxEdge.rotateYZBy(-90);
+				if(facedir == 1)
+				{
+					box.MinEdge.rotateXYBy(-90);
+					box.MaxEdge.rotateXYBy(-90);
+				}
+				else if(facedir == 2)
+				{
+					box.MinEdge.rotateXYBy(180);
+					box.MaxEdge.rotateXYBy(180);
+				}
+				else if(facedir == 3)
+				{
+					box.MinEdge.rotateXYBy(90);
+					box.MaxEdge.rotateXYBy(90);
+				}
+				break;
+			case 3:  //x+
+				box.MinEdge.rotateXYBy(-90);
+				box.MaxEdge.rotateXYBy(-90);
+				if(facedir == 1)
+				{
+					box.MinEdge.rotateYZBy(90);
+					box.MaxEdge.rotateYZBy(90);
+				}
+				else if(facedir == 2)
+				{
+					box.MinEdge.rotateYZBy(180);
+					box.MaxEdge.rotateYZBy(180);
+				}
+				else if(facedir == 3)
+				{
+					box.MinEdge.rotateYZBy(-90);
+					box.MaxEdge.rotateYZBy(-90);
+				}
+				break;
+			case 4:  //x-
+				box.MinEdge.rotateXYBy(90);
+				box.MaxEdge.rotateXYBy(90);
+				if(facedir == 1)
+				{
+					box.MinEdge.rotateYZBy(-90);
+					box.MaxEdge.rotateYZBy(-90);
+				}
+				else if(facedir == 2)
+				{
+					box.MinEdge.rotateYZBy(180);
+					box.MaxEdge.rotateYZBy(180);
+				}
+				else if(facedir == 3)
+				{
+					box.MinEdge.rotateYZBy(90);
+					box.MaxEdge.rotateYZBy(90);
+				}
+				break;
+			case 5:
+				box.MinEdge.rotateXYBy(-180);
+				box.MaxEdge.rotateXYBy(-180);
+				if(facedir == 1)
+				{
+					box.MinEdge.rotateXZBy(90);
+					box.MaxEdge.rotateXZBy(90);
+				}
+				else if(facedir == 2)
+				{
+					box.MinEdge.rotateXZBy(180);
+					box.MaxEdge.rotateXZBy(180);
+				}
+				else if(facedir == 3)
+				{
+					box.MinEdge.rotateXZBy(-90);
+					box.MaxEdge.rotateXZBy(-90);
+				}
+				break;
+			default:
+				break;
 			}
+			box.repair();
 			boxes.push_back(box);
 		}
 	}
@@ -225,6 +360,91 @@ std::vector<aabb3f> MapNode::getSelectionBoxes(INodeDefManager *nodemgr) const
 	return transformNodeBox(*this, f.selection_box, nodemgr);
 }
 
+u8 MapNode::getMaxLevel(INodeDefManager *nodemgr) const
+{
+	const ContentFeatures &f = nodemgr->get(*this);
+	// todo: after update in all games leave only if (f.param_type_2 ==
+	if( f.liquid_type == LIQUID_FLOWING || f.param_type_2 == CPT2_FLOWINGLIQUID)
+		return LIQUID_LEVEL_MAX;
+	if(f.leveled || f.param_type_2 == CPT2_LEVELED)
+		return LEVELED_MAX;
+	return 0;
+}
+
+u8 MapNode::getLevel(INodeDefManager *nodemgr) const
+{
+	const ContentFeatures &f = nodemgr->get(*this);
+	// todo: after update in all games leave only if (f.param_type_2 ==
+	if(f.liquid_type == LIQUID_SOURCE)
+		return LIQUID_LEVEL_SOURCE;
+	if (f.param_type_2 == CPT2_FLOWINGLIQUID)
+		return getParam2() & LIQUID_LEVEL_MASK;
+	if(f.liquid_type == LIQUID_FLOWING) // can remove if all param_type_2 setted
+		return getParam2() & LIQUID_LEVEL_MASK;
+	if(f.leveled || f.param_type_2 == CPT2_LEVELED) {
+		 u8 level = getParam2() & LEVELED_MASK;
+		 if(level)
+			return level;
+		 if(f.leveled > LEVELED_MAX)
+		 	return LEVELED_MAX;
+		 return f.leveled; //default
+	}
+	return 0;
+}
+
+u8 MapNode::setLevel(INodeDefManager *nodemgr, s8 level)
+{
+	u8 rest = 0;
+	if (level < 1) {
+		setContent(CONTENT_AIR);
+		return 0;
+	}
+	const ContentFeatures &f = nodemgr->get(*this);
+	if (f.param_type_2 == CPT2_FLOWINGLIQUID
+		|| f.liquid_type == LIQUID_FLOWING
+		|| f.liquid_type == LIQUID_SOURCE) {
+		if (level >= LIQUID_LEVEL_SOURCE) {
+			rest = level - LIQUID_LEVEL_SOURCE;
+			setContent(nodemgr->getId(f.liquid_alternative_source));
+		} else {
+			setContent(nodemgr->getId(f.liquid_alternative_flowing));
+			setParam2(level & LIQUID_LEVEL_MASK);
+		}
+	} else if (f.leveled || f.param_type_2 == CPT2_LEVELED) {
+		if (level > LEVELED_MAX) {
+			rest = level - LEVELED_MAX;
+			level = LEVELED_MAX;
+		}
+		setParam2(level & LEVELED_MASK);
+	}
+	return rest;
+}
+
+u8 MapNode::addLevel(INodeDefManager *nodemgr, s8 add)
+{
+	s8 level = getLevel(nodemgr);
+	if (add == 0) level = 1;
+	level += add;
+	return setLevel(nodemgr, level);
+}
+
+void MapNode::freezeMelt(INodeDefManager *ndef) {
+	u8 level_was_max = this->getMaxLevel(ndef);
+	u8 level_was = this->getLevel(ndef);
+	this->setContent(ndef->getId(ndef->get(*this).freezemelt));
+	u8 level_now_max = this->getMaxLevel(ndef);
+	if (level_was_max && level_was_max != level_now_max) {
+		u8 want = (float)level_now_max / level_was_max * level_was;
+		if (!want)
+			want = 1;
+		if (want != level_was)
+			this->setLevel(ndef, want);
+		//errorstream<<"was="<<(int)level_was<<"/"<<(int)level_was_max<<" nowm="<<(int)want<<"/"<<(int)level_now_max<< " => "<<(int)this->getLevel(ndef)<< std::endl;
+	}
+	if (this->getMaxLevel(ndef) && !this->getLevel(ndef))
+		this->addLevel(ndef);
+}
+
 u32 MapNode::serializedLength(u8 version)
 {
 	if(!ser_ver_supported(version))
@@ -234,35 +454,25 @@ u32 MapNode::serializedLength(u8 version)
 		return 1;
 	else if(version <= 9)
 		return 2;
-	else
+	else if(version <= 23)
 		return 3;
+	else
+		return 4;
 }
 void MapNode::serialize(u8 *dest, u8 version)
 {
 	if(!ser_ver_supported(version))
 		throw VersionMismatchException("ERROR: MapNode format not supported");
-
-	if(version <= 21)
-	{
-		serialize_pre22(dest, version);
-		return;
-	}
-
-	if(version >= 24){
-		writeU16(dest+0, param0);
-		writeU8(dest+2, param1);
-		writeU8(dest+3, param2);
-	}
-	else{
-		writeU8(dest+0, (param0&0xFF));
-		writeU8(dest+1, param1);
-		if (param0 > 0x7F){
-			writeU8(dest+2, ((param2&0x0F) | ((param0&0x0F00)>>4)));
-		}
-		else{
-			writeU8(dest+2, param2);
-		}
-	}
+	
+	// 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("MapNode::serialize: serialization to "
+				"version < 24 not possible");
+		
+	writeU16(dest+0, param0);
+	writeU8(dest+2, param1);
+	writeU8(dest+3, param2);
 }
 void MapNode::deSerialize(u8 *source, u8 version)
 {
@@ -279,8 +489,7 @@ void MapNode::deSerialize(u8 *source, u8 version)
 		param0 = readU16(source+0);
 		param1 = readU8(source+2);
 		param2 = readU8(source+3);
-	}
-	else{
+	}else{
 		param0 = readU8(source+0);
 		param1 = readU8(source+1);
 		param2 = readU8(source+2);
@@ -297,22 +506,20 @@ void MapNode::serializeBulk(std::ostream &os, int version,
 	if(!ser_ver_supported(version))
 		throw VersionMismatchException("ERROR: MapNode format not supported");
 
-	assert(version >= 22);
-	assert(content_width == 1 || content_width == 2);
+	assert(content_width == 2);
 	assert(params_width == 2);
 
+	// 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("MapNode::serializeBulk: serialization to "
+				"version < 24 not possible");
+
 	SharedBuffer<u8> databuf(nodecount * (content_width + params_width));
 
 	// Serialize content
-	if(content_width == 1)
-	{
-		for(u32 i=0; i<nodecount; i++)
-			writeU8(&databuf[i], (nodes[i].param0&0x00FF));
-	}else if(content_width == 2)
-	{
-		for(u32 i=0; i<nodecount; i++)
-			writeU16(&databuf[i*2], nodes[i].param0);
-	}
+	for(u32 i=0; i<nodecount; i++)
+		writeU16(&databuf[i*2], nodes[i].param0);
 
 	// Serialize param1
 	u32 start1 = content_width * nodecount;
@@ -321,21 +528,8 @@ void MapNode::serializeBulk(std::ostream &os, int version,
 
 	// Serialize param2
 	u32 start2 = (content_width + 1) * nodecount;
-	if(content_width == 1)
-	{
-		for(u32 i=0; i<nodecount; i++) {
-			if(nodes[i].param0 > 0x7F){
-				writeU8(&databuf[start2 + i], ((nodes[i].param2&0x0F) | ((nodes[i].param0&0x0F00)>>4)));
-			}
-			else{
-				writeU8(&databuf[start2 + i], nodes[i].param2);
-			}
-		}
-	}else if(content_width == 2)
-	{
-		for(u32 i=0; i<nodecount; i++)
-			writeU8(&databuf[start2 + i], nodes[i].param2);
-	}
+	for(u32 i=0; i<nodecount; i++)
+		writeU8(&databuf[start2 + i], nodes[i].param2);
 
 	/*
 		Compress data to output stream
@@ -408,7 +602,8 @@ void MapNode::deSerializeBulk(std::istream &is, int version,
 		for(u32 i=0; i<nodecount; i++) {
 			nodes[i].param2 = readU8(&databuf[start2 + i]);
 			if(nodes[i].param0 > 0x7F){
-				nodes[i].param0 |= ((nodes[i].param2&0xF0)<<4);
+				nodes[i].param0 <<= 4;
+				nodes[i].param0 |= (nodes[i].param2&0xF0)>>4;
 				nodes[i].param2 &= 0x0F;
 			}
 		}
@@ -423,40 +618,6 @@ void MapNode::deSerializeBulk(std::istream &is, int version,
 /*
 	Legacy serialization
 */
-void MapNode::serialize_pre22(u8 *dest, u8 version)
-{
-	// Translate to wanted version
-	MapNode n_foreign = mapnode_translate_from_internal(*this, version);
-
-	u8 actual_param0 = n_foreign.param0;
-
-	// Convert special values from new version to old
-	if(version <= 18)
-	{
-		// In these versions, CONTENT_IGNORE and CONTENT_AIR
-		// are 255 and 254
-		if(actual_param0 == CONTENT_IGNORE)
-			actual_param0 = 255;
-		else if(actual_param0 == CONTENT_AIR)
-			actual_param0 = 254;
-	}
-
-	if(version == 0)
-	{
-		dest[0] = actual_param0;
-	}
-	else if(version <= 9)
-	{
-		dest[0] = actual_param0;
-		dest[1] = n_foreign.param1;
-	}
-	else
-	{
-		dest[0] = actual_param0;
-		dest[1] = n_foreign.param1;
-		dest[2] = n_foreign.param2;
-	}
-}
 void MapNode::deSerialize_pre22(u8 *source, u8 version)
 {
 	if(version <= 1)
@@ -473,6 +634,11 @@ void MapNode::deSerialize_pre22(u8 *source, u8 version)
 		param0 = source[0];
 		param1 = source[1];
 		param2 = source[2];
+		if(param0 > 0x7f){
+			param0 <<= 4;
+			param0 |= (param2&0xf0)>>4;
+			param2 &= 0x0f;
+		}
 	}
 	
 	// Convert special values from old version to new