X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fenvironment.cpp;h=f233eaf7ff072ddab7ef88c824b51c2103147497;hb=0af53115384cda1d96337b39c4205cb7a970c069;hp=d144baeefd375b713992efb4835ca4bde838f8e0;hpb=e0f7bd4d57bf0c9b497c4d0bb73f7bd4d5cc0643;p=dragonfireclient.git

diff --git a/src/environment.cpp b/src/environment.cpp
index d144baeef..f233eaf7f 100644
--- a/src/environment.cpp
+++ b/src/environment.cpp
@@ -1,6 +1,6 @@
 /*
 Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2010-2011 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
@@ -20,10 +20,12 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "environment.h"
 #include "filesys.h"
 #include "porting.h"
+#include "collision.h"
 
-Environment::Environment()
+
+Environment::Environment():
+	m_time_of_day(9000)
 {
-	m_daynight_ratio = 0.5;
 }
 
 Environment::~Environment()
@@ -172,14 +174,84 @@ void Environment::printPlayers(std::ostream &o)
 	}
 }
 
-void Environment::setDayNightRatio(u32 r)
+/*void Environment::setDayNightRatio(u32 r)
 {
-	m_daynight_ratio = r;
-}
+	getDayNightRatio() = r;
+}*/
 
 u32 Environment::getDayNightRatio()
 {
-	return m_daynight_ratio;
+	//return getDayNightRatio();
+	return time_to_daynight_ratio(m_time_of_day);
+}
+
+/*
+	ActiveBlockList
+*/
+
+void fillRadiusBlock(v3s16 p0, s16 r, core::map<v3s16, bool> &list)
+{
+	v3s16 p;
+	for(p.X=p0.X-r; p.X<=p0.X+r; p.X++)
+	for(p.Y=p0.Y-r; p.Y<=p0.Y+r; p.Y++)
+	for(p.Z=p0.Z-r; p.Z<=p0.Z+r; p.Z++)
+	{
+		// Set in list
+		list[p] = true;
+	}
+}
+
+void ActiveBlockList::update(core::list<v3s16> &active_positions,
+		s16 radius,
+		core::map<v3s16, bool> &blocks_removed,
+		core::map<v3s16, bool> &blocks_added)
+{
+	/*
+		Create the new list
+	*/
+	core::map<v3s16, bool> newlist;
+	for(core::list<v3s16>::Iterator i = active_positions.begin();
+			i != active_positions.end(); i++)
+	{
+		fillRadiusBlock(*i, radius, newlist);
+	}
+
+	/*
+		Find out which blocks on the old list are not on the new list
+	*/
+	// Go through old list
+	for(core::map<v3s16, bool>::Iterator i = m_list.getIterator();
+			i.atEnd()==false; i++)
+	{
+		v3s16 p = i.getNode()->getKey();
+		// If not on new list, it's been removed
+		if(newlist.find(p) == NULL)
+			blocks_removed.insert(p, true);
+	}
+
+	/*
+		Find out which blocks on the new list are not on the old list
+	*/
+	// Go through new list
+	for(core::map<v3s16, bool>::Iterator i = newlist.getIterator();
+			i.atEnd()==false; i++)
+	{
+		v3s16 p = i.getNode()->getKey();
+		// If not on old list, it's been added
+		if(m_list.find(p) == NULL)
+			blocks_added.insert(p, true);
+	}
+
+	/*
+		Update m_list
+	*/
+	m_list.clear();
+	for(core::map<v3s16, bool>::Iterator i = newlist.getIterator();
+			i.atEnd()==false; i++)
+	{
+		v3s16 p = i.getNode()->getKey();
+		m_list.insert(p, true);
+	}
 }
 
 /*
@@ -189,12 +261,22 @@ u32 Environment::getDayNightRatio()
 ServerEnvironment::ServerEnvironment(ServerMap *map, Server *server):
 	m_map(map),
 	m_server(server),
-	m_random_spawn_timer(0)
+	m_random_spawn_timer(3),
+	m_send_recommended_timer(0),
+	m_game_time(0),
+	m_game_time_fraction_counter(0)
 {
 }
 
 ServerEnvironment::~ServerEnvironment()
 {
+	// Clear active block list.
+	// This makes the next one delete all active objects.
+	m_active_blocks.clear();
+
+	// Convert all objects to static and delete the active objects
+	deactivateFarObjects(true);
+
 	// Drop/delete map
 	m_map->drop();
 }
@@ -376,16 +458,143 @@ void ServerEnvironment::deSerializePlayers(const std::string &savedir)
 	}
 }
 
+void ServerEnvironment::saveMeta(const std::string &savedir)
+{
+	std::string path = savedir + "/env_meta.txt";
+
+	// Open file and serialize
+	std::ofstream os(path.c_str(), std::ios_base::binary);
+	if(os.good() == false)
+	{
+		dstream<<"WARNING: ServerEnvironment::saveMeta(): Failed to open "
+				<<path<<std::endl;
+		throw SerializationError("Couldn't save env meta");
+	}
+
+	Settings args;
+	args.setU64("game_time", m_game_time);
+	args.setU64("time_of_day", getTimeOfDay());
+	args.writeLines(os);
+	os<<"EnvArgsEnd\n";
+}
+
+void ServerEnvironment::loadMeta(const std::string &savedir)
+{
+	std::string path = savedir + "/env_meta.txt";
+
+	// Open file and deserialize
+	std::ifstream is(path.c_str(), std::ios_base::binary);
+	if(is.good() == false)
+	{
+		dstream<<"WARNING: ServerEnvironment::loadMeta(): Failed to open "
+				<<path<<std::endl;
+		throw SerializationError("Couldn't load env meta");
+	}
+
+	Settings args;
+	
+	for(;;)
+	{
+		if(is.eof())
+			throw SerializationError
+					("ServerEnvironment::loadMeta(): EnvArgsEnd not found");
+		std::string line;
+		std::getline(is, line);
+		std::string trimmedline = trim(line);
+		if(trimmedline == "EnvArgsEnd")
+			break;
+		args.parseConfigLine(line);
+	}
+	
+	try{
+		m_game_time = args.getU64("game_time");
+	}catch(SettingNotFoundException &e){
+		// Getting this is crucial, otherwise timestamps are useless
+		throw SerializationError("Couldn't load env meta game_time");
+	}
+
+	try{
+		m_time_of_day = args.getU64("time_of_day");
+	}catch(SettingNotFoundException &e){
+		// This is not as important
+		m_time_of_day = 9000;
+	}
+}
+
+#if 0
+// This is probably very useless
+void spawnRandomObjects(MapBlock *block)
+{
+	for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
+	for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
+	{
+		bool last_node_walkable = false;
+		for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
+		{
+			v3s16 p(x0,y0,z0);
+			MapNode n = block->getNodeNoEx(p);
+			if(n.d == CONTENT_IGNORE)
+				continue;
+			if(content_features(n.d).liquid_type != LIQUID_NONE)
+				continue;
+			if(content_features(n.d).walkable)
+			{
+				last_node_walkable = true;
+				continue;
+			}
+			if(last_node_walkable)
+			{
+				// If block contains light information
+				if(content_features(n.d).param_type == CPT_LIGHT)
+				{
+					if(n.getLight(LIGHTBANK_DAY) <= 5)
+					{
+						if(myrand() % 1000 == 0)
+						{
+							v3f pos_f = intToFloat(p+block->getPosRelative(), BS);
+							pos_f.Y -= BS*0.4;
+							ServerActiveObject *obj = new Oerkki1SAO(NULL,0,pos_f);
+							std::string data = obj->getStaticData();
+							StaticObject s_obj(obj->getType(),
+									obj->getBasePosition(), data);
+							// Add one
+							block->m_static_objects.insert(0, s_obj);
+							delete obj;
+							block->setChangedFlag();
+						}
+					}
+				}
+			}
+			last_node_walkable = false;
+		}
+	}
+}
+#endif
+
 void ServerEnvironment::step(float dtime)
 {
 	DSTACK(__FUNCTION_NAME);
+	
+	//TimeTaker timer("ServerEnv step");
 
 	// Get some settings
-	//bool free_move = g_settings.getBool("free_move");
 	bool footprints = g_settings.getBool("footprints");
 
+	/*
+		Increment game time
+	*/
+	{
+		m_game_time_fraction_counter += dtime;
+		u32 inc_i = (u32)m_game_time_fraction_counter;
+		m_game_time += inc_i;
+		m_game_time_fraction_counter -= (float)inc_i;
+	}
+	
+	/*
+		Let map update it's timers
+	*/
 	{
-		//TimeTaker timer("Server m_map->timerUpdate()", g_device);
+		//TimeTaker timer("Server m_map->timerUpdate()");
 		m_map->timerUpdate(dtime);
 	}
 
