X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fvoxel.cpp;h=f859a1f0382cf6025a41c0b60dd48a7c83ad3eb2;hb=6a1670dbc31cc0e44178bbd9ad34ff0d5981a060;hp=f8a98942cc7e72873803875a4c91791ce09a10d0;hpb=0ca9423b8b2cf7bd1435fb09eba7a9f50d444864;p=minetest.git

diff --git a/src/voxel.cpp b/src/voxel.cpp
index f8a98942c..f859a1f03 100644
--- a/src/voxel.cpp
+++ b/src/voxel.cpp
@@ -1,28 +1,27 @@
 /*
-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.
 */
 
 #include "voxel.h"
 #include "map.h"
-
-// For TimeTaker
-#include "main.h"
-#include "utility.h"
+#include "gettime.h"
+#include "nodedef.h"
+#include "util/timetaker.h"
 
 /*
 	Debug stuff
@@ -41,7 +40,6 @@ VoxelManipulator::VoxelManipulator():
 	m_data(NULL),
 	m_flags(NULL)
 {
-	m_disable_water_climb = false;
 }
 
 VoxelManipulator::~VoxelManipulator()
@@ -65,7 +63,8 @@ void VoxelManipulator::clear()
 	m_flags = NULL;
 }
 
-void VoxelManipulator::print(std::ostream &o, VoxelPrintMode mode)
+void VoxelManipulator::print(std::ostream &o, INodeDefManager *ndef,
+		VoxelPrintMode mode)
 {
 	v3s16 em = m_area.getExtent();
 	v3s16 of = m_area.MinEdge;
@@ -95,8 +94,9 @@ void VoxelManipulator::print(std::ostream &o, VoxelPrintMode mode)
 				else
 				{
 					c = 'X';
-					u8 m = m_data[m_area.index(x,y,z)].d;
-					u8 pr = m_data[m_area.index(x,y,z)].pressure;
+					MapNode n = m_data[m_area.index(x,y,z)];
+					content_t m = n.getContent();
+					u8 pr = n.param2;
 					if(mode == VOXELPRINT_MATERIAL)
 					{
 						if(m <= 9)
@@ -104,13 +104,13 @@ void VoxelManipulator::print(std::ostream &o, VoxelPrintMode mode)
 					}
 					else if(mode == VOXELPRINT_WATERPRESSURE)
 					{
-						if(m == CONTENT_WATER)
+						if(ndef->get(m).isLiquid())
 						{
 							c = 'w';
 							if(pr <= 9)
 								c = pr + '0';
 						}
-						else if(liquid_replaces_content(m))
+						else if(m == CONTENT_AIR)
 						{
 							c = ' ';
 						}
@@ -119,6 +119,21 @@ void VoxelManipulator::print(std::ostream &o, VoxelPrintMode mode)
 							c = '#';
 						}
 					}
+					else if(mode == VOXELPRINT_LIGHT_DAY)
+					{
+						if(ndef->get(m).light_source != 0)
+							c = 'S';
+						else if(ndef->get(m).light_propagates == false)
+							c = 'X';
+						else
+						{
+							u8 light = n.getLight(LIGHTBANK_DAY, ndef);
+							if(light < 10)
+								c = '0' + light;
+							else
+								c = 'a' + (light-10);
+						}
+					}
 				}
 				o<<c;
 			}
@@ -138,7 +153,7 @@ void VoxelManipulator::addArea(VoxelArea area)
 	if(m_area.contains(area))
 		return;
 	
-	TimeTaker timer("addArea", g_device, &addarea_time);
+	TimeTaker timer("addArea", &addarea_time);
 
 	// Calculate new area
 	VoxelArea new_area;
@@ -221,76 +236,33 @@ void VoxelManipulator::copyFrom(MapNode *src, VoxelArea src_area,
 	}
 }
 
-void VoxelManipulator::interpolate(VoxelArea area)
+void VoxelManipulator::copyTo(MapNode *dst, VoxelArea dst_area,
+		v3s16 dst_pos, v3s16 from_pos, v3s16 size)
 {
-	VoxelArea emerge_area = area;
-	emerge_area.MinEdge -= v3s16(1,1,1);
-	emerge_area.MaxEdge += v3s16(1,1,1);
-	emerge(emerge_area);
-
-	SharedBuffer<u8> buf(area.getVolume());
-
-	for(s32 z=area.MinEdge.Z; z<=area.MaxEdge.Z; z++)
-	for(s32 y=area.MinEdge.Y; y<=area.MaxEdge.Y; y++)
-	for(s32 x=area.MinEdge.X; x<=area.MaxEdge.X; x++)
+	for(s16 z=0; z<size.Z; z++)
+	for(s16 y=0; y<size.Y; y++)
 	{
-		v3s16 p(x,y,z);
-
-		v3s16 dirs[] = {
-			v3s16(1,1,0),
-			v3s16(1,0,1),
-			v3s16(1,-1,0),
-			v3s16(1,0,-1),
-			v3s16(-1,1,0),
-			v3s16(-1,0,1),
-			v3s16(-1,-1,0),
-			v3s16(-1,0,-1),
-		};
-		//const v3s16 *dirs = g_26dirs;
-		
-		s16 total = 0;
-		s16 airness = 0;
-		u8 m = CONTENT_IGNORE;
-
-		for(s16 i=0; i<8; i++)
-		//for(s16 i=0; i<26; i++)
-		{
-			v3s16 p2 = p + dirs[i];
-
-			u8 f = m_flags[m_area.index(p2)];
-			assert(!(f & VOXELFLAG_NOT_LOADED));
-			if(f & VOXELFLAG_INEXISTENT)
-				continue;
-
-			MapNode &n = m_data[m_area.index(p2)];
-
-			airness += (n.d == CONTENT_AIR) ? 1 : -1;
-			total++;
-
-			if(m == CONTENT_IGNORE && n.d != CONTENT_AIR)
-				m = n.d;
+		s32 i_dst = dst_area.index(dst_pos.X, dst_pos.Y+y, dst_pos.Z+z);
+		s32 i_local = m_area.index(from_pos.X, from_pos.Y+y, from_pos.Z+z);
+		for (s16 x = 0; x < size.X; x++) {
+			if (m_data[i_local].getContent() != CONTENT_IGNORE)
+				dst[i_dst] = m_data[i_local];
+			i_dst++;
+			i_local++;
 		}
-
-		// 1 if air, 0 if not
-		buf[area.index(p)] = airness > -total/2 ? CONTENT_AIR : m;
-		//buf[area.index(p)] = airness > -total ? CONTENT_AIR : m;
-		//buf[area.index(p)] = airness >= -7 ? CONTENT_AIR : m;
-	}
-
-	for(s32 z=area.MinEdge.Z; z<=area.MaxEdge.Z; z++)
-	for(s32 y=area.MinEdge.Y; y<=area.MaxEdge.Y; y++)
-	for(s32 x=area.MinEdge.X; x<=area.MaxEdge.X; x++)
-	{
-		v3s16 p(x,y,z);
-		m_data[m_area.index(p)].d = buf[area.index(p)];
+		//memcpy(&dst[i_dst], &m_data[i_local], size.X*sizeof(MapNode));
 	}
 }
 
+/*
+	Algorithms
+	-----------------------------------------------------
+*/
 
 void VoxelManipulator::clearFlag(u8 flags)
 {
 	// 0-1ms on moderate area
-	TimeTaker timer("clearFlag", g_device, &clearflag_time);
+	TimeTaker timer("clearFlag", &clearflag_time);
 
 	v3s16 s = m_area.getExtent();
 
@@ -329,638 +301,392 @@ void VoxelManipulator::clearFlag(u8 flags)
 			<<volume<<" nodes"<<std::endl;*/
 }
 
