X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fnodedef.cpp;h=2b6de0461b14e505918d050b66152722b84bf1ee;hb=eda9214f81b32d9606f425e3777616e8cfc0a44f;hp=52d9fc8bf497d5b80ec75dcb5e00684084d5ecd2;hpb=e5650bb54917ead2dccac9b46dfa1a00cd737694;p=dragonfireclient.git

diff --git a/src/nodedef.cpp b/src/nodedef.cpp
index 52d9fc8bf..2b6de0461 100644
--- a/src/nodedef.cpp
+++ b/src/nodedef.cpp
@@ -1,18 +1,18 @@
 /*
-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 General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+GNU Lesser General Public License for more details.
 
-You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU Lesser General Public License along
 with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
@@ -20,62 +20,141 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "nodedef.h"
 
 #include "main.h" // For g_settings
-#include "nodemetadata.h"
+#include "itemdef.h"
 #ifndef SERVER
 #include "tile.h"
 #endif
 #include "log.h"
 #include "settings.h"
 #include "nameidmapping.h"
+#include "util/numeric.h"
+#include "util/serialize.h"
+//#include "profiler.h" // For TimeTaker
 
 /*
 	NodeBox
 */
 
-void NodeBox::serialize(std::ostream &os) const
+void NodeBox::reset()
 {
-	writeU8(os, 0); // version
-	writeU8(os, type);
-	writeV3F1000(os, fixed.MinEdge);
-	writeV3F1000(os, fixed.MaxEdge);
-	writeV3F1000(os, wall_top.MinEdge);
-	writeV3F1000(os, wall_top.MaxEdge);
-	writeV3F1000(os, wall_bottom.MinEdge);
-	writeV3F1000(os, wall_bottom.MaxEdge);
-	writeV3F1000(os, wall_side.MinEdge);
-	writeV3F1000(os, wall_side.MaxEdge);
+	type = NODEBOX_REGULAR;
+	// default is empty
+	fixed.clear();
+	// default is sign/ladder-like
+	wall_top = aabb3f(-BS/2, BS/2-BS/16., -BS/2, BS/2, BS/2, BS/2);
+	wall_bottom = aabb3f(-BS/2, -BS/2, -BS/2, BS/2, -BS/2+BS/16., BS/2);
+	wall_side = aabb3f(-BS/2, -BS/2, -BS/2, -BS/2+BS/16., BS/2, BS/2);
+}
+
+void NodeBox::serialize(std::ostream &os, u16 protocol_version) const
+{
+	int version = protocol_version >= 21 ? 2 : 1;
+	writeU8(os, version);
+
+	if (version == 1 && type == NODEBOX_LEVELED)
+		writeU8(os, NODEBOX_FIXED);
+	else
+		writeU8(os, type);
+
+	if(type == NODEBOX_FIXED || type == NODEBOX_LEVELED)
+	{
+		writeU16(os, fixed.size());
+		for(std::vector<aabb3f>::const_iterator
+				i = fixed.begin();
+				i != fixed.end(); i++)
+		{
+			writeV3F1000(os, i->MinEdge);
+			writeV3F1000(os, i->MaxEdge);
+		}
+	}
+	else if(type == NODEBOX_WALLMOUNTED)
+	{
+		writeV3F1000(os, wall_top.MinEdge);
+		writeV3F1000(os, wall_top.MaxEdge);
+		writeV3F1000(os, wall_bottom.MinEdge);
+		writeV3F1000(os, wall_bottom.MaxEdge);
+		writeV3F1000(os, wall_side.MinEdge);
+		writeV3F1000(os, wall_side.MaxEdge);
+	}
 }
 
 void NodeBox::deSerialize(std::istream &is)
 {
 	int version = readU8(is);
-	if(version != 0)
+	if(version < 1 || version > 2)
 		throw SerializationError("unsupported NodeBox version");
+
+	reset();
+
 	type = (enum NodeBoxType)readU8(is);
-	fixed.MinEdge = readV3F1000(is);
-	fixed.MaxEdge = readV3F1000(is);
-	wall_top.MinEdge = readV3F1000(is);
-	wall_top.MaxEdge = readV3F1000(is);
-	wall_bottom.MinEdge = readV3F1000(is);
-	wall_bottom.MaxEdge = readV3F1000(is);
-	wall_side.MinEdge = readV3F1000(is);
-	wall_side.MaxEdge = readV3F1000(is);
+
+	if(type == NODEBOX_FIXED || type == NODEBOX_LEVELED)
+	{
+		u16 fixed_count = readU16(is);
+		while(fixed_count--)
+		{
+			aabb3f box;
+			box.MinEdge = readV3F1000(is);
+			box.MaxEdge = readV3F1000(is);
+			fixed.push_back(box);
+		}
+	}
+	else if(type == NODEBOX_WALLMOUNTED)
+	{
+		wall_top.MinEdge = readV3F1000(is);
+		wall_top.MaxEdge = readV3F1000(is);
+		wall_bottom.MinEdge = readV3F1000(is);
+		wall_bottom.MaxEdge = readV3F1000(is);
+		wall_side.MinEdge = readV3F1000(is);
+		wall_side.MaxEdge = readV3F1000(is);
+	}
 }
 
 /*
-	MaterialSpec
+	TileDef
 */
 