@@ -396,6 +605,11 @@ void ServerEnvironment::step(float dtime)
 			i != m_players.end(); i++)
 	{
 		Player *player = *i;
+		
+		// Ignore disconnected players
+		if(player->peer_id == 0)
+			continue;
+
 		v3f playerpos = player->getPosition();
 		
 		// Move
@@ -421,68 +635,234 @@ void ServerEnvironment::step(float dtime)
 			}
 		}
 	}
-	
-	if(g_settings.getBool("enable_experimental"))
-	{
 
 	/*
-		Step active objects
+		Manage active block list
 	*/
-	for(core::map<u16, ServerActiveObject*>::Iterator
-			i = m_active_objects.getIterator();
-			i.atEnd()==false; i++)
+	if(m_active_blocks_management_interval.step(dtime, 2.0))
 	{
-		ServerActiveObject* obj = i.getNode()->getValue();
-		// Step object, putting messages directly to the queue
-		obj->step(dtime, m_active_object_messages);
+		/*
+			Get player block positions
+		*/
+		core::list<v3s16> players_blockpos;
+		for(core::list<Player*>::Iterator
+				i = m_players.begin();
+				i != m_players.end(); i++)
+		{
+			Player *player = *i;
+			// Ignore disconnected players
+			if(player->peer_id == 0)
+				continue;
+			v3s16 blockpos = getNodeBlockPos(
+					floatToInt(player->getPosition(), BS));
+			players_blockpos.push_back(blockpos);
+		}
+		
+		/*
+			Update list of active blocks, collecting changes
+		*/
+		const s16 active_block_range = 5;
+		core::map<v3s16, bool> blocks_removed;
+		core::map<v3s16, bool> blocks_added;
+		m_active_blocks.update(players_blockpos, active_block_range,
+				blocks_removed, blocks_added);
+
+		/*
+			Handle removed blocks
+		*/
+
+		// Convert active objects that are no more in active blocks to static
+		deactivateFarObjects(false);
+		
+		for(core::map<v3s16, bool>::Iterator
+				i = blocks_removed.getIterator();
+				i.atEnd()==false; i++)
+		{
+			v3s16 p = i.getNode()->getKey();
+
+			/*dstream<<"Server: Block ("<<p.X<<","<<p.Y<<","<<p.Z
+					<<") became inactive"<<std::endl;*/
+			
+			MapBlock *block = m_map->getBlockNoCreateNoEx(p);
+			if(block==NULL)
+				continue;
+			
+			// Set current time as timestamp
+			block->setTimestamp(m_game_time);
+		}
+
+		/*
+			Handle added blocks
+		*/
+
+		for(core::map<v3s16, bool>::Iterator
+				i = blocks_added.getIterator();
+				i.atEnd()==false; i++)
+		{
+			v3s16 p = i.getNode()->getKey();
+			
+			/*dstream<<"Server: Block ("<<p.X<<","<<p.Y<<","<<p.Z
+					<<") became active"<<std::endl;*/
+
+			MapBlock *block = m_map->getBlockNoCreateNoEx(p);
+			if(block==NULL)
+				continue;
+			
+			// Get time difference
+			u32 dtime_s = 0;
+			u32 stamp = block->getTimestamp();
+			if(m_game_time > stamp && stamp != BLOCK_TIMESTAMP_UNDEFINED)
+				dtime_s = m_game_time - block->getTimestamp();
+
+			// Set current time as timestamp
+			block->setTimestamp(m_game_time);
+
+			//dstream<<"Block is "<<dtime_s<<" seconds old."<<std::endl;
+			
+			// Activate stored objects
+			activateObjects(block);
+
+			// TODO: Do something
+			
+			// Here's a quick demonstration
+			v3s16 p0;
+			for(p0.X=0; p0.X<MAP_BLOCKSIZE; p0.X++)
+			for(p0.Y=0; p0.Y<MAP_BLOCKSIZE; p0.Y++)
+			for(p0.Z=0; p0.Z<MAP_BLOCKSIZE; p0.Z++)
+			{
+				v3s16 p = p0 + block->getPosRelative();
+				MapNode n = block->getNodeNoEx(p0);
+				// Test something:
+				// Convert all mud under proper day lighting to grass
+				if(n.d == CONTENT_MUD)
+				{
+					if(1)
+					{
+						MapNode n_top = block->getNodeNoEx(p0+v3s16(0,1,0));
+						if(content_features(n_top.d).walkable == false &&
+								n_top.getLight(LIGHTBANK_DAY) >= 13)
+						{
+							n.d = CONTENT_GRASS;
+							m_map->addNodeWithEvent(p, n);
+						}
+					}
+				}
+			}
+		}
 	}
 
 	/*
-		Remove (m_removed && m_known_by_count==0) objects
+		Mess around in active blocks
 	*/
+	if(m_active_blocks_test_interval.step(dtime, 5.0))
 	{
-		core::list<u16> objects_to_remove;
-		for(core::map<u16, ServerActiveObject*>::Iterator
-				i = m_active_objects.getIterator();
+		for(core::map<v3s16, bool>::Iterator
+				i = m_active_blocks.m_list.getIterator();
 				i.atEnd()==false; i++)
 		{
-			u16 id = i.getNode()->getKey();
-			ServerActiveObject* obj = i.getNode()->getValue();
-			// This shouldn't happen but check it
-			if(obj == NULL)
-			{
-				dstream<<"WARNING: NULL object found in ServerEnvironment"
-						<<" while finding removed objects. id="<<id<<std::endl;
-				// Id to be removed from m_active_objects
-				objects_to_remove.push_back(id);
+			v3s16 p = i.getNode()->getKey();
+			
+			/*dstream<<"Server: Block ("<<p.X<<","<<p.Y<<","<<p.Z
+					<<") being handled"<<std::endl;*/
+
+			MapBlock *block = m_map->getBlockNoCreateNoEx(p);
+			if(block==NULL)
 				continue;
-			}
-			else
+			
+			// Set current time as timestamp
+			block->setTimestamp(m_game_time);
+			
+			/*
+				Do stuff!
+
+				Note that map modifications should be done using the event-
+				making map methods so that the server gets information
+				about them.
+
+				Reading can be done quickly directly from the block.
+
+				Everything should bind to inside this single content
+				searching loop to keep things fast.
+			*/
+
+			v3s16 p0;
+			for(p0.X=0; p0.X<MAP_BLOCKSIZE; p0.X++)
+			for(p0.Y=0; p0.Y<MAP_BLOCKSIZE; p0.Y++)
+			for(p0.Z=0; p0.Z<MAP_BLOCKSIZE; p0.Z++)
 			{
-				// If not m_removed, don't remove.
-				if(obj->m_removed == false)
-					continue;
-				// Delete
-				delete obj;
-				// Id to be removed from m_active_objects
-				objects_to_remove.push_back(id);
+				v3s16 p = p0 + block->getPosRelative();
+				MapNode n = block->getNodeNoEx(p0);
+				// Test something:
+				// Convert mud under proper lighting to grass
+				if(n.d == CONTENT_MUD)
+				{
+					if(myrand()%4 == 0)
+					{
+						MapNode n_top = block->getNodeNoEx(p0+v3s16(0,1,0));
+						if(content_features(n_top.d).walkable == false &&
+								n_top.getLightBlend(getDayNightRatio()) >= 13)
+						{
+							n.d = CONTENT_GRASS;
+							m_map->addNodeWithEvent(p, n);
+						}
+					}
+				}
 			}
 		}
-		// Remove references from m_active_objects
-		for(core::list<u16>::Iterator i = objects_to_remove.begin();
-				i != objects_to_remove.end(); i++)
+	}
+	
+	/*
+		Step active objects
+	*/
+	{
+		//TimeTaker timer("Step active objects");
+		
+		// This helps the objects to send data at the same time
+		bool send_recommended = false;
+		m_send_recommended_timer += dtime;
+		if(m_send_recommended_timer > 0.15)
+		{
+			m_send_recommended_timer = 0;
+			send_recommended = true;
+		}
+
+		for(core::map<u16, ServerActiveObject*>::Iterator
+				i = m_active_objects.getIterator();
+				i.atEnd()==false; i++)
 		{
-			m_active_objects.remove(*i);
+			ServerActiveObject* obj = i.getNode()->getValue();
+			// Don't step if is to be removed or stored statically
+			if(obj->m_removed || obj->m_pending_deactivation)
+				continue;
+			// Step object, putting messages directly to the queue
+			obj->step(dtime, m_active_object_messages, send_recommended);
 		}
 	}
+	
+	/*
+		Manage active objects
+	*/
+	if(m_object_management_interval.step(dtime, 0.5))
+	{
+		/*
+			Remove objects that satisfy (m_removed && m_known_by_count==0)
+		*/
+		removeRemovedObjects();
+	}
+
+	if(g_settings.getBool("enable_experimental"))
+	{
 
 	/*
 		TEST CODE
 	*/
+#if 1
 	m_random_spawn_timer -= dtime;
 	if(m_random_spawn_timer < 0)
 	{
-		m_random_spawn_timer += myrand_range(2.0, 20.0);
+		//m_random_spawn_timer += myrand_range(2.0, 20.0);
+		//m_random_spawn_timer += 2.0;
+		m_random_spawn_timer += 200.0;
 
 		/*
 			Find some position
@@ -503,15 +883,16 @@ void ServerEnvironment::step(float dtime)
 		);
 
 		/*
-			Create a TestSAO object
+			Create a ServerActiveObject
 		*/
 
-		TestSAO *obj = new TestSAO(this, 0,
-				v3f(myrand_range(-2*BS,2*BS), BS*5, myrand_range(-2*BS,2*BS)));
-
-		// Add the object to the environment
+		//TestSAO *obj = new TestSAO(this, 0, pos);
+		//ServerActiveObject *obj = new ItemSAO(this, 0, pos, "CraftItem Stick 1");
+		//ServerActiveObject *obj = new RatSAO(this, 0, pos);
+		ServerActiveObject *obj = new Oerkki1SAO(this, 0, pos);
 		addActiveObject(obj);
 	}
+#endif
 
 	} // enable_experimental
 }
@@ -579,9 +960,29 @@ u16 ServerEnvironment::addActiveObject(ServerActiveObject *object)
 		delete object;
 		return 0;
 	}