-int VoxelManipulator::getWaterPressure(v3s16 p, s16 &highest_y, int recur_count)
+void VoxelManipulator::unspreadLight(enum LightBank bank, v3s16 p, u8 oldlight,
+		std::set<v3s16> & light_sources, INodeDefManager *nodemgr)
 {
-	m_flags[m_area.index(p)] |= VOXELFLAG_CHECKED2;
-
-	if(p.Y > highest_y)
-		highest_y = p.Y;
-	
-	/*if(recur_count > 1000)
-		throw ProcessingLimitException
-				("getWaterPressure recur_count limit reached");*/
-	
-	if(recur_count > 10000)
-		return -1;
-	
-	recur_count++;
-
 	v3s16 dirs[6] = {
-		v3s16(0,1,0), // top
 		v3s16(0,0,1), // back
-		v3s16(0,0,-1), // front
-		v3s16(1,0,0), // right
-		v3s16(-1,0,0), // left
-		v3s16(0,-1,0), // bottom
-	};
-
-	// Load neighboring nodes
-	emerge(VoxelArea(p - v3s16(1,1,1), p + v3s16(1,1,1)), 1);
-
-	s32 i;
-	for(i=0; i<6; i++)
-	{
-		v3s16 p2 = p + dirs[i];
-		u8 f = m_flags[m_area.index(p2)];
-		// Ignore inexistent or checked nodes
-		if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED2))
-			continue;
-		MapNode &n = m_data[m_area.index(p2)];
-		// Ignore non-liquid nodes
-		if(content_liquid(n.d) == false)
-			continue;
-
-		int pr;
-
-		// If at ocean surface
-		if(n.pressure == 1 && n.d == CONTENT_OCEAN)
-		//if(n.pressure == 1) // Causes glitches but is fast
-		{
-			pr = 1;
-		}
-		// Otherwise recurse more
-		else
-		{
-			pr = getWaterPressure(p2, highest_y, recur_count);
-			if(pr == -1)
-				continue;
-		}
-
-		// If block is at top, pressure here is one higher
-		if(i == 0)
-		{
-			if(pr < 255)
-				pr++;
-		}
-		// If block is at bottom, pressure here is one lower
-		else if(i == 5)
-		{
-			if(pr > 1)
-				pr--;
-		}
-		
-		// Node is on the pressure route
-		m_flags[m_area.index(p)] |= VOXELFLAG_CHECKED4;
-
-		// Got pressure
-		return pr;
-	}
-	
-	// Nothing useful found
-	return -1;
-}
-
-void VoxelManipulator::spreadWaterPressure(v3s16 p, int pr,
-		VoxelArea request_area,
-		core::map<v3s16, u8> &active_nodes,
-		int recur_count)
-{
-	//if(recur_count > 10000)
-		/*throw ProcessingLimitException
-				("spreadWaterPressure recur_count limit reached");*/
-	if(recur_count > 10)
-		return;
-	recur_count++;
-	
-	/*dstream<<"spreadWaterPressure: p=("
-			<<p.X<<","<<p.Y<<","<<p.Z<<")"
-			<<", oldpr="<<(int)m_data[m_area.index(p)].pressure
-			<<", pr="<<pr
-			<<", recur_count="<<recur_count
-			<<", request_area=";
-	request_area.print(dstream);
-	dstream<<std::endl;*/
-
-	m_flags[m_area.index(p)] |= VOXELFLAG_CHECKED3;
-	m_data[m_area.index(p)].pressure = pr;
-
-	v3s16 dirs[6] = {
 		v3s16(0,1,0), // top
-		v3s16(-1,0,0), // left
 		v3s16(1,0,0), // right
 		v3s16(0,0,-1), // front
-		v3s16(0,0,1), // back
 		v3s16(0,-1,0), // bottom
+		v3s16(-1,0,0), // left
 	};
+	
+	emerge(VoxelArea(p - v3s16(1,1,1), p + v3s16(1,1,1)));
 
-	// Load neighboring nodes
-	emerge(VoxelArea(p - v3s16(1,1,1), p + v3s16(1,1,1)), 2);
-
-	s32 i;
-	for(i=0; i<6; i++)
+	// Loop through 6 neighbors
+	for(u16 i=0; i<6; i++)
 	{
-		v3s16 p2 = p + dirs[i];
+		// Get the position of the neighbor node
+		v3s16 n2pos = p + dirs[i];
 		
-		u8 f = m_flags[m_area.index(p2)];
+		u32 n2i = m_area.index(n2pos);
 
-		// Ignore inexistent and checked nodes
-		if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED3))
+		if(m_flags[n2i] & VOXELFLAG_INEXISTENT)
 			continue;
 