-void MaterialSpec::serialize(std::ostream &os) const
+void TileDef::serialize(std::ostream &os, u16 protocol_version) const
+{
+	if(protocol_version >= 17)
+		writeU8(os, 1); 
+	else
+		writeU8(os, 0);
+	os<<serializeString(name);
+	writeU8(os, animation.type);
+	writeU16(os, animation.aspect_w);
+	writeU16(os, animation.aspect_h);
+	writeF1000(os, animation.length);
+	if(protocol_version >= 17)
+		writeU8(os, backface_culling);
+}
+
+void TileDef::deSerialize(std::istream &is)
 {
-	os<<serializeString(tname);
-	writeU8(os, backface_culling);
+	int version = readU8(is);
+	name = deSerializeString(is);
+	animation.type = (TileAnimationType)readU8(is);
+	animation.aspect_w = readU16(is);
+	animation.aspect_h = readU16(is);
+	animation.length = readF1000(is);
+	if(version >= 1)
+		backface_culling = readU8(is);
 }
 
-void MaterialSpec::deSerialize(std::istream &is)
+/*
+	SimpleSoundSpec serialization
+*/
+
+static void serializeSimpleSoundSpec(const SimpleSoundSpec &ss,
+		std::ostream &os)
 {
-	tname = deSerializeString(is);
-	backface_culling = readU8(is);
+	os<<serializeString(ss.name);
+	writeF1000(os, ss.gain);
+}
+static void deSerializeSimpleSoundSpec(SimpleSoundSpec &ss, std::istream &is)
+{
+	ss.name = deSerializeString(is);
+	ss.gain = readF1000(is);
 }
 
 /*
@@ -89,12 +168,6 @@ ContentFeatures::ContentFeatures()
 
 ContentFeatures::~ContentFeatures()
 {
-#ifndef SERVER
-	for(u16 j=0; j<CF_SPECIAL_COUNT; j++){
-		delete special_materials[j];
-		delete special_aps[j];
-	}
-#endif
 }
 
 void ContentFeatures::reset()
@@ -103,31 +176,33 @@ void ContentFeatures::reset()
 		Cached stuff
 	*/
 #ifndef SERVER
-	inventory_texture = NULL;
-	
-	for(u16 j=0; j<CF_SPECIAL_COUNT; j++){
-		special_materials[j] = NULL;
-		special_aps[j] = NULL;
-	}
 	solidness = 2;
 	visual_solidness = 0;
 	backface_culling = true;
 #endif
-	used_texturenames.clear();
+	has_on_construct = false;
+	has_on_destruct = false;
+	has_after_destruct = false;
 	/*
 		Actual data
+
+		NOTE: Most of this is always overridden by the default values given
+		      in builtin.lua
 	*/
 	name = "";
+	groups.clear();
+	// Unknown nodes can be dug
+	groups["dig_immediate"] = 2;
 	drawtype = NDT_NORMAL;
 	visual_scale = 1.0;
 	for(u32 i=0; i<6; i++)
-		tname_tiles[i] = "";
+		tiledef[i] = TileDef();
 	for(u16 j=0; j<CF_SPECIAL_COUNT; j++)
-		mspec_special[j] = MaterialSpec();
-	tname_inventory = "";
+		tiledef_special[j] = TileDef();
 	alpha = 255;
 	post_effect_color = video::SColor(0, 0, 0, 0);
 	param_type = CPT_NONE;
+	param_type_2 = CPT2_NONE;
 	is_ground_content = false;
 	light_propagates = false;
 	sunlight_propagates = false;
@@ -136,39 +211,51 @@ void ContentFeatures::reset()
 	diggable = true;
 	climbable = false;
 	buildable_to = false;
-	wall_mounted = false;
-	air_equivalent = false;
-	often_contains_mineral = false;
-	dug_item = "";
-	extra_dug_item = "";
-	extra_dug_item_rarity = 2;
-	metadata_name = "";
+	rightclickable = true;
+	leveled = 0;
 	liquid_type = LIQUID_NONE;
 	liquid_alternative_flowing = "";
 	liquid_alternative_source = "";
 	liquid_viscosity = 0;
+	liquid_renewable = true;
+	freezemelt = "";
+	liquid_range = LIQUID_LEVEL_MAX+1;
+	drowning = 0;
 	light_source = 0;
 	damage_per_second = 0;
+	node_box = NodeBox();
 	selection_box = NodeBox();
-	material = MaterialProperties();
-	cookresult_item = ""; // Cannot be cooked
-	furnace_cooktime = 3.0;
-	furnace_burntime = -1.0; // Cannot be burned
+	waving = 0;
+	legacy_facedir_simple = false;
+	legacy_wallmounted = false;
+	sound_footstep = SimpleSoundSpec();
+	sound_dig = SimpleSoundSpec("__group");
+	sound_dug = SimpleSoundSpec();
 }
 
-void ContentFeatures::serialize(std::ostream &os)
+void ContentFeatures::serialize(std::ostream &os, u16 protocol_version)
 {
-	writeU8(os, 0); // version
+	if(protocol_version < 14){
+		serializeOld(os, protocol_version);
+		return;
+	}
+
+	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++)
-		os<<serializeString(tname_tiles[i]);
-	os<<serializeString(tname_inventory);
+		tiledef[i].serialize(os, protocol_version);
 	writeU8(os, CF_SPECIAL_COUNT);
 	for(u32 i=0; i<CF_SPECIAL_COUNT; i++){
-		mspec_special[i].serialize(os);
+		tiledef_special[i].serialize(os, protocol_version);
 	}
 	writeU8(os, alpha);
 	writeU8(os, post_effect_color.getAlpha());
@@ -176,6 +263,7 @@ void ContentFeatures::serialize(std::ostream &os)
 	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);
@@ -184,50 +272,63 @@ void ContentFeatures::serialize(std::ostream &os)
 	writeU8(os, diggable);
 	writeU8(os, climbable);
 	writeU8(os, buildable_to);