-	dstream<<"INGO: ServerEnvironment::addActiveObject(): "
-			<<"added (id="<<object->getId()<<")"<<std::endl;
+	/*dstream<<"INGO: ServerEnvironment::addActiveObject(): "
+			<<"added (id="<<object->getId()<<")"<<std::endl;*/
+			
 	m_active_objects.insert(object->getId(), object);
+
+	// Add static object to active static list of the block
+	v3f objectpos = object->getBasePosition();
+	std::string staticdata = object->getStaticData();
+	StaticObject s_obj(object->getType(), objectpos, staticdata);
+	// Add to the block where the object is located in
+	v3s16 blockpos = getNodeBlockPos(floatToInt(objectpos, BS));
+	MapBlock *block = m_map->getBlockNoCreateNoEx(blockpos);
+	if(block)
+	{
+		block->m_static_objects.m_active.insert(object->getId(), s_obj);
+		object->m_static_exists = true;
+		object->m_static_block = blockpos;
+	}
+	else{
+		dstream<<"WARNING: Server: Could not find a block for "
+				<<"storing newly added static active object"<<std::endl;
+	}
+
 	return object->getId();
 }
 
@@ -681,6 +1082,226 @@ ActiveObjectMessage ServerEnvironment::getActiveObjectMessage()
 	return m_active_object_messages.pop_front();
 }
 