-		MapNode &n = m_data[m_area.index(p2)];
+		MapNode &n2 = m_data[n2i];
 		
 		/*
-			If material is air:
-				add to active_nodes if there is flow-causing pressure.
-			NOTE: Do not remove anything from there. We cannot know
-			      here if some other neighbor of it causes flow.
+			If the neighbor is dimmer than what was specified
+			as oldlight (the light of the previous node)
 		*/
-		if(liquid_replaces_content(n.d))
+		u8 light2 = n2.getLight(bank, nodemgr);
+		if(light2 < oldlight)
 		{
-			bool pressure_causes_flow = false;
-			// If empty block is at top
-			if(i == 0)
+			/*
+				And the neighbor is transparent and it has some light
+			*/
+			if(nodemgr->get(n2).light_propagates && light2 != 0)
 			{
-				if(m_disable_water_climb)
-					continue;
+				/*
+					Set light to 0 and add to queue
+				*/
+
+				n2.setLight(bank, 0, nodemgr);
 				
-				//if(pr >= PRESERVE_WATER_VOLUME ? 3 : 2)
-				if(pr >= 3)
-					pressure_causes_flow = true;
-			}
-			// If block is at bottom
-			else if(i == 5)
-			{
-				pressure_causes_flow = true;
-			}
-			// If block is at side
-			else
-			{
-				//if(pr >= PRESERVE_WATER_VOLUME ? 2 : 1)
-				if(pr >= 2)
-					pressure_causes_flow = true;
-			}
-			
-			if(pressure_causes_flow)
-			{
-				active_nodes[p2] = 1;
+				unspreadLight(bank, n2pos, light2, light_sources, nodemgr);
+				
+				/*
+					Remove from light_sources if it is there
+					NOTE: This doesn't happen nearly at all
+				*/
+				/*if(light_sources.find(n2pos))
+				{
+					std::cout<<"Removed from light_sources"<<std::endl;
+					light_sources.remove(n2pos);
+				}*/
 			}
-
-			continue;
 		}
+		else{
+			light_sources.insert(n2pos);
+		}
+	}
+}
 