-	writeU8(os, wall_mounted);
-	writeU8(os, air_equivalent);
-	writeU8(os, often_contains_mineral);
-	os<<serializeString(dug_item);
-	os<<serializeString(extra_dug_item);
-	writeS32(os, extra_dug_item_rarity);
-	os<<serializeString(metadata_name);
+	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);
-	selection_box.serialize(os);
-	material.serialize(os);
-	os<<serializeString(cookresult_item);
-	writeF1000(os, furnace_cooktime);
-	writeF1000(os, furnace_burntime);
+	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);
+	// Stuff below should be moved to correct place in a version that otherwise changes
+	// the protocol version
+	writeU8(os, waving);
 }
 
-void ContentFeatures::deSerialize(std::istream &is, IGameDef *gamedef)
+void ContentFeatures::deSerialize(std::istream &is)
 {
 	int version = readU8(is);
-	if(version != 0)
-		throw SerializationError("unsupported ContentFeatures version");
+	if(version != 6){
+		deSerializeOld(is, version);
+		return;
+	}
+
 	name = deSerializeString(is);
+	groups.clear();
+	u32 groups_size = readU16(is);
+	for(u32 i=0; i<groups_size; i++){
+		std::string name = deSerializeString(is);
+		int value = readS16(is);
+		groups[name] = value;
+	}
 	drawtype = (enum NodeDrawType)readU8(is);
 	visual_scale = readF1000(is);
 	if(readU8(is) != 6)
 		throw SerializationError("unsupported tile count");
 	for(u32 i=0; i<6; i++)
-		tname_tiles[i] = deSerializeString(is);
-	tname_inventory = deSerializeString(is);
+		tiledef[i].deSerialize(is);
 	if(readU8(is) != CF_SPECIAL_COUNT)
 		throw SerializationError("unsupported CF_SPECIAL_COUNT");
-	for(u32 i=0; i<CF_SPECIAL_COUNT; i++){
-		mspec_special[i].deSerialize(is);
-	}
+	for(u32 i=0; i<CF_SPECIAL_COUNT; i++)
+		tiledef_special[i].deSerialize(is);
 	alpha = readU8(is);
 	post_effect_color.setAlpha(readU8(is));
 	post_effect_color.setRed(readU8(is));
 	post_effect_color.setGreen(readU8(is));
 	post_effect_color.setBlue(readU8(is));
 	param_type = (enum ContentParamType)readU8(is);
+	param_type_2 = (enum ContentParamType2)readU8(is);
 	is_ground_content = readU8(is);
 	light_propagates = readU8(is);
 	sunlight_propagates = readU8(is);
@@ -236,68 +337,32 @@ void ContentFeatures::deSerialize(std::istream &is, IGameDef *gamedef)
 	diggable = readU8(is);
 	climbable = readU8(is);
 	buildable_to = readU8(is);
-	wall_mounted = readU8(is);
-	air_equivalent = readU8(is);
-	often_contains_mineral = readU8(is);
-	dug_item = deSerializeString(is);
-	extra_dug_item = deSerializeString(is);
-	extra_dug_item_rarity = readS32(is);
-	metadata_name = deSerializeString(is);
+	deSerializeString(is); // legacy: used to be metadata_name
 	liquid_type = (enum LiquidType)readU8(is);
 	liquid_alternative_flowing = deSerializeString(is);
 	liquid_alternative_source = deSerializeString(is);
 	liquid_viscosity = readU8(is);
+	liquid_renewable = readU8(is);
 	light_source = readU8(is);
 	damage_per_second = readU32(is);
+	node_box.deSerialize(is);
 	selection_box.deSerialize(is);
-	material.deSerialize(is);
-	cookresult_item = deSerializeString(is);
-	furnace_cooktime = readF1000(is);
-	furnace_burntime = readF1000(is);
-}
-
-void ContentFeatures::setTexture(u16 i, std::string name)
-{
-	used_texturenames.insert(name);
-	tname_tiles[i] = name;
-	if(tname_inventory == "")
-		tname_inventory = name;
-}
-
-void ContentFeatures::setAllTextures(std::string name)
-{
-	for(u16 i=0; i<6; i++)
-		setTexture(i, name);
-	// Force inventory texture too
-	setInventoryTexture(name);
-}
-
-void ContentFeatures::setSpecialMaterial(u16 i, const MaterialSpec &mspec)
-{
-	assert(i < CF_SPECIAL_COUNT);
-	mspec_special[i] = mspec;
-}
-
-void ContentFeatures::setInventoryTexture(std::string imgname)
-{
-	tname_inventory = imgname + "^[forcesingle";
-}
-
-void ContentFeatures::setInventoryTextureCube(std::string top,
-		std::string left, std::string right)
-{
-	str_replace_char(top, '^', '&');
-	str_replace_char(left, '^', '&');
-	str_replace_char(right, '^', '&');
-
-	std::string imgname_full;
-	imgname_full += "[inventorycube{";
-	imgname_full += top;
-	imgname_full += "{";
-	imgname_full += left;
-	imgname_full += "{";
-	imgname_full += right;
-	tname_inventory = imgname_full;
+	legacy_facedir_simple = readU8(is);
+	legacy_wallmounted = readU8(is);
+	deSerializeSimpleSoundSpec(sound_footstep, is);
+	deSerializeSimpleSoundSpec(sound_dig, is);
+	deSerializeSimpleSoundSpec(sound_dug, is);
+	rightclickable = readU8(is);
+	drowning = readU8(is);
+	leveled = readU8(is);
+	liquid_range = readU8(is);
+	// If you add anything here, insert it primarily inside the try-catch
+	// block to not need to increase the version.
+	try{
+		// Stuff below should be moved to correct place in a version that
+		// otherwise changes the protocol version
+	waving = readU8(is);
+	}catch(SerializationError &e) {};
 }
 
 /*
@@ -309,65 +374,66 @@ class CNodeDefManager: public IWritableNodeDefManager
 public:
 	void clear()
 	{
+		m_content_features.clear();
 		m_name_id_mapping.clear();
-		for(u16 i=0; i<=MAX_CONTENT; i++)
+		m_name_id_mapping_with_aliases.clear();
+		m_group_to_items.clear();
+		m_next_id = 0;
+
+		u32 initial_length = 0;
+		initial_length = MYMAX(initial_length, CONTENT_UNKNOWN + 1);
+		initial_length = MYMAX(initial_length, CONTENT_AIR + 1);
+		initial_length = MYMAX(initial_length, CONTENT_IGNORE + 1);
+		m_content_features.resize(initial_length);
+
+		// Set CONTENT_UNKNOWN
 		{
-			ContentFeatures &f = m_content_features[i];
-			f.reset(); // Reset to defaults
-			f.setAllTextures("unknown_block.png");
+			ContentFeatures f;
+			f.name = "unknown";
+			// Insert directly into containers
+			content_t c = CONTENT_UNKNOWN;
+			m_content_features[c] = f;
+			addNameIdMapping(c, f.name);
 		}
-		
+
 		// Set CONTENT_AIR
 		{
 			ContentFeatures f;
-			f.name = "air";
-			f.drawtype = NDT_AIRLIKE;
-			f.param_type = CPT_LIGHT;
-			f.light_propagates = true;
+			f.name                = "air";
+			f.drawtype            = NDT_AIRLIKE;
+			f.param_type          = CPT_LIGHT;
+			f.light_propagates    = true;
 			f.sunlight_propagates = true;
-			f.walkable = false;
-			f.pointable = false;
-			f.diggable = false;
-			f.buildable_to = true;
-			f.air_equivalent = true;
-			set(CONTENT_AIR, f);
+			f.walkable            = false;
+			f.pointable           = false;
+			f.diggable            = false;
+			f.buildable_to        = true;
+			f.is_ground_content   = true;
+			// Insert directly into containers
+			content_t c = CONTENT_AIR;
+			m_content_features[c] = f;
+			addNameIdMapping(c, f.name);
 		}
+
 		// Set CONTENT_IGNORE
 		{
 			ContentFeatures f;
-			f.name = "ignore";
-			f.drawtype = NDT_AIRLIKE;
-			f.param_type = CPT_NONE;
-			f.light_propagates = false;
+			f.name                = "ignore";
+			f.drawtype            = NDT_AIRLIKE;
+			f.param_type          = CPT_NONE;
+			f.light_propagates    = false;
 			f.sunlight_propagates = false;
-			f.walkable = false;
-			f.pointable = false;
-			f.diggable = false;
-			// A way to remove accidental CONTENT_IGNOREs
-			f.buildable_to = true;
-			f.air_equivalent = true;
-			set(CONTENT_IGNORE, f);
+			f.walkable            = false;
+			f.pointable           = false;
+			f.diggable            = false;
+			f.buildable_to        = true; // A way to remove accidental CONTENT_IGNOREs
+			f.is_ground_content   = true;
+			// Insert directly into containers
+			content_t c = CONTENT_IGNORE;
+			m_content_features[c] = f;
+			addNameIdMapping(c, f.name);
 		}
 	}
-	// CONTENT_IGNORE = not found
-	content_t getFreeId(bool require_full_param2)
-	{
-		// If allowed, first search in the large 4-byte-param2 pool
-		if(!require_full_param2){
-			for(u16 i=0x800; i<=0xfff; i++){
-				const ContentFeatures &f = m_content_features[i];
-				if(f.name == "")
-					return i;
-			}
-		}
-		// Then search from the small 8-byte-param2 pool
-		for(u16 i=0; i<=125; i++){
-			const ContentFeatures &f = m_content_features[i];
-			if(f.name == "")
-				return i;
-		}
-		return CONTENT_IGNORE;
-	}
 	CNodeDefManager()
 	{
 		clear();
@@ -378,16 +444,15 @@ class CNodeDefManager: public IWritableNodeDefManager
 	virtual IWritableNodeDefManager* clone()
 	{
 		CNodeDefManager *mgr = new CNodeDefManager();
-		for(u16 i=0; i<=MAX_CONTENT; i++)
-		{
-			mgr->set(i, get(i));
-		}
+		*mgr = *this;
 		return mgr;
 	}
 	virtual const ContentFeatures& get(content_t c) const
 	{
-		assert(c <= MAX_CONTENT);
-		return m_content_features[c];
+		if(c < m_content_features.size())
+			return m_content_features[c];
+		else
+			return m_content_features[CONTENT_UNKNOWN];
 	}
 	virtual const ContentFeatures& get(const MapNode &n) const
 	{
@@ -395,7 +460,12 @@ class CNodeDefManager: public IWritableNodeDefManager
 	}
 	virtual bool getId(const std::string &name, content_t &result) const
 	{
-		return m_name_id_mapping.getId(name, result);
+		std::map<std::string, content_t>::const_iterator
+			i = m_name_id_mapping_with_aliases.find(name);
+		if(i == m_name_id_mapping_with_aliases.end())
+			return false;
+		result = i->second;
+		return true;
 	}
 	virtual content_t getId(const std::string &name) const
 	{
@@ -403,56 +473,104 @@ class CNodeDefManager: public IWritableNodeDefManager
 		getId(name, id);
 		return id;
 	}
+	virtual void getIds(const std::string &name, std::set<content_t> &result)
+			const
+	{
+		//TimeTaker t("getIds", NULL, PRECISION_MICRO);
+		if(name.substr(0,6) != "group:"){
+			content_t id = CONTENT_IGNORE;
+			if(getId(name, id))
+				result.insert(id);
+			return;
+		}
+		std::string group = name.substr(6);
+
+		std::map<std::string, GroupItems>::const_iterator
+			i = m_group_to_items.find(group);
+		if (i == m_group_to_items.end())
+			return;
+
+		const GroupItems &items = i->second;
+		for (GroupItems::const_iterator j = items.begin();
+			j != items.end(); ++j) {
+			if ((*j).second != 0)
+				result.insert((*j).first);
+		}
+		//printf("getIds: %dus\n", t.stop());
+	}
 	virtual const ContentFeatures& get(const std::string &name) const
 	{
-		content_t id = CONTENT_IGNORE;
+		content_t id = CONTENT_UNKNOWN;
 		getId(name, id);
 		return get(id);
 	}
-	// IWritableNodeDefManager
-	virtual void set(content_t c, const ContentFeatures &def)
+	// returns CONTENT_IGNORE if no free ID found
+	content_t allocateId()
 	{
-		infostream<<"registerNode: registering content id \""<<c
-				<<"\": name=\""<<def.name<<"\""<<std::endl;
-		assert(c <= MAX_CONTENT);
-		// Check that the special contents are not redefined as different id
-		// because it would mess up everything
-		if((def.name == "ignore" && c != CONTENT_IGNORE) ||
-			(def.name == "air" && c != CONTENT_AIR)){
-			errorstream<<"registerNode: IGNORING ERROR: "
-					<<"trying to register built-in type \""
-					<<def.name<<"\" as different id"<<std::endl;
-			return;
+		for(content_t id = m_next_id;
+				id >= m_next_id; // overflow?
+				++id){
+			while(id >= m_content_features.size()){
+				m_content_features.push_back(ContentFeatures());
+			}
+			const ContentFeatures &f = m_content_features[id];
+			if(f.name == ""){
+				m_next_id = id + 1;
+				return id;
+			}
 		}
-		m_content_features[c] = def;
-		if(def.name != "")
-			m_name_id_mapping.set(c, def.name);
+		// If we arrive here, an overflow occurred in id.
+		// That means no ID was found
+		return CONTENT_IGNORE;
 	}
+	// IWritableNodeDefManager
 	virtual content_t set(const std::string &name,
 			const ContentFeatures &def)
 	{
+		assert(name != "");
 		assert(name == def.name);
-		u16 id = CONTENT_IGNORE;
-		bool found = m_name_id_mapping.getId(name, id);
+
+		// Don't allow redefining ignore (but allow air and unknown)
+		if(name == "ignore"){
+			infostream<<"NodeDefManager: WARNING: Ignoring "
+					<<"CONTENT_IGNORE redefinition"<<std::endl;
+			return CONTENT_IGNORE;
+		}
+
+		content_t id = CONTENT_IGNORE;
+		bool found = m_name_id_mapping.getId(name, id);  // ignore aliases
 		if(!found){
-			// Determine if full param2 is required
-			bool require_full_param2 = (
-				def.liquid_type == LIQUID_FLOWING
-				||
-				def.drawtype == NDT_FLOWINGLIQUID
-				||
-				def.drawtype == NDT_TORCHLIKE
-				||
-				def.drawtype == NDT_SIGNLIKE
-			);
-			// Get some id
-			id = getFreeId(require_full_param2);
-			if(id == CONTENT_IGNORE)
+			// Get new id
+			id = allocateId();
+			if(id == CONTENT_IGNORE){
+				infostream<<"NodeDefManager: WARNING: Absolute "
+						<<"limit reached"<<std::endl;
 				return CONTENT_IGNORE;
-			if(name != "")
-				m_name_id_mapping.set(id, name);
+			}
+			assert(id != CONTENT_IGNORE);
+			addNameIdMapping(id, name);
+		}
+		m_content_features[id] = def;
+		verbosestream<<"NodeDefManager: registering content id \""<<id
+				<<"\": name=\""<<def.name<<"\""<<std::endl;
+
+		// Add this content to the list of all groups it belongs to
+		// FIXME: This should remove a node from groups it no longer
+		// belongs to when a node is re-registered
+		for (ItemGroupList::const_iterator i = def.groups.begin();
+			i != def.groups.end(); ++i) {
+			std::string group_name = i->first;
+			
+			std::map<std::string, GroupItems>::iterator
+				j = m_group_to_items.find(group_name);
+			if (j == m_group_to_items.end()) {
+				m_group_to_items[group_name].push_back(
+						std::make_pair(id, i->second));
+			} else {
+				GroupItems &items = j->second;
+				items.push_back(std::make_pair(id, i->second));
+			}
 		}
-		set(id, def);
 		return id;
 	}
 	virtual content_t allocateDummy(const std::string &name)
@@ -460,9 +578,25 @@ class CNodeDefManager: public IWritableNodeDefManager
 		assert(name != "");
 		ContentFeatures f;
 		f.name = name;
-		f.setAllTextures("unknown_block.png");
 		return set(name, f);
 	}
+	virtual void updateAliases(IItemDefManager *idef)
+	{
+		std::set<std::string> all = idef->getAll();
+		m_name_id_mapping_with_aliases.clear();
+		for(std::set<std::string>::iterator
+				i = all.begin(); i != all.end(); i++)
+		{
+			std::string name = *i;
+			std::string convert_to = idef->getAlias(name);
+			content_t id;
+			if(m_name_id_mapping.getId(convert_to, id))
+			{
+				m_name_id_mapping_with_aliases.insert(
+						std::make_pair(name, id));
+			}
+		}
+	}
 	virtual void updateTextures(ITextureSource *tsrc)
 	{
 #ifndef SERVER
@@ -472,11 +606,24 @@ class CNodeDefManager: public IWritableNodeDefManager
 		bool new_style_water = g_settings->getBool("new_style_water");
 		bool new_style_leaves = g_settings->getBool("new_style_leaves");
 		bool opaque_water = g_settings->getBool("opaque_water");
-		
-		for(u16 i=0; i<=MAX_CONTENT; i++)
+
+		for(u32 i=0; i<m_content_features.size(); i++)
 		{
 			ContentFeatures *f = &m_content_features[i];
 
+			// Figure out the actual tiles to use
+			TileDef tiledef[6];
+			for(u32 j=0; j<6; j++)
+			{
+				tiledef[j] = f->tiledef[j];
+				if(tiledef[j].name == "")
+					tiledef[j].name = "unknown_node.png";
+			}
+
+			bool is_liquid = false;
+			u8 material_type;
+			material_type = (f->alpha == 255) ? TILE_MATERIAL_BASIC : TILE_MATERIAL_ALPHA;
+
 			switch(f->drawtype){
 			default:
 			case NDT_NORMAL:
@@ -493,20 +640,25 @@ class CNodeDefManager: public IWritableNodeDefManager
 					f->solidness = 0;
 				} else {
 					f->solidness = 1;
-					if(f->alpha == 255)
-						f->solidness = 2;
+					f->backface_culling = false;
 				}
+				is_liquid = true;
 				break;
 			case NDT_FLOWINGLIQUID:
 				assert(f->liquid_type == LIQUID_FLOWING);
 				f->solidness = 0;
 				if(opaque_water)
 					f->alpha = 255;
+				is_liquid = true;
 				break;
 			case NDT_GLASSLIKE:
 				f->solidness = 0;
 				f->visual_solidness = 1;
 				break;
+			case NDT_GLASSLIKE_FRAMED:
+				f->solidness = 0;
+				f->visual_solidness = 1;
+				break;
 			case NDT_ALLFACES:
 				f->solidness = 0;
 				f->visual_solidness = 1;
@@ -518,115 +670,213 @@ class CNodeDefManager: public IWritableNodeDefManager
 					f->visual_solidness = 1;
 				} else {
 					f->drawtype = NDT_NORMAL;
-					f->solidness = 1;
+					f->solidness = 2;
 					for(u32 i=0; i<6; i++){
-						f->tname_tiles[i] = f->tname_tiles[i]
-								+ std::string("^[noalpha");
+						tiledef[i].name += std::string("^[noalpha");
 					}
 				}
+				if (f->waving == 1)
+					material_type = TILE_MATERIAL_LEAVES;
+				break;
+			case NDT_PLANTLIKE:
+				f->solidness = 0;
+				f->backface_culling = false;
+				if (f->waving == 1)
+					material_type = TILE_MATERIAL_PLANTS;
 				break;
 			case NDT_TORCHLIKE:
 			case NDT_SIGNLIKE:
-			case NDT_PLANTLIKE:
 			case NDT_FENCELIKE:
 			case NDT_RAILLIKE:
+			case NDT_NODEBOX:
 				f->solidness = 0;
 				break;
 			}
 
-			// Inventory texture
-			if(f->tname_inventory != "")
-				f->inventory_texture = tsrc->getTextureRaw(f->tname_inventory);
-			else
-				f->inventory_texture = NULL;
-			// Tile textures
+			if (is_liquid)
+				material_type = (f->alpha == 255) ? TILE_MATERIAL_LIQUID_OPAQUE : TILE_MATERIAL_LIQUID_TRANSPARENT;
+
+			// Tiles (fill in f->tiles[])
 			for(u16 j=0; j<6; j++){
-				if(f->tname_tiles[j] == "")
-					continue;
-				f->tiles[j].texture = tsrc->getTexture(f->tname_tiles[j]);
+				// Texture
+				f->tiles[j].texture = tsrc->getTexture(
+						tiledef[j].name,
+						&f->tiles[j].texture_id);
+				// Alpha
 				f->tiles[j].alpha = f->alpha;
-				if(f->alpha == 255)
-					f->tiles[j].material_type = MATERIAL_ALPHA_SIMPLE;
-				else
-					f->tiles[j].material_type = MATERIAL_ALPHA_VERTEX;
+				// Material type
+				f->tiles[j].material_type = material_type;
+				// Material flags
+				f->tiles[j].material_flags = 0;
 				if(f->backface_culling)
 					f->tiles[j].material_flags |= MATERIAL_FLAG_BACKFACE_CULLING;
-				else
-					f->tiles[j].material_flags &= ~MATERIAL_FLAG_BACKFACE_CULLING;
+				if(tiledef[j].animation.type == TAT_VERTICAL_FRAMES)
+					f->tiles[j].material_flags |= MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES;
+				// Animation parameters
+				if(f->tiles[j].material_flags &
+						MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES)
+				{
+					// Get texture size to determine frame count by
+					// aspect ratio
+					v2u32 size = f->tiles[j].texture->getOriginalSize();
+					int frame_height = (float)size.X /
+							(float)tiledef[j].animation.aspect_w *
+							(float)tiledef[j].animation.aspect_h;
+					int frame_count = size.Y / frame_height;
+					int frame_length_ms = 1000.0 *
+							tiledef[j].animation.length / frame_count;
+					f->tiles[j].animation_frame_count = frame_count;
+					f->tiles[j].animation_frame_length_ms = frame_length_ms;
+
+					// If there are no frames for an animation, switch
+					// animation off (so that having specified an animation
+					// for something but not using it in the texture pack
+					// gives no overhead)
+					if(frame_count == 1){
+						f->tiles[j].material_flags &=
+								~MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES;
+					}
+				}
 			}
-			// Special textures
+			// Special tiles (fill in f->special_tiles[])
 			for(u16 j=0; j<CF_SPECIAL_COUNT; j++){
-				// Remove all stuff
-				if(f->special_aps[j]){
-					delete f->special_aps[j];
-					f->special_aps[j] = NULL;
-				}
-				if(f->special_materials[j]){
-					delete f->special_materials[j];
-					f->special_materials[j] = NULL;
+				// Texture
+				f->special_tiles[j].texture = tsrc->getTexture(
+						f->tiledef_special[j].name,
+						&f->special_tiles[j].texture_id);
+				// Alpha
+				f->special_tiles[j].alpha = f->alpha;
+				// Material type
+				f->special_tiles[j].material_type = material_type;
+				// Material flags
+				f->special_tiles[j].material_flags = 0;
+				if(f->tiledef_special[j].backface_culling)
+					f->special_tiles[j].material_flags |= MATERIAL_FLAG_BACKFACE_CULLING;
+				if(f->tiledef_special[j].animation.type == TAT_VERTICAL_FRAMES)
+					f->special_tiles[j].material_flags |= MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES;
+				// Animation parameters
+				if(f->special_tiles[j].material_flags &
+						MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES)
+				{
+					// Get texture size to determine frame count by
+					// aspect ratio
+					v2u32 size = f->special_tiles[j].texture->getOriginalSize();
+					int frame_height = (float)size.X /
+							(float)f->tiledef_special[j].animation.aspect_w *
+							(float)f->tiledef_special[j].animation.aspect_h;
+					int frame_count = size.Y / frame_height;
+					int frame_length_ms = 1000.0 *
+							f->tiledef_special[j].animation.length / frame_count;
+					f->special_tiles[j].animation_frame_count = frame_count;
+					f->special_tiles[j].animation_frame_length_ms = frame_length_ms;
+
+					// If there are no frames for an animation, switch
+					// animation off (so that having specified an animation
+					// for something but not using it in the texture pack
+					// gives no overhead)
+					if(frame_count == 1){
+						f->special_tiles[j].material_flags &=
+								~MATERIAL_FLAG_ANIMATION_VERTICAL_FRAMES;
+					}
 				}
-				// Skip if should not exist
-				if(f->mspec_special[j].tname == "")
-					continue;
-				// Create all stuff
-				f->special_aps[j] = new AtlasPointer(
-						tsrc->getTexture(f->mspec_special[j].tname));
-				f->special_materials[j] = new video::SMaterial;
-				f->special_materials[j]->setFlag(video::EMF_LIGHTING, false);
-				f->special_materials[j]->setFlag(video::EMF_BACK_FACE_CULLING,
-						f->mspec_special[j].backface_culling);
-				f->special_materials[j]->setFlag(video::EMF_BILINEAR_FILTER, false);
-				f->special_materials[j]->setFlag(video::EMF_FOG_ENABLE, true);
-				f->special_materials[j]->setTexture(0, f->special_aps[j]->atlas);
-				if(f->alpha != 255)
-					f->special_materials[j]->MaterialType =
-							video::EMT_TRANSPARENT_VERTEX_ALPHA;
 			}
 		}
 #endif
 	}
-	void serialize(std::ostream &os)
+	void serialize(std::ostream &os, u16 protocol_version)
 	{
+		writeU8(os, 1); // version
 		u16 count = 0;
-		std::ostringstream tmp_os(std::ios::binary);
-		for(u16 i=0; i<=MAX_CONTENT; i++)
+		std::ostringstream os2(std::ios::binary);
+		for(u32 i=0; i<m_content_features.size(); i++)
 		{
-			if(i == CONTENT_IGNORE || i == CONTENT_AIR)
+			if(i == CONTENT_IGNORE || i == CONTENT_AIR
+					|| i == CONTENT_UNKNOWN)
 				continue;
 			ContentFeatures *f = &m_content_features[i];
 			if(f->name == "")
 				continue;
-			writeU16(tmp_os, i);
-			f->serialize(tmp_os);
+			writeU16(os2, i);
+			// Wrap it in a string to allow different lengths without
+			// strict version incompatibilities
+			std::ostringstream wrapper_os(std::ios::binary);
+			f->serialize(wrapper_os, protocol_version);
+			os2<<serializeString(wrapper_os.str());
+
+			assert(count + 1 > count); // must not overflow
 			count++;
 		}
 		writeU16(os, count);
-		os<<serializeLongString(tmp_os.str());
+		os<<serializeLongString(os2.str());
 	}
-	void deSerialize(std::istream &is, IGameDef *gamedef)
+	void deSerialize(std::istream &is)
 	{
 		clear();
+		int version = readU8(is);
+		if(version != 1)
+			throw SerializationError("unsupported NodeDefinitionManager version");
 		u16 count = readU16(is);
-		std::istringstream tmp_is(deSerializeLongString(is), std::ios::binary);
+		std::istringstream is2(deSerializeLongString(is), std::ios::binary);
+		ContentFeatures f;
 		for(u16 n=0; n<count; n++){
-			u16 i = readU16(tmp_is);
-			if(i > MAX_CONTENT){
-				errorstream<<"ContentFeatures::deSerialize(): "
-						<<"Too large content id: "<<i<<std::endl;
+			u16 i = readU16(is2);
+
+			// Read it from the string wrapper
+			std::string wrapper = deSerializeString(is2);
+			std::istringstream wrapper_is(wrapper, std::ios::binary);
+			f.deSerialize(wrapper_is);
+
+			// Check error conditions
+			if(i == CONTENT_IGNORE || i == CONTENT_AIR
+					|| i == CONTENT_UNKNOWN){
+				infostream<<"NodeDefManager::deSerialize(): WARNING: "
+					<<"not changing builtin node "<<i
+					<<std::endl;
 				continue;
 			}
-			/*// Do not deserialize special types
-			if(i == CONTENT_IGNORE || i == CONTENT_AIR)
-				continue;*/
-			ContentFeatures *f = &m_content_features[i];
-			f->deSerialize(tmp_is, gamedef);
-			if(f->name != "")
-				m_name_id_mapping.set(i, f->name);
+			if(f.name == ""){
+				infostream<<"NodeDefManager::deSerialize(): WARNING: "
+					<<"received empty name"<<std::endl;
+				continue;
+			}
+			u16 existing_id;
+			bool found = m_name_id_mapping.getId(f.name, existing_id);  // ignore aliases
+			if(found && i != existing_id){
+				infostream<<"NodeDefManager::deSerialize(): WARNING: "
+					<<"already defined with different ID: "
+					<<f.name<<std::endl;
+				continue;
+			}
+
+			// All is ok, add node definition with the requested ID
+			if(i >= m_content_features.size())
+				m_content_features.resize((u32)(i) + 1);
+			m_content_features[i] = f;
+			addNameIdMapping(i, f.name);
+			verbosestream<<"deserialized "<<f.name<<std::endl;
 		}
 	}
 private:
-	ContentFeatures m_content_features[MAX_CONTENT+1];
+	void addNameIdMapping(content_t i, std::string name)
+	{
+		m_name_id_mapping.set(i, name);
+		m_name_id_mapping_with_aliases.insert(std::make_pair(name, i));
+	}
+private:
+	// Features indexed by id
+	std::vector<ContentFeatures> m_content_features;
+	// A mapping for fast converting back and forth between names and ids
 	NameIdMapping m_name_id_mapping;
+	// Like m_name_id_mapping, but only from names to ids, and includes
+	// item aliases too. Updated by updateAliases()
+	// Note: Not serialized.
+	std::map<std::string, content_t> m_name_id_mapping_with_aliases;
+	// A mapping from groups to a list of content_ts (and their levels)
+	// that belong to it.  Necessary for a direct lookup in getIds().
+	// Note: Not serialized.
+	std::map<std::string, GroupItems> m_group_to_items;
+	// Next possibly free id
+	content_t m_next_id;
 };
 
 IWritableNodeDefManager* createNodeDefManager()
@@ -634,3 +884,122 @@ IWritableNodeDefManager* createNodeDefManager()
 	return new CNodeDefManager();
 }
 
+/*
+	Serialization of old ContentFeatures formats
+*/
+
+void ContentFeatures::serializeOld(std::ostream &os, u16 protocol_version)
+{
+	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);
+		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, 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
+	{
+		throw SerializationError("ContentFeatures::serialize(): Unsupported version requested");
+	}
+}
+
+void ContentFeatures::deSerializeOld(std::istream &is, int version)
+{
+	if(version == 5) // In PROTOCOL_VERSION 13
+	{
+		name = deSerializeString(is);
+		groups.clear();
+		u32 groups_size = readU16(is);
+		for(u32 i=0; i<groups_size; i++){
+			std::string name = deSerializeString(is);
+			int value = readS16(is);
+			groups[name] = value;
+		}
+		drawtype = (enum NodeDrawType)readU8(is);
+		visual_scale = readF1000(is);
+		if(readU8(is) != 6)
+			throw SerializationError("unsupported tile count");
+		for(u32 i=0; i<6; i++)
+			tiledef[i].deSerialize(is);
+		if(readU8(is) != CF_SPECIAL_COUNT)
+			throw SerializationError("unsupported CF_SPECIAL_COUNT");
+		for(u32 i=0; i<CF_SPECIAL_COUNT; i++)
+			tiledef_special[i].deSerialize(is);
+		alpha = readU8(is);
+		post_effect_color.setAlpha(readU8(is));
+		post_effect_color.setRed(readU8(is));
+		post_effect_color.setGreen(readU8(is));
+		post_effect_color.setBlue(readU8(is));
+		param_type = (enum ContentParamType)readU8(is);
+		param_type_2 = (enum ContentParamType2)readU8(is);
+		is_ground_content = readU8(is);
+		light_propagates = readU8(is);
+		sunlight_propagates = readU8(is);
+		walkable = readU8(is);
+		pointable = readU8(is);
+		diggable = readU8(is);
+		climbable = readU8(is);
+		buildable_to = readU8(is);
+		deSerializeString(is); // legacy: used to be metadata_name
+		liquid_type = (enum LiquidType)readU8(is);
+		liquid_alternative_flowing = deSerializeString(is);
+		liquid_alternative_source = deSerializeString(is);
+		liquid_viscosity = readU8(is);
+		light_source = readU8(is);
+		damage_per_second = readU32(is);
+		node_box.deSerialize(is);
+		selection_box.deSerialize(is);
+		legacy_facedir_simple = readU8(is);
+		legacy_wallmounted = readU8(is);
+		deSerializeSimpleSoundSpec(sound_footstep, is);
+		deSerializeSimpleSoundSpec(sound_dig, is);
+		deSerializeSimpleSoundSpec(sound_dug, is);
+	}
+	else
+	{
+		throw SerializationError("unsupported ContentFeatures version");
+	}
+}
+