+/*
+	************ Private methods *************
+*/
+
+/*
+	Remove objects that satisfy (m_removed && m_known_by_count==0)
+*/
+void ServerEnvironment::removeRemovedObjects()
+{
+	core::list<u16> objects_to_remove;
+	for(core::map<u16, ServerActiveObject*>::Iterator
+			i = m_active_objects.getIterator();
+			i.atEnd()==false; i++)
+	{
+		u16 id = i.getNode()->getKey();
+		ServerActiveObject* obj = i.getNode()->getValue();
+		// This shouldn't happen but check it
+		if(obj == NULL)
+		{
+			dstream<<"WARNING: NULL object found in ServerEnvironment"
+					<<" while finding removed objects. id="<<id<<std::endl;
+			// Id to be removed from m_active_objects
+			objects_to_remove.push_back(id);
+			continue;
+		}
+
+		/*
+			We will delete objects that are marked as removed or thatare
+			waiting for deletion after deactivation
+		*/
+		if(obj->m_removed == false && obj->m_pending_deactivation == false)
+			continue;
+
+		/*
+			Delete static data from block if is marked as removed
+		*/
+		if(obj->m_static_exists && obj->m_removed)
+		{
+			MapBlock *block = m_map->getBlockNoCreateNoEx(obj->m_static_block);
+			if(block)
+			{
+				block->m_static_objects.remove(id);
+				block->setChangedFlag();
+			}
+		}
+
+		// If m_known_by_count > 0, don't actually remove.
+		if(obj->m_known_by_count > 0)
+			continue;
+		
+		// Delete
+		delete obj;
+		// Id to be removed from m_active_objects
+		objects_to_remove.push_back(id);
+	}
+	// Remove references from m_active_objects
+	for(core::list<u16>::Iterator i = objects_to_remove.begin();
+			i != objects_to_remove.end(); i++)
+	{
+		m_active_objects.remove(*i);
+	}
+}
+
+/*
+	Convert stored objects from blocks near the players to active.
+*/
+void ServerEnvironment::activateObjects(MapBlock *block)
+{
+	if(block==NULL)
+		return;
+	// Ignore if no stored objects (to not set changed flag)
+	if(block->m_static_objects.m_stored.size() == 0)
+		return;
+	// A list for objects that couldn't be converted to static for some
+	// reason. They will be stored back.
+	core::list<StaticObject> new_stored;
+	// Loop through stored static objects
+	for(core::list<StaticObject>::Iterator
+			i = block->m_static_objects.m_stored.begin();
+			i != block->m_static_objects.m_stored.end(); i++)
+	{
+		/*dstream<<"INFO: Server: Creating an active object from "
+				<<"static data"<<std::endl;*/
+		StaticObject &s_obj = *i;
+		// Create an active object from the data
+		ServerActiveObject *obj = ServerActiveObject::create
+				(s_obj.type, this, 0, s_obj.pos, s_obj.data);
+		// If couldn't create object, store static data back.
+		if(obj==NULL)
+		{
+			new_stored.push_back(s_obj);
+			continue;
+		}
+		// This will also add the object to the active static list
+		addActiveObject(obj);
+		//u16 id = addActiveObject(obj);
+	}
+	// Clear stored list
+	block->m_static_objects.m_stored.clear();
+	// Add leftover failed stuff to stored list
+	for(core::list<StaticObject>::Iterator
+			i = new_stored.begin();
+			i != new_stored.end(); i++)
+	{
+		StaticObject &s_obj = *i;
+		block->m_static_objects.m_stored.push_back(s_obj);
+	}
+	// Block has been modified
+	block->setChangedFlag();
+}
+
+/*
+	Convert objects that are not in active blocks to static.
+
+	If m_known_by_count != 0, active object is not deleted, but static
+	data is still updated.
+
+	If force_delete is set, active object is deleted nevertheless. It
+	shall only be set so in the destructor of the environment.
+*/
+void ServerEnvironment::deactivateFarObjects(bool force_delete)
+{
+	core::list<u16> objects_to_remove;
+	for(core::map<u16, ServerActiveObject*>::Iterator
+			i = m_active_objects.getIterator();
+			i.atEnd()==false; i++)
+	{
+		ServerActiveObject* obj = i.getNode()->getValue();
+		u16 id = i.getNode()->getKey();
+		v3f objectpos = obj->getBasePosition();
+
+		// This shouldn't happen but check it
+		if(obj == NULL)
+		{
+			dstream<<"WARNING: NULL object found in ServerEnvironment"
+					<<std::endl;
+			assert(0);
+			continue;
+		}
+
+		// The block in which the object resides in
+		v3s16 blockpos_o = getNodeBlockPos(floatToInt(objectpos, BS));
+		
+		// If block is active, don't remove
+		if(m_active_blocks.contains(blockpos_o))
+			continue;
+
+		/*
+			Update the static data
+		*/
+
+		// Delete old static object
+		MapBlock *oldblock = NULL;
+		if(obj->m_static_exists)
+		{
+			MapBlock *block = m_map->getBlockNoCreateNoEx
+					(obj->m_static_block);
+			if(block)
+			{
+				block->m_static_objects.remove(id);
+				oldblock = block;
+			}
+		}
+		// Create new static object
+		std::string staticdata = obj->getStaticData();
+		StaticObject s_obj(obj->getType(), objectpos, staticdata);
+		// Add to the block where the object is located in
+		v3s16 blockpos = getNodeBlockPos(floatToInt(objectpos, BS));
+		MapBlock *block = m_map->getBlockNoCreateNoEx(blockpos);
+		if(block)
+		{
+			block->m_static_objects.insert(0, s_obj);
+			block->setChangedFlag();
+			obj->m_static_exists = true;
+			obj->m_static_block = block->getPos();
+		}
+		// If not possible, add back to previous block
+		else if(oldblock)
+		{
+			oldblock->m_static_objects.insert(0, s_obj);
+			oldblock->setChangedFlag();
+			obj->m_static_exists = true;
+			obj->m_static_block = oldblock->getPos();
+		}
+		else{
+			dstream<<"WARNING: Server: Could not find a block for "
+					<<"storing static object"<<std::endl;
+			obj->m_static_exists = false;
+			continue;
+		}
+
+		/*
+			Delete active object if not known by some client,
+			else set pending deactivation
+		*/
+
+		// If known by some client, don't delete.
+		if(obj->m_known_by_count > 0 && force_delete == false)
+		{
+			obj->m_pending_deactivation = true;
+			continue;
+		}
+		
+		/*dstream<<"INFO: Server: Stored static data. Deleting object."
+				<<std::endl;*/
+		// Delete active object
+		delete obj;
+		// Id to be removed from m_active_objects
+		objects_to_remove.push_back(id);
+	}
+
+	// Remove references from m_active_objects
+	for(core::list<u16>::Iterator i = objects_to_remove.begin();
+			i != objects_to_remove.end(); i++)
+	{
+		m_active_objects.remove(*i);
+	}
+}
+
+
 #ifndef SERVER
 
 /*
@@ -742,17 +1363,21 @@ void ClientEnvironment::step(float dtime)
 	bool footprints = g_settings.getBool("footprints");
 
 	{
-		//TimeTaker timer("Client m_map->timerUpdate()", g_device);
+		//TimeTaker timer("Client m_map->timerUpdate()");
 		m_map->timerUpdate(dtime);
 	}
-
+	
+	// Get local player
+	LocalPlayer *lplayer = getLocalPlayer();
+	assert(lplayer);
+	// collision info queue
+	core::list<CollisionInfo> player_collisions;
+	
 	/*
 		Get the speed the player is going
 	*/
 	f32 player_speed = 0.001; // just some small value