-		// Ignore non-liquid nodes
-		if(content_liquid(n.d) == false)
-			continue;
+#if 1
+/*
+	Goes recursively through the neighbours of the node.
 
-		int pr2 = pr;
-		// If block is at top, pressure there is lower
-		if(i == 0)
-		{
-			if(pr2 > 0)
-				pr2--;
-		}
-		// If block is at bottom, pressure there is higher
-		else if(i == 5)
-		{
-			if(pr2 < 255)
-				pr2++;
-		}
+	Alters only transparent nodes.
 
-		/*if(m_disable_water_climb)
-		{
-			if(pr2 > 3)
-				pr2 = 3;
-		}*/
-		
-		// Ignore if correct pressure is already set and is not on
-		// request_area.
-		// Thus, request_area can be used for updating as much
-		// pressure info in some area as possible to possibly
-		// make some calls to getWaterPressure unnecessary.
-		if(n.pressure == pr2 && request_area.contains(p2) == false)
-			continue;
+	If the lighting of the neighbour is lower than the lighting of
+	the node was (before changing it to 0 at the step before), the
+	lighting of the neighbour is set to 0 and then the same stuff
+	repeats for the neighbour.
 
-		spreadWaterPressure(p2, pr2, request_area, active_nodes, recur_count);
-	}
-}
+	The ending nodes of the routine are stored in light_sources.
+	This is useful when a light is removed. In such case, this
+	routine can be called for the light node and then again for
+	light_sources to re-light the area without the removed light.
 
-void VoxelManipulator::updateAreaWaterPressure(VoxelArea a,
-		core::map<v3s16, u8> &active_nodes,
-		bool checked3_is_clear)
+	values of from_nodes are lighting values.
+*/
+void VoxelManipulator::unspreadLight(enum LightBank bank,
+		std::map<v3s16, u8> & from_nodes,
+		std::set<v3s16> & light_sources, INodeDefManager *nodemgr)
 {
-	TimeTaker timer("updateAreaWaterPressure", g_device,
-			&updateareawaterpressure_time);
-
-	emerge(a, 3);
-	
-	bool checked2_clear = false;
+	if(from_nodes.size() == 0)
+		return;
 	
-	if(checked3_is_clear == false)
+	for(std::map<v3s16, u8>::iterator j = from_nodes.begin();
+		j != from_nodes.end(); ++j)
 	{
-		//clearFlag(VOXELFLAG_CHECKED3);
-
-		clearFlag(VOXELFLAG_CHECKED3 | VOXELFLAG_CHECKED2);
-		checked2_clear = true;
+		unspreadLight(bank, j->first, j->second, light_sources, nodemgr);
 	}
-	
-
-	for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
-	for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++)
-	for(s32 x=a.MinEdge.X; x<=a.MaxEdge.X; x++)
-	{
-		v3s16 p(x,y,z);
-
-		u8 f = m_flags[m_area.index(p)];
-		// Ignore inexistent or checked nodes
-		if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED3))
-			continue;
-		MapNode &n = m_data[m_area.index(p)];
-		// Ignore non-liquid nodes
-		if(content_liquid(n.d) == false)
-			continue;
-		
-		if(checked2_clear == false)
-		{
-			clearFlag(VOXELFLAG_CHECKED2);
-			checked2_clear = true;
-		}
+}
+#endif
 
-		checked2_clear = false;
+#if 0
+/*
+	Goes recursively through the neighbours of the node.
 
-		s16 highest_y = -32768;
-		int recur_count = 0;
-		int pr = -1;
+	Alters only transparent nodes.
 
-		try
-		{
-			// 0-1ms @ recur_count <= 100
-			//TimeTaker timer("getWaterPressure", g_device);
-			pr = getWaterPressure(p, highest_y, recur_count);
-		}
-		catch(ProcessingLimitException &e)
-		{
-			//dstream<<"getWaterPressure ProcessingLimitException"<<std::endl;
-		}
+	If the lighting of the neighbour is lower than the lighting of
+	the node was (before changing it to 0 at the step before), the
+	lighting of the neighbour is set to 0 and then the same stuff
+	repeats for the neighbour.
 
-		if(pr == -1)
-		{
-			assert(highest_y != -32768);
-
-			pr = highest_y - p.Y + 1;
-			if(pr > 255)
-				pr = 255;
-
-			/*dstream<<"WARNING: Pressure at ("
-					<<p.X<<","<<p.Y<<","<<p.Z<<")"
-					<<" = "<<pr
-					//<<" and highest_y == -32768"
-					<<std::endl;
-			assert(highest_y != -32768);
-			continue;*/
-		}
-		
-		try
-		{
-			// 0ms
-			//TimeTaker timer("spreadWaterPressure", g_device);
-			spreadWaterPressure(p, pr, a, active_nodes, 0);
-		}
-		catch(ProcessingLimitException &e)
-		{
-			//dstream<<"getWaterPressure ProcessingLimitException"<<std::endl;
-		}
-	}
-}
+	The ending nodes of the routine are stored in light_sources.
+	This is useful when a light is removed. In such case, this
+	routine can be called for the light node and then again for
+	light_sources to re-light the area without the removed light.
 