-	LocalPlayer *lplayer = getLocalPlayer();
-	if(lplayer)
-		player_speed = lplayer->getSpeed().getLength();
+	player_speed = lplayer->getSpeed().getLength();
 	
 	/*
 		Maximum position increment
@@ -805,20 +1430,18 @@ void ClientEnvironment::step(float dtime)
 		*/
 		
 		{
-			Player *player = getLocalPlayer();
-
-			v3f playerpos = player->getPosition();
+			v3f lplayerpos = lplayer->getPosition();
 			
 			// Apply physics
 			if(free_move == false)
 			{
 				// Gravity
-				v3f speed = player->getSpeed();
-				if(player->swimming_up == false)
+				v3f speed = lplayer->getSpeed();
+				if(lplayer->swimming_up == false)
 					speed.Y -= 9.81 * BS * dtime_part * 2;
 
 				// Water resistance
-				if(player->in_water_stable || player->in_water)
+				if(lplayer->in_water_stable || lplayer->in_water)
 				{
 					f32 max_down = 2.0*BS;
 					if(speed.Y < -max_down) speed.Y = -max_down;
@@ -830,19 +1453,47 @@ void ClientEnvironment::step(float dtime)
 					}
 				}
 
-				player->setSpeed(speed);
+				lplayer->setSpeed(speed);
 			}
 
 			/*
-				Move the player.
+				Move the lplayer.
 				This also does collision detection.
 			*/
-			player->move(dtime_part, *m_map, position_max_increment);
+			lplayer->move(dtime_part, *m_map, position_max_increment,
+					&player_collisions);
 		}
 	}
 	while(dtime_downcount > 0.001);
 		
 	//std::cout<<"Looped "<<loopcount<<" times."<<std::endl;
+
+	for(core::list<CollisionInfo>::Iterator
+			i = player_collisions.begin();
+			i != player_collisions.end(); i++)
+	{
+		CollisionInfo &info = *i;
+		if(info.t == COLLISION_FALL)
+		{
+			//f32 tolerance = BS*10; // 2 without damage
+			f32 tolerance = BS*12; // 3 without damage
+			f32 factor = 1;
+			if(info.speed > tolerance)
+			{
+				f32 damage_f = (info.speed - tolerance)/BS*factor;
+				u16 damage = (u16)(damage_f+0.5);
+				if(lplayer->hp > damage)
+					lplayer->hp -= damage;
+				else
+					lplayer->hp = 0;
+
+				ClientEnvEvent event;
+				event.type = CEE_PLAYER_DAMAGE;
+				event.player_damage.amount = damage;
+				m_client_event_queue.push_back(event);
+			}
+		}
+	}
 	
 	/*
 		Stuff that can be done in an arbitarily large dtime
@@ -867,7 +1518,7 @@ void ClientEnvironment::step(float dtime)
 				// Get node at head
 				v3s16 p = floatToInt(playerpos + v3f(0,BS+BS/2,0), BS);
 				MapNode n = m_map->getNode(p);
-				light = n.getLightBlend(m_daynight_ratio);
+				light = n.getLightBlend(getDayNightRatio());
 			}
 			catch(InvalidPositionException &e) {}
 			player->updateLight(light);
@@ -891,7 +1542,7 @@ void ClientEnvironment::step(float dtime)
 					{
 						v3s16 p_blocks = getNodeBlockPos(bottompos);
 						MapBlock *b = m_map->getBlockNoCreate(p_blocks);
-						//b->updateMesh(m_daynight_ratio);
+						//b->updateMesh(getDayNightRatio());
 						b->setMeshExpired(true);
 					}
 				}
@@ -903,21 +1554,33 @@ void ClientEnvironment::step(float dtime)
 	}
 	
 	/*
-		Step active objects
+		Step active objects and update lighting of them
 	*/