-bool VoxelManipulator::flowWater(v3s16 removed_pos,
-		core::map<v3s16, u8> &active_nodes,
-		int recursion_depth, bool debugprint,
-		u32 stoptime)
+	values of from_nodes are lighting values.
+*/
+void VoxelManipulator::unspreadLight(enum LightBank bank,
+		core::map<v3s16, u8> & from_nodes,
+		core::map<v3s16, bool> & light_sources)
 {
 	v3s16 dirs[6] = {
-		v3s16(0,1,0), // top
-		v3s16(0,0,-1), // front
 		v3s16(0,0,1), // back
-		v3s16(-1,0,0), // left
+		v3s16(0,1,0), // top
 		v3s16(1,0,0), // right
+		v3s16(0,0,-1), // front
 		v3s16(0,-1,0), // bottom
+		v3s16(-1,0,0), // left
 	};
-
-	recursion_depth++;
-
-	v3s16 p;
-	bool from_ocean = false;
 	
-	// Randomize horizontal order
-	static s32 cs = 0;
-	if(cs < 3)
-		cs++;
-	else
-		cs = 0;
-	s16 s1 = (cs & 1) ? 1 : -1;
-	s16 s2 = (cs & 2) ? 1 : -1;
-	//dstream<<"s1="<<s1<<", s2="<<s2<<std::endl;
-
-	{
-	TimeTaker timer1("flowWater pre", g_device, &flowwater_pre_time);
-	
-	// Load neighboring nodes
-	emerge(VoxelArea(removed_pos - v3s16(1,1,1), removed_pos + v3s16(1,1,1)), 4);
-	
-	// Ignore incorrect removed_pos
-	{
-		u8 f = m_flags[m_area.index(removed_pos)];
-		// Ignore inexistent or checked node
-		if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED))
-			return false;
-		MapNode &n = m_data[m_area.index(removed_pos)];
-		// Ignore nodes to which the water can't go
-		if(liquid_replaces_content(n.d) == false)
-			return false;
-	}
+	if(from_nodes.size() == 0)
+		return;
 	
-	s32 i;
-	for(i=0; i<6; i++)
-	{
-		// Don't raise water from bottom
-		if(m_disable_water_climb && i == 5)
-			continue;
+	core::map<v3s16, u8> unlighted_nodes;
+	core::map<v3s16, u8>::Iterator j;
+	j = from_nodes.getIterator();
 
-		p = removed_pos + v3s16(s1*dirs[i].X, dirs[i].Y, s2*dirs[i].Z);
+	for(; j.atEnd() == false; j++)
+	{
+		v3s16 pos = j.getNode()->getKey();
+		
+		emerge(VoxelArea(pos - v3s16(1,1,1), pos + v3s16(1,1,1)));
 
-		u8 f = m_flags[m_area.index(p)];
-		// Inexistent or checked nodes can't move
-		if(f & (VOXELFLAG_INEXISTENT | VOXELFLAG_CHECKED))
-			continue;
-		MapNode &n = m_data[m_area.index(p)];
-		// Only liquid nodes can move
-		if(content_liquid(n.d) == false)
-			continue;
-		// If block is at top, select it always
-		if(i == 0)
-		{
-			break;
-		}
-		// If block is at bottom, select it if it has enough pressure
-		if(i == 5)
-		{
-			//if(n.pressure >= PRESERVE_WATER_VOLUME ? 3 : 2)
-			if(n.pressure >= 3)
-				break;
-			continue;
-		}
-		// Else block is at some side. Select it if it has enough pressure
-		//if(n.pressure >= PRESERVE_WATER_VOLUME ? 2 : 1)
-		if(n.pressure >= 2)
+		//MapNode &n = m_data[m_area.index(pos)];
+		
+		u8 oldlight = j.getNode()->getValue();
+		
+		// Loop through 6 neighbors
+		for(u16 i=0; i<6; i++)
 		{
-			break;
+			// Get the position of the neighbor node
+			v3s16 n2pos = pos + dirs[i];
+			
+			u32 n2i = m_area.index(n2pos);
+
+			if(m_flags[n2i] & VOXELFLAG_INEXISTENT)
+				continue;
+
+			MapNode &n2 = m_data[n2i];
+			
+			/*
+				If the neighbor is dimmer than what was specified
+				as oldlight (the light of the previous node)
+			*/
+			if(n2.getLight(bank, nodemgr) < oldlight)
+			{
+				/*
+					And the neighbor is transparent and it has some light
+				*/
+				if(nodemgr->get(n2).light_propagates && n2.getLight(bank, nodemgr) != 0)
+				{
+					/*
+						Set light to 0 and add to queue
+					*/
+
+					u8 current_light = n2.getLight(bank, nodemgr);
+					n2.setLight(bank, 0);
+
+					unlighted_nodes.insert(n2pos, current_light);
+					
+					/*
+						Remove from light_sources if it is there
+						NOTE: This doesn't happen nearly at all
+					*/
+					/*if(light_sources.find(n2pos))
+					{
+						std::cout<<"Removed from light_sources"<<std::endl;
+						light_sources.remove(n2pos);
+					}*/
+				}
+			}
+			else{
+				light_sources.insert(n2pos, true);
+			}
 		}
 	}
 
-	// If there is nothing to move, return
-	if(i==6)
-		return false;
-
-	/*
-		Move water and bubble
-	*/
+	/*dstream<<"unspreadLight(): Changed block "
+			<<blockchangecount<<" times"
+			<<" for "<<from_nodes.size()<<" nodes"
+			<<std::endl;*/
+	
+	if(unlighted_nodes.size() > 0)
+		unspreadLight(bank, unlighted_nodes, light_sources);
+}
+#endif
 