+	
 	for(core::map<u16, ClientActiveObject*>::Iterator
 			i = m_active_objects.getIterator();
 			i.atEnd()==false; i++)
 	{
 		ClientActiveObject* obj = i.getNode()->getValue();
 		// Step object
-		obj->step(dtime);
+		obj->step(dtime, this);
+		// Update lighting
+		//u8 light = LIGHT_MAX;
+		u8 light = 0;
+		try{
+			// Get node at head
+			v3s16 p = obj->getLightPosition();
+			MapNode n = m_map->getNode(p);
+			light = n.getLightBlend(getDayNightRatio());
+		}
+		catch(InvalidPositionException &e) {}
+		obj->updateLight(light);
 	}
 }
 
 void ClientEnvironment::updateMeshes(v3s16 blockpos)
 {
-	m_map->updateMeshes(blockpos, m_daynight_ratio);
+	m_map->updateMeshes(blockpos, getDayNightRatio());
 }
 
 void ClientEnvironment::expireMeshes(bool only_daynight_diffed)
@@ -1044,6 +1707,61 @@ void ClientEnvironment::processActiveObjectMessage(u16 id,
 	obj->processMessage(data);
 }
 
+/*
+	Callbacks for activeobjects
+*/
+
+void ClientEnvironment::damageLocalPlayer(u8 damage)
+{
+	LocalPlayer *lplayer = getLocalPlayer();
+	assert(lplayer);
+
+	if(lplayer->hp > damage)
+		lplayer->hp -= damage;
+	else
+		lplayer->hp = 0;
+
+	ClientEnvEvent event;
+	event.type = CEE_PLAYER_DAMAGE;
+	event.player_damage.amount = damage;
+	m_client_event_queue.push_back(event);
+}
+
+/*
+	Client likes to call these
+*/
+	
+void ClientEnvironment::getActiveObjects(v3f origin, f32 max_d,
+		core::array<DistanceSortedActiveObject> &dest)
+{
+	for(core::map<u16, ClientActiveObject*>::Iterator
+			i = m_active_objects.getIterator();
+			i.atEnd()==false; i++)
+	{
+		ClientActiveObject* obj = i.getNode()->getValue();
+
+		f32 d = (obj->getPosition() - origin).getLength();
+
+		if(d > max_d)
+			continue;
+
+		DistanceSortedActiveObject dso(obj, d);
+
+		dest.push_back(dso);
+	}
+}
+
+ClientEnvEvent ClientEnvironment::getClientEvent()
+{
+	if(m_client_event_queue.size() == 0)
+	{
+		ClientEnvEvent event;
+		event.type = CEE_NONE;
+		return event;
+	}
+	return m_client_event_queue.pop_front();
+}
+
 #endif // #ifndef SERVER