-	u8 m = m_data[m_area.index(p)].d;
-	u8 f = m_flags[m_area.index(p)];
+void VoxelManipulator::spreadLight(enum LightBank bank, v3s16 p,
+		INodeDefManager *nodemgr)
+{
+	const v3s16 dirs[6] = {
+		v3s16(0,0,1), // back
+		v3s16(0,1,0), // top
+		v3s16(1,0,0), // right
+		v3s16(0,0,-1), // front
+		v3s16(0,-1,0), // bottom
+		v3s16(-1,0,0), // left
+	};
 
-	if(m == CONTENT_OCEAN)
-		from_ocean = true;
+	emerge(VoxelArea(p - v3s16(1,1,1), p + v3s16(1,1,1)));
 
-	// Move air bubble if not taking water from ocean
-	if(from_ocean == false)
-	{
-		m_data[m_area.index(p)].d = m_data[m_area.index(removed_pos)].d;
-		m_flags[m_area.index(p)] = m_flags[m_area.index(removed_pos)];
-	}
+	u32 i = m_area.index(p);
 	
-	/*
-		This has to be done to copy the brightness of a light source
-		correctly. Otherwise unspreadLight will fuck up when water
-		has replaced a light source.
-	*/
-	u8 light = m_data[m_area.index(removed_pos)].getLightBanksWithSource();
-
-	m_data[m_area.index(removed_pos)].d = m;
-	m_flags[m_area.index(removed_pos)] = f;
+	if(m_flags[i] & VOXELFLAG_INEXISTENT)
+		return;
 
-	m_data[m_area.index(removed_pos)].setLightBanks(light);
-	
-	// Mark removed_pos checked
-	m_flags[m_area.index(removed_pos)] |= VOXELFLAG_CHECKED;
+	MapNode &n = m_data[i];
 
-	// If block was dropped from surface, increase pressure
-	if(i == 0 && m_data[m_area.index(removed_pos)].pressure == 1)
-	{
-		m_data[m_area.index(removed_pos)].pressure = 2;
-	}
-	
-	/*
-	NOTE: This does not work as-is
-	if(m == CONTENT_OCEAN)
-	{
-		// If block was raised to surface, increase pressure of
-		// source node
-		if(i == 5 && m_data[m_area.index(p)].pressure == 1)
-		{
-			m_data[m_area.index(p)].pressure = 2;
-		}
-	}*/
-	
-	/*if(debugprint)
-	{
-		dstream<<"VoxelManipulator::flowWater(): Moved bubble:"<<std::endl;
-		print(dstream, VOXELPRINT_WATERPRESSURE);
-	}*/
+	u8 oldlight = n.getLight(bank, nodemgr);
+	u8 newlight = diminish_light(oldlight);
 
-	// Update pressure
-	VoxelArea a;
-	a.addPoint(p - v3s16(1,1,1));
-	a.addPoint(p + v3s16(1,1,1));
-	a.addPoint(removed_pos - v3s16(1,1,1));
-	a.addPoint(removed_pos + v3s16(1,1,1));
-	updateAreaWaterPressure(a, active_nodes);
-	
-	/*if(debugprint)
+	// Loop through 6 neighbors
+	for(u16 i=0; i<6; i++)
 	{
-		dstream<<"VoxelManipulator::flowWater(): Pressure updated:"<<std::endl;
-		print(dstream, VOXELPRINT_WATERPRESSURE);
-		//std::cin.get();
-	}*/
+		// Get the position of the neighbor node
+		v3s16 n2pos = p + dirs[i];
+		
+		u32 n2i = m_area.index(n2pos);
 
-	if(debugprint)
-	{
-		dstream<<"VoxelManipulator::flowWater(): step done:"<<std::endl;
-		print(dstream, VOXELPRINT_WATERPRESSURE);
-		//std::cin.get();
-	}
-	
-	}//timer1
-	
-	//if(PRESERVE_WATER_VOLUME)
-	if(from_ocean == false)
-	{
-		// Flow water to the newly created empty position
-		/*flowWater(p, active_nodes, recursion_depth,
-				debugprint, counter, counterlimit);*/
-		flowWater(p, active_nodes, recursion_depth,
-				debugprint, stoptime);
-	}
-	
-	if(stoptime != 0 && g_device != NULL)
-	{
-		u32 timenow = g_device->getTimer()->getRealTime();
-		if(timenow >= stoptime ||
-				(stoptime < 0x80000000 && timenow > 0x80000000))
-		{
-			dstream<<"flowWater: stoptime reached"<<std::endl;
-			throw ProcessingLimitException("flowWater stoptime reached");
-		}
-	}
-	
-find_again:
-	
-	// Try flowing water to empty positions around removed_pos.
-	// They are checked in reverse order compared to the previous loop.
-	for(s32 i=5; i>=0; i--)
-	{
-		// Don't try to flow to top
-		if(m_disable_water_climb && i == 0)
+		if(m_flags[n2i] & VOXELFLAG_INEXISTENT)
 			continue;
 
-		//v3s16 p = removed_pos + dirs[i];
-		p = removed_pos + v3s16(s1*dirs[i].X, dirs[i].Y, s2*dirs[i].Z);
+		MapNode &n2 = m_data[n2i];
 
-		u8 f = m_flags[m_area.index(p)];
-		// Water can't move to inexistent nodes
-		if(f & VOXELFLAG_INEXISTENT)
-			continue;
-		MapNode &n = m_data[m_area.index(p)];
-		// Water can only move to air
-		if(liquid_replaces_content(n.d) == false)
-			continue;
-			
-		// Flow water to node
-		bool moved =
-		flowWater(p, active_nodes, recursion_depth,
-				debugprint, stoptime);
-		/*flowWater(p, active_nodes, recursion_depth,
-				debugprint, counter, counterlimit);*/
+		u8 light2 = n2.getLight(bank, nodemgr);
 		
-		if(moved)
+		/*
+			If the neighbor is brighter than the current node,
+			add to list (it will light up this node on its turn)
+		*/
+		if(light2 > undiminish_light(oldlight))
 		{
-			// Search again from all neighbors
-			goto find_again;
+			spreadLight(bank, n2pos, nodemgr);
+		}
+		/*
+			If the neighbor is dimmer than how much light this node
+			would spread on it, add to list
+		*/
+		if(light2 < newlight)
+		{
+			if(nodemgr->get(n2).light_propagates)
+			{
+				n2.setLight(bank, newlight, nodemgr);
+				spreadLight(bank, n2pos, nodemgr);
+			}
 		}
 	}
-
-	return true;
 }
 
-void VoxelManipulator::flowWater(
-		core::map<v3s16, u8> &active_nodes,
-		int recursion_depth, bool debugprint,
-		u32 timelimit)
+#if 0
+/*
+	Lights neighbors of from_nodes, collects all them and then
+	goes on recursively.
+
+	NOTE: This is faster on small areas but will overflow the
+	      stack on large areas. Thus it is not used.
+*/
+void VoxelManipulator::spreadLight(enum LightBank bank,
+		core::map<v3s16, bool> & from_nodes)
 {
-	addarea_time = 0;
-	emerge_time = 0;
-	emerge_load_time = 0;
-	clearflag_time = 0;
-	updateareawaterpressure_time = 0;
-	flowwater_pre_time = 0;
-
-	if(active_nodes.size() == 0)
-	{
-		dstream<<"flowWater: no active nodes"<<std::endl;
+	if(from_nodes.size() == 0)
 		return;
-	}
-
-	//TimeTaker timer1("flowWater (active_nodes)", g_device);
-
-	//dstream<<"active_nodes.size() = "<<active_nodes.size()<<std::endl;
-
+	
+	core::map<v3s16, bool> lighted_nodes;
+	core::map<v3s16, bool>::Iterator j;
+	j = from_nodes.getIterator();
 
-	u32 stoptime = 0;
-	if(g_device != NULL)
+	for(; j.atEnd() == false; j++)
 	{
-		stoptime = g_device->getTimer()->getRealTime() + timelimit;
-	}
+		v3s16 pos = j.getNode()->getKey();
 
-	// Count of handled active nodes
-	u32 handled_count = 0;
-
-	try
-	{
+		spreadLight(bank, pos);
+	}
+}
+#endif
 
-	/*
-		Take random one at first
+#if 1
+/*
+	Lights neighbors of from_nodes, collects all them and then
+	goes on recursively.
+*/
+void VoxelManipulator::spreadLight(enum LightBank bank,
+		std::set<v3s16> & from_nodes, INodeDefManager *nodemgr)
+{
+	const v3s16 dirs[6] = {
+		v3s16(0,0,1), // back
+		v3s16(0,1,0), // top
+		v3s16(1,0,0), // right
+		v3s16(0,0,-1), // front
+		v3s16(0,-1,0), // bottom
+		v3s16(-1,0,0), // left
+	};
 
-		This is randomized only at the first time so that all
-		subsequent nodes will be taken at roughly the same position
-	*/
-	s32 k = 0;
-	if(active_nodes.size() != 0)
-		k = (s32)rand() % (s32)active_nodes.size();
+	if(from_nodes.size() == 0)
+		return;
+	
+	std::set<v3s16> lighted_nodes;
 
-	// Flow water to active nodes
-	for(;;)
-	//for(s32 h=0; h<1; h++)
+	for(std::set<v3s16>::iterator j = from_nodes.begin();
+		j != from_nodes.end(); ++j)
 	{
-		if(active_nodes.size() == 0)
-			break;
+		v3s16 pos = *j;
 
-		handled_count++;
-		
-		// Clear check flags
-		clearFlag(VOXELFLAG_CHECKED);
+		emerge(VoxelArea(pos - v3s16(1,1,1), pos + v3s16(1,1,1)));
+
+		u32 i = m_area.index(pos);
 		
-		//dstream<<"Selecting a new active_node"<<std::endl;
+		if(m_flags[i] & VOXELFLAG_INEXISTENT)
+			continue;
 
-#if 0
-		// Take first one
-		core::map<v3s16, u8>::Node
-				*n = active_nodes.getIterator().getNode();
-#endif
+		MapNode &n = m_data[i];
 
-#if 1
-		
-		core::map<v3s16, u8>::Iterator
-				i = active_nodes.getIterator().getNode();
-		for(s32 j=0; j<k; j++)
+		u8 oldlight = n.getLight(bank, nodemgr);
+		u8 newlight = diminish_light(oldlight);
+
+		// Loop through 6 neighbors
+		for(u16 i=0; i<6; i++)
 		{
-			i++;
-		}
-		core::map<v3s16, u8>::Node *n = i.getNode();
+			// Get the position of the neighbor node
+			v3s16 n2pos = pos + dirs[i];
+			
+			try
+			{
+				u32 n2i = m_area.index(n2pos);
 
-		// Decrement index if less than 0.
-		// This keeps us in existing indices always.
-		if(k > 0)
-			k--;
-#endif
+				if(m_flags[n2i] & VOXELFLAG_INEXISTENT)
+					continue;
 
-		v3s16 p = n->getKey();
-		active_nodes.remove(p);
-		flowWater(p, active_nodes, recursion_depth,
-				debugprint, stoptime);
-	}
+				MapNode &n2 = m_data[n2i];
 
+				u8 light2 = n2.getLight(bank, nodemgr);
+				
+				/*
+					If the neighbor is brighter than the current node,
+					add to list (it will light up this node on its turn)
+				*/
+				if(light2 > undiminish_light(oldlight))
+				{
+					lighted_nodes.insert(n2pos);
+				}
+				/*
+					If the neighbor is dimmer than how much light this node
+					would spread on it, add to list
+				*/
+				if(light2 < newlight)
+				{
+					if(nodemgr->get(n2).light_propagates)
+					{
+						n2.setLight(bank, newlight, nodemgr);
+						lighted_nodes.insert(n2pos);
+					}
+				}
+			}
+			catch(InvalidPositionException &e)
+			{
+				continue;
+			}
+		}
 	}
-	catch(ProcessingLimitException &e)
-	{
-		//dstream<<"getWaterPressure ProcessingLimitException"<<std::endl;
-	}
-	
-	/*v3s16 e = m_area.getExtent();
-	s32 v = m_area.getVolume();
-	dstream<<"flowWater (active): "
-			<<"area ended up as "
-			<<e.X<<"x"<<e.Y<<"x"<<e.Z<<" = "<<v
-			<<", handled a_node count: "<<handled_count
-			<<", active_nodes.size() = "<<active_nodes.size()
-			<<std::endl;
-	dstream<<"addarea_time: "<<addarea_time
-			<<", emerge_time: "<<emerge_time
-			<<", emerge_load_time: "<<emerge_load_time
-			<<", clearflag_time: "<<clearflag_time
-			<<", flowwater_pre_time: "<<flowwater_pre_time
-			<<", updateareawaterpressure_time: "<<updateareawaterpressure_time
+
+	/*dstream<<"spreadLight(): Changed block "
+			<<blockchangecount<<" times"
+			<<" for "<<from_nodes.size()<<" nodes"
 			<<std::endl;*/
+	
+	if(lighted_nodes.size() > 0)
+		spreadLight(bank, lighted_nodes, nodemgr);
 }
-
+#endif
 
 //END