X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fenvironment.cpp;h=e472916657ede944d490dfb9ae6ec8f603520e0e;hb=29932d4bddad6a0ad4269606e38701d544784951;hp=906bab611d3c2af5846aa13ab9bc7439d2a8f5ea;hpb=3fb0d2fb65c968f91c333a1d31d2d7a1a02ab7d1;p=dragonfireclient.git

diff --git a/src/environment.cpp b/src/environment.cpp
index 906bab611..e47291665 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
@@ -18,13 +18,13 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 */
 
 #include "environment.h"
-#include "main.h" // g_device for timing debug
+#include "filesys.h"
+#include "porting.h"
+#include "collision.h"
 
-Environment::Environment(Map *map, std::ostream &dout):
-		m_dout(dout)
+Environment::Environment()
 {
-	m_map = map;
-	m_daynight_ratio = 0.2;
+	m_daynight_ratio = 0.5;
 }
 
 Environment::~Environment()
@@ -35,54 +35,1037 @@ Environment::~Environment()
 	{
 		delete (*i);
 	}
+}
+
+void Environment::addPlayer(Player *player)
+{
+	DSTACK(__FUNCTION_NAME);
+	/*
+		Check that peer_ids are unique.
+		Also check that names are unique.
+		Exception: there can be multiple players with peer_id=0
+	*/
+	// If peer id is non-zero, it has to be unique.
+	if(player->peer_id != 0)
+		assert(getPlayer(player->peer_id) == NULL);
+	// Name has to be unique.
+	assert(getPlayer(player->getName()) == NULL);
+	// Add.
+	m_players.push_back(player);
+}
+
+void Environment::removePlayer(u16 peer_id)
+{
+	DSTACK(__FUNCTION_NAME);
+re_search:
+	for(core::list<Player*>::Iterator i = m_players.begin();
+			i != m_players.end(); i++)
+	{
+		Player *player = *i;
+		if(player->peer_id != peer_id)
+			continue;
+		
+		delete player;
+		m_players.erase(i);
+		// See if there is an another one
+		// (shouldn't be, but just to be sure)
+		goto re_search;
+	}
+}
+
+Player * Environment::getPlayer(u16 peer_id)
+{
+	for(core::list<Player*>::Iterator i = m_players.begin();
+			i != m_players.end(); i++)
+	{
+		Player *player = *i;
+		if(player->peer_id == peer_id)
+			return player;
+	}
+	return NULL;
+}
+
+Player * Environment::getPlayer(const char *name)
+{
+	for(core::list<Player*>::Iterator i = m_players.begin();
+			i != m_players.end(); i++)
+	{
+		Player *player = *i;
+		if(strcmp(player->getName(), name) == 0)
+			return player;
+	}
+	return NULL;
+}
+
+Player * Environment::getRandomConnectedPlayer()
+{
+	core::list<Player*> connected_players = getPlayers(true);
+	u32 chosen_one = myrand() % connected_players.size();
+	u32 j = 0;
+	for(core::list<Player*>::Iterator
+			i = connected_players.begin();
+			i != connected_players.end(); i++)
+	{
+		if(j == chosen_one)
+		{
+			Player *player = *i;
+			return player;
+		}
+		j++;
+	}
+	return NULL;
+}
+
+Player * Environment::getNearestConnectedPlayer(v3f pos)
+{
+	core::list<Player*> connected_players = getPlayers(true);
+	f32 nearest_d = 0;
+	Player *nearest_player = NULL;
+	for(core::list<Player*>::Iterator
+			i = connected_players.begin();
+			i != connected_players.end(); i++)
+	{
+		Player *player = *i;
+		f32 d = player->getPosition().getDistanceFrom(pos);
+		if(d < nearest_d || nearest_player == NULL)
+		{
+			nearest_d = d;
+			nearest_player = player;
+		}
+	}
+	return nearest_player;
+}
+
+core::list<Player*> Environment::getPlayers()
+{
+	return m_players;
+}
+
+core::list<Player*> Environment::getPlayers(bool ignore_disconnected)
+{
+	core::list<Player*> newlist;
+	for(core::list<Player*>::Iterator
+			i = m_players.begin();
+			i != m_players.end(); i++)
+	{
+		Player *player = *i;
+		
+		if(ignore_disconnected)
+		{
+			// Ignore disconnected players
+			if(player->peer_id == 0)
+				continue;
+		}
+
+		newlist.push_back(player);
+	}
+	return newlist;
+}
+
+void Environment::printPlayers(std::ostream &o)
+{
+	o<<"Players in environment:"<<std::endl;
+	for(core::list<Player*>::Iterator i = m_players.begin();
+			i != m_players.end(); i++)
+	{
+		Player *player = *i;
+		o<<"Player peer_id="<<player->peer_id<<std::endl;
+	}
+}
+
+void Environment::setDayNightRatio(u32 r)
+{
+	m_daynight_ratio = r;
+}
+
+u32 Environment::getDayNightRatio()
+{
+	return m_daynight_ratio;
+}
+
+/*
+	ServerEnvironment
+*/
+
+ServerEnvironment::ServerEnvironment(ServerMap *map, Server *server):
+	m_map(map),
+	m_server(server),
+	m_random_spawn_timer(3),
+	m_send_recommended_timer(0)
+{
+}
+
+ServerEnvironment::~ServerEnvironment()
+{
+	// Drop/delete map
+	m_map->drop();
+}
+
+void ServerEnvironment::serializePlayers(const std::string &savedir)
+{
+	std::string players_path = savedir + "/players";
+	fs::CreateDir(players_path);
+
+	core::map<Player*, bool> saved_players;
+
+	std::vector<fs::DirListNode> player_files = fs::GetDirListing(players_path);
+	for(u32 i=0; i<player_files.size(); i++)
+	{
+		if(player_files[i].dir)
+			continue;
+		
+		// Full path to this file
+		std::string path = players_path + "/" + player_files[i].name;
+
+		//dstream<<"Checking player file "<<path<<std::endl;
+
+		// Load player to see what is its name
+		ServerRemotePlayer testplayer;
+		{
+			// Open file and deserialize
+			std::ifstream is(path.c_str(), std::ios_base::binary);
+			if(is.good() == false)
+			{
+				dstream<<"Failed to read "<<path<<std::endl;
+				continue;
+			}
+			testplayer.deSerialize(is);
+		}
+
+		//dstream<<"Loaded test player with name "<<testplayer.getName()<<std::endl;
+		
+		// Search for the player
+		std::string playername = testplayer.getName();
+		Player *player = getPlayer(playername.c_str());
+		if(player == NULL)
+		{
+			dstream<<"Didn't find matching player, ignoring file "<<path<<std::endl;
+			continue;
+		}
+
+		//dstream<<"Found matching player, overwriting."<<std::endl;
+
+		// OK, found. Save player there.
+		{
+			// Open file and serialize
+			std::ofstream os(path.c_str(), std::ios_base::binary);
+			if(os.good() == false)
+			{
+				dstream<<"Failed to overwrite "<<path<<std::endl;
+				continue;
+			}
+			player->serialize(os);
+			saved_players.insert(player, true);
+		}
+	}
+
+	for(core::list<Player*>::Iterator i = m_players.begin();
+			i != m_players.end(); i++)
+	{
+		Player *player = *i;
+		if(saved_players.find(player) != NULL)
+		{
+			/*dstream<<"Player "<<player->getName()
+					<<" was already saved."<<std::endl;*/
+			continue;
+		}
+		std::string playername = player->getName();
+		// Don't save unnamed player
+		if(playername == "")
+		{
+			//dstream<<"Not saving unnamed player."<<std::endl;
+			continue;
+		}
+		/*
+			Find a sane filename
+		*/
+		if(string_allowed(playername, PLAYERNAME_ALLOWED_CHARS) == false)
+			playername = "player";
+		std::string path = players_path + "/" + playername;
+		bool found = false;
+		for(u32 i=0; i<1000; i++)
+		{
+			if(fs::PathExists(path) == false)
+			{
+				found = true;
+				break;
+			}
+			path = players_path + "/" + playername + itos(i);
+		}
+		if(found == false)
+		{
+			dstream<<"WARNING: Didn't find free file for player"<<std::endl;
+			continue;
+		}
+
+		{
+			/*dstream<<"Saving player "<<player->getName()<<" to "
+					<<path<<std::endl;*/
+			// Open file and serialize
+			std::ofstream os(path.c_str(), std::ios_base::binary);
+			if(os.good() == false)
+			{
+				dstream<<"WARNING: Failed to overwrite "<<path<<std::endl;
+				continue;
+			}
+			player->serialize(os);
+			saved_players.insert(player, true);
+		}
+	}
+
+	//dstream<<"Saved "<<saved_players.size()<<" players."<<std::endl;
+}
+
+void ServerEnvironment::deSerializePlayers(const std::string &savedir)
+{
+	std::string players_path = savedir + "/players";
+
+	core::map<Player*, bool> saved_players;
+
+	std::vector<fs::DirListNode> player_files = fs::GetDirListing(players_path);
+	for(u32 i=0; i<player_files.size(); i++)
+	{
+		if(player_files[i].dir)
+			continue;
+		
+		// Full path to this file
+		std::string path = players_path + "/" + player_files[i].name;
+
+		dstream<<"Checking player file "<<path<<std::endl;
+
+		// Load player to see what is its name
+		ServerRemotePlayer testplayer;
+		{
+			// Open file and deserialize
+			std::ifstream is(path.c_str(), std::ios_base::binary);
+			if(is.good() == false)
+			{
+				dstream<<"Failed to read "<<path<<std::endl;
+				continue;
+			}
+			testplayer.deSerialize(is);
+		}
+
+		dstream<<"Loaded test player with name "<<testplayer.getName()<<std::endl;
+		
+		// Search for the player
+		std::string playername = testplayer.getName();
+		Player *player = getPlayer(playername.c_str());
+		bool newplayer = false;
+		if(player == NULL)
+		{
+			dstream<<"Is a new player"<<std::endl;
+			player = new ServerRemotePlayer();
+			newplayer = true;
+		}
+
+		// Load player
+		{
+			dstream<<"Reading player "<<testplayer.getName()<<" from "
+					<<path<<std::endl;
+			// Open file and deserialize
+			std::ifstream is(path.c_str(), std::ios_base::binary);
+			if(is.good() == false)
+			{
+				dstream<<"Failed to read "<<path<<std::endl;
+				continue;
+			}
+			player->deSerialize(is);
+		}
+
+		if(newplayer)
+			addPlayer(player);
+	}
+}
+
+#if 0
+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");
+
+	{
+		//TimeTaker timer("Server m_map->timerUpdate()");
+		m_map->timerUpdate(dtime);
+	}
+
+	/*
+		Handle players
+	*/
+	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;
+
+		v3f playerpos = player->getPosition();
+		
+		// Move
+		player->move(dtime, *m_map, 100*BS);
+		
+		/*
+			Add footsteps to grass
+		*/
+		if(footprints)
+		{
+			// Get node that is at BS/4 under player
+			v3s16 bottompos = floatToInt(playerpos + v3f(0,-BS/4,0), BS);
+			try{
+				MapNode n = m_map->getNode(bottompos);
+				if(n.d == CONTENT_GRASS)
+				{
+					n.d = CONTENT_GRASS_FOOTSTEPS;
+					m_map->setNode(bottompos, n);
+				}
+			}
+			catch(InvalidPositionException &e)
+			{
+			}
+		}
+	}
+
+	/*
+		Step active objects
+	*/
+	{
+		//TimeTaker timer("Step active objects");
+
+		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++)
+		{
+			ServerActiveObject* obj = i.getNode()->getValue();
+			// Step object, putting messages directly to the queue
+			obj->step(dtime, m_active_object_messages, send_recommended);
+		}
+	}
+
+	if(m_object_management_interval.step(dtime, 0.5))
+	{
+		//TimeTaker timer("ServerEnv object management");
+
+		/*
+			Remove objects that satisfy (m_removed && m_known_by_count==0)
+		*/
+		{
+			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;
+				}
+				// If not m_removed, don't remove.
+				if(obj->m_removed == false)
+					continue;
+				// Delete static data from block
+				if(obj->m_static_exists)
+				{
+					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);
+			}
+		}
+		
+
+		const s16 to_active_max_blocks = 3;
+		const f32 to_static_max_f = (to_active_max_blocks+2)*MAP_BLOCKSIZE*BS;
+
+		/*
+			Convert stored objects from blocks near the players to active.
+		*/
+		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;
+
+			v3f playerpos = player->getPosition();
+			
+			v3s16 blockpos0 = getNodeBlockPos(floatToInt(playerpos, BS));
+			v3s16 bpmin = blockpos0 - v3s16(1,1,1)*to_active_max_blocks;
+			v3s16 bpmax = blockpos0 + v3s16(1,1,1)*to_active_max_blocks;
+			// Loop through all nearby blocks
+			for(s16 x=bpmin.X; x<=bpmax.X; x++)
+			for(s16 y=bpmin.Y; y<=bpmax.Y; y++)
+			for(s16 z=bpmin.Z; z<=bpmax.Z; z++)
+			{
+				v3s16 blockpos(x,y,z);
+				MapBlock *block = m_map->getBlockNoCreateNoEx(blockpos);
+				if(block==NULL)
+					continue;
+				// Ignore if no stored objects (to not set changed flag)
+				if(block->m_static_objects.m_stored.size() == 0)
+					continue;
+				// This will contain the leftovers of the stored list
+				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(obj==NULL)
+					{
+						// This is necessary to preserve stuff during bugs
+						// and errors
+						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 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->setChangedFlag();
+			}
+		}
+
+		/*
+			Convert objects that are far away from all the players to static.
+		*/
+		{
+			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;
+					continue;
+				}
+				// If known by some client, don't convert to static.
+				if(obj->m_known_by_count > 0)
+					continue;
+
+				// If close to some player, don't convert to static.
+				bool close_to_player = false;
+				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;
+
+					v3f playerpos = player->getPosition();
+					f32 d = playerpos.getDistanceFrom(objectpos);
+					if(d < to_static_max_f)
+					{
+						close_to_player = true;
+						break;
+					}
+				}
+
+				if(close_to_player)
+					continue;
+
+				/*
+					Update the static data and remove the active object.
+				*/
+
+				// 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;
+					}
+				}
+				// Add 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;
+				}
+				/*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);
+			}
+		}
+	}
+
+	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 += 2.0;
+		m_random_spawn_timer += 200.0;
+
+		/*
+			Find some position
+		*/
+
+		/*v2s16 p2d(myrand_range(-5,5), myrand_range(-5,5));
+		s16 y = 1 + getServerMap().findGroundLevel(p2d);
+		v3f pos(p2d.X*BS,y*BS,p2d.Y*BS);*/
+		
+		Player *player = getRandomConnectedPlayer();
+		v3f pos(0,0,0);
+		if(player)
+			pos = player->getPosition();
+		pos += v3f(
+			myrand_range(-3,3)*BS,
+			0,
+			myrand_range(-3,3)*BS
+		);
+
+		/*
+			Create a ServerActiveObject
+		*/
+
+		//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
+}
+
+ServerActiveObject* ServerEnvironment::getActiveObject(u16 id)
+{
+	core::map<u16, ServerActiveObject*>::Node *n;
+	n = m_active_objects.find(id);
+	if(n == NULL)
+		return NULL;
+	return n->getValue();
+}
+
+bool isFreeServerActiveObjectId(u16 id,
+		core::map<u16, ServerActiveObject*> &objects)
+{
+	if(id == 0)
+		return false;
+	
+	for(core::map<u16, ServerActiveObject*>::Iterator
+			i = objects.getIterator();
+			i.atEnd()==false; i++)
+	{
+		if(i.getNode()->getKey() == id)
+			return false;
+	}
+	return true;
+}
+
+u16 getFreeServerActiveObjectId(
+		core::map<u16, ServerActiveObject*> &objects)
+{
+	u16 new_id = 1;
+	for(;;)
+	{
+		if(isFreeServerActiveObjectId(new_id, objects))
+			return new_id;
+		
+		if(new_id == 65535)
+			return 0;
+
+		new_id++;
+	}
+}
+
+u16 ServerEnvironment::addActiveObject(ServerActiveObject *object)
+{
+	assert(object);
+	if(object->getId() == 0)
+	{
+		u16 new_id = getFreeServerActiveObjectId(m_active_objects);
+		if(new_id == 0)
+		{
+			dstream<<"WARNING: ServerEnvironment::addActiveObject(): "
+					<<"no free ids available"<<std::endl;
+			delete object;
+			return 0;
+		}
+		object->setId(new_id);
+	}
+	if(isFreeServerActiveObjectId(object->getId(), m_active_objects) == false)
+	{
+		dstream<<"WARNING: ServerEnvironment::addActiveObject(): "
+				<<"id is not free ("<<object->getId()<<")"<<std::endl;
+		delete object;
+		return 0;
+	}
+	/*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();
+}
+
+/*
+	Finds out what new objects have been added to
+	inside a radius around a position
+*/
+void ServerEnvironment::getAddedActiveObjects(v3s16 pos, s16 radius,
+		core::map<u16, bool> &current_objects,
+		core::map<u16, bool> &added_objects)
+{
+	v3f pos_f = intToFloat(pos, BS);
+	f32 radius_f = radius * BS;
+	/*
+		Go through the object list,
+		- discard m_removed objects,
+		- discard objects that are too far away,
+		- discard objects that are found in current_objects.
+		- add remaining objects to added_objects
+	*/
+	for(core::map<u16, ServerActiveObject*>::Iterator
+			i = m_active_objects.getIterator();
+			i.atEnd()==false; i++)
+	{
+		u16 id = i.getNode()->getKey();
+		// Get object
+		ServerActiveObject *object = i.getNode()->getValue();
+		if(object == NULL)
+			continue;
+		// Discard if removed
+		if(object->m_removed)
+			continue;
+		// Discard if too far
+		f32 distance_f = object->getBasePosition().getDistanceFrom(pos_f);
+		if(distance_f > radius_f)
+			continue;
+		// Discard if already on current_objects
+		core::map<u16, bool>::Node *n;
+		n = current_objects.find(id);
+		if(n != NULL)
+			continue;
+		// Add to added_objects
+		added_objects.insert(id, false);
+	}
+}
+
+/*
+	Finds out what objects have been removed from
+	inside a radius around a position
+*/
+void ServerEnvironment::getRemovedActiveObjects(v3s16 pos, s16 radius,
+		core::map<u16, bool> &current_objects,
+		core::map<u16, bool> &removed_objects)
+{
+	v3f pos_f = intToFloat(pos, BS);
+	f32 radius_f = radius * BS;
+	/*
+		Go through current_objects; object is removed if:
+		- object is not found in m_active_objects (this is actually an
+		  error condition; objects should be set m_removed=true and removed
+		  only after all clients have been informed about removal), or
+		- object has m_removed=true, or
+		- object is too far away
+	*/
+	for(core::map<u16, bool>::Iterator
+			i = current_objects.getIterator();
+			i.atEnd()==false; i++)
+	{
+		u16 id = i.getNode()->getKey();
+		ServerActiveObject *object = getActiveObject(id);
+		if(object == NULL)
+		{
+			dstream<<"WARNING: ServerEnvironment::getRemovedActiveObjects():"
+					<<" object in current_objects is NULL"<<std::endl;
+		}
+		else if(object->m_removed == false)
+		{
+			f32 distance_f = object->getBasePosition().getDistanceFrom(pos_f);
+			/*dstream<<"removed == false"
+					<<"distance_f = "<<distance_f
+					<<", radius_f = "<<radius_f<<std::endl;*/
+			if(distance_f < radius_f)
+			{
+				// Not removed
+				continue;
+			}
+		}
+		removed_objects.insert(id, false);
+	}
+}
+
+ActiveObjectMessage ServerEnvironment::getActiveObjectMessage()
+{
+	if(m_active_object_messages.size() == 0)
+		return ActiveObjectMessage(0);
 	
-	// The map is removed by the SceneManager
+	return m_active_object_messages.pop_front();
+}
+
+#ifndef SERVER
+
+/*
+	ClientEnvironment
+*/
+
+ClientEnvironment::ClientEnvironment(ClientMap *map, scene::ISceneManager *smgr):
+	m_map(map),
+	m_smgr(smgr)
+{
+	assert(m_map);
+	assert(m_smgr);
+}
+
+ClientEnvironment::~ClientEnvironment()
+{
+	// delete active objects
+	for(core::map<u16, ClientActiveObject*>::Iterator
+			i = m_active_objects.getIterator();
+			i.atEnd()==false; i++)
+	{
+		delete i.getNode()->getValue();
+	}
+
+	// Drop/delete map
 	m_map->drop();
-	//delete m_map;
 }
 
-void Environment::step(float dtime)
+void ClientEnvironment::addPlayer(Player *player)
 {
 	DSTACK(__FUNCTION_NAME);
 	/*
-		Run Map's timers
+		It is a failure if player is local and there already is a local
+		player
 	*/
-	//TimeTaker maptimerupdatetimer("m_map->timerUpdate()", g_device);
-	// 0ms
-	m_map->timerUpdate(dtime);
-	//maptimerupdatetimer.stop();
+	assert(!(player->isLocal() == true && getLocalPlayer() != NULL));
 
-	/*
-		Get the highest speed some player is going
-	*/
-	//TimeTaker playerspeed("playerspeed", g_device);
-	// 0ms
-	f32 maximum_player_speed = 0.001; // just some small value
+	Environment::addPlayer(player);
+}
+
+LocalPlayer * ClientEnvironment::getLocalPlayer()
+{
 	for(core::list<Player*>::Iterator i = m_players.begin();
 			i != m_players.end(); i++)
 	{
-		f32 speed = (*i)->getSpeed().getLength();
-		if(speed > maximum_player_speed)
-			maximum_player_speed = speed;
+		Player *player = *i;
+		if(player->isLocal())
+			return (LocalPlayer*)player;
+	}
+	return NULL;
+}
+
+void ClientEnvironment::step(float dtime)
+{
+	DSTACK(__FUNCTION_NAME);
+
+	// Get some settings
+	bool free_move = g_settings.getBool("free_move");
+	bool footprints = g_settings.getBool("footprints");
+
+	{
+		//TimeTaker timer("Client m_map->timerUpdate()");
+		m_map->timerUpdate(dtime);
 	}
-	//playerspeed.stop();
 	
+	// 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
+	player_speed = lplayer->getSpeed().getLength();
+	
+	/*
+		Maximum position increment
+	*/
+	//f32 position_max_increment = 0.05*BS;
+	f32 position_max_increment = 0.1*BS;
+
 	// Maximum time increment (for collision detection etc)
-	// Allow 0.1 blocks per increment
 	// time = distance / speed
-	f32 dtime_max_increment = 0.1*BS / maximum_player_speed;
+	f32 dtime_max_increment = position_max_increment / player_speed;
+	
 	// Maximum time increment is 10ms or lower
 	if(dtime_max_increment > 0.01)
 		dtime_max_increment = 0.01;
 	
-	//TimeTaker playerupdate("playerupdate", g_device);
+	// Don't allow overly huge dtime
+	if(dtime > 0.5)
+		dtime = 0.5;
 	
+	f32 dtime_downcount = dtime;
+
 	/*
 		Stuff that has a maximum time increment
 	*/
-	// Don't allow overly huge dtime
-	if(dtime > 0.5)
-		dtime = 0.5;
 
 	u32 loopcount = 0;
 	do
@@ -90,35 +1073,41 @@ void Environment::step(float dtime)
 		loopcount++;
 
 		f32 dtime_part;
-		if(dtime > dtime_max_increment)
+		if(dtime_downcount > dtime_max_increment)
+		{
 			dtime_part = dtime_max_increment;
+			dtime_downcount -= dtime_part;
+		}
 		else
-			dtime_part = dtime;
-		dtime -= dtime_part;
+		{
+			dtime_part = dtime_downcount;
+			/*
+				Setting this to 0 (no -=dtime_part) disables an infinite loop
+				when dtime_part is so small that dtime_downcount -= dtime_part
+				does nothing
+			*/
+			dtime_downcount = 0;
+		}
 		
 		/*
-			Handle players
+			Handle local player
 		*/
-		for(core::list<Player*>::Iterator i = m_players.begin();
-				i != m_players.end(); i++)
+		
 		{
-			Player *player = *i;
-
-			v3f playerpos = player->getPosition();
+			v3f lplayerpos = lplayer->getPosition();
 			
-			// Apply physics to local player
-			if(player->isLocal())
+			// Apply physics
+			if(free_move == false)
 			{
-				// Apply gravity to local player
-				v3f speed = player->getSpeed();
-				speed.Y -= 9.81 * BS * dtime_part * 2;
+				// Gravity
+				v3f speed = lplayer->getSpeed();
+				if(lplayer->swimming_up == false)
+					speed.Y -= 9.81 * BS * dtime_part * 2;
 
-				/*
-					Apply water resistance
-				*/
-				if(player->in_water)
+				// Water resistance
+				if(lplayer->in_water_stable || lplayer->in_water)
 				{
-					f32 max_down = 1.0*BS;
+					f32 max_down = 2.0*BS;
 					if(speed.Y < -max_down) speed.Y = -max_down;
 
 					f32 max = 2.5*BS;
@@ -128,48 +1117,98 @@ void Environment::step(float dtime)
 					}
 				}
 
-				player->setSpeed(speed);
+				lplayer->setSpeed(speed);
 			}
 
 			/*
-				Move the player.
-				For local player, this also calculates collision detection.
-			*/
-			player->move(dtime_part, *m_map);
-			
-			/*
-				Update lighting on remote players on client
+				Move the lplayer.
+				This also does collision detection.
 			*/
+			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
+	*/
+	for(core::list<Player*>::Iterator i = m_players.begin();
+			i != m_players.end(); i++)
+	{
+		Player *player = *i;
+		v3f playerpos = player->getPosition();
+		
+		/*
+			Handle non-local players
+		*/
+		if(player->isLocal() == false)
+		{
+			// Move
+			player->move(dtime, *m_map, 100*BS);
+
+			// Update lighting on remote players on client
 			u8 light = LIGHT_MAX;
 			try{
-				// Get node at feet
-				v3s16 p = floatToInt(playerpos + v3f(0,BS/4,0));
+				// 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);
 			}
 			catch(InvalidPositionException &e) {}
 			player->updateLight(light);
-
-			/*
-				Add footsteps to grass
-			*/
+		}
+		
+		/*
+			Add footsteps to grass
+		*/
+		if(footprints)
+		{
 			// Get node that is at BS/4 under player
-			v3s16 bottompos = floatToInt(playerpos + v3f(0,-BS/4,0));
+			v3s16 bottompos = floatToInt(playerpos + v3f(0,-BS/4,0), BS);
 			try{
 				MapNode n = m_map->getNode(bottompos);
 				if(n.d == CONTENT_GRASS)
 				{
 					n.d = CONTENT_GRASS_FOOTSTEPS;
 					m_map->setNode(bottompos, n);
-#ifndef SERVER
 					// Update mesh on client
 					if(m_map->mapType() == MAPTYPE_CLIENT)
 					{
 						v3s16 p_blocks = getNodeBlockPos(bottompos);
 						MapBlock *b = m_map->getBlockNoCreate(p_blocks);
-						b->updateMesh(m_daynight_ratio);
+						//b->updateMesh(m_daynight_ratio);
+						b->setMeshExpired(true);
 					}
-#endif
 				}
 			}
 			catch(InvalidPositionException &e)
@@ -177,140 +1216,216 @@ void Environment::step(float dtime)
 			}
 		}
 	}
-	while(dtime > 0.001);
 	
-	//std::cout<<"Looped "<<loopcount<<" times."<<std::endl;
+	/*
+		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, 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(m_daynight_ratio);
+		}
+		catch(InvalidPositionException &e) {}
+		obj->updateLight(light);
+	}
 }
 
-Map & Environment::getMap()
+void ClientEnvironment::updateMeshes(v3s16 blockpos)
 {
-	return *m_map;
+	m_map->updateMeshes(blockpos, m_daynight_ratio);
 }
 
-void Environment::addPlayer(Player *player)
+void ClientEnvironment::expireMeshes(bool only_daynight_diffed)
 {
-	DSTACK(__FUNCTION_NAME);
-	//Check that only one local player exists and peer_ids are unique
-#ifndef SERVER
-	assert(player->isLocal() == false || getLocalPlayer() == NULL);
-#endif
-	assert(getPlayer(player->peer_id) == NULL);
-	m_players.push_back(player);
+	m_map->expireMeshes(only_daynight_diffed);
 }
 
-void Environment::removePlayer(u16 peer_id)
+ClientActiveObject* ClientEnvironment::getActiveObject(u16 id)
 {
-	DSTACK(__FUNCTION_NAME);
-re_search:
-	for(core::list<Player*>::Iterator i = m_players.begin();
-			i != m_players.end(); i++)
-	{
-		Player *player = *i;
-		if(player->peer_id != peer_id)
-			continue;
-		
-		delete player;
-		m_players.erase(i);
-		// See if there is an another one
-		// (shouldn't be, but just to be sure)
-		goto re_search;
-	}
+	core::map<u16, ClientActiveObject*>::Node *n;
+	n = m_active_objects.find(id);
+	if(n == NULL)
+		return NULL;
+	return n->getValue();
 }
 
-#ifndef SERVER
-LocalPlayer * Environment::getLocalPlayer()
+bool isFreeClientActiveObjectId(u16 id,
+		core::map<u16, ClientActiveObject*> &objects)
 {
-	for(core::list<Player*>::Iterator i = m_players.begin();
-			i != m_players.end(); i++)
+	if(id == 0)
+		return false;
+	
+	for(core::map<u16, ClientActiveObject*>::Iterator
+			i = objects.getIterator();
+			i.atEnd()==false; i++)
 	{
-		Player *player = *i;
-		if(player->isLocal())
-			return (LocalPlayer*)player;
+		if(i.getNode()->getKey() == id)
+			return false;
 	}
-	return NULL;
+	return true;
 }
-#endif
 
-Player * Environment::getPlayer(u16 peer_id)
+u16 getFreeClientActiveObjectId(
+		core::map<u16, ClientActiveObject*> &objects)
 {
-	for(core::list<Player*>::Iterator i = m_players.begin();
-			i != m_players.end(); i++)
+	u16 new_id = 1;
+	for(;;)
 	{
-		Player *player = *i;
-		if(player->peer_id == peer_id)
-			return player;
+		if(isFreeClientActiveObjectId(new_id, objects))
+			return new_id;
+		
+		if(new_id == 65535)
+			return 0;
+
+		new_id++;
 	}
-	return NULL;
 }
 
-Player * Environment::getPlayer(const char *name)
+u16 ClientEnvironment::addActiveObject(ClientActiveObject *object)
 {
-	for(core::list<Player*>::Iterator i = m_players.begin();
-			i != m_players.end(); i++)
+	assert(object);
+	if(object->getId() == 0)
 	{
-		Player *player = *i;
-		if(strcmp(player->getName(), name) == 0)
-			return player;
+		u16 new_id = getFreeClientActiveObjectId(m_active_objects);
+		if(new_id == 0)
+		{
+			dstream<<"WARNING: ClientEnvironment::addActiveObject(): "
+					<<"no free ids available"<<std::endl;
+			delete object;
+			return 0;
+		}
+		object->setId(new_id);
 	}
-	return NULL;
+	if(isFreeClientActiveObjectId(object->getId(), m_active_objects) == false)
+	{
+		dstream<<"WARNING: ClientEnvironment::addActiveObject(): "
+				<<"id is not free ("<<object->getId()<<")"<<std::endl;
+		delete object;
+		return 0;
+	}
+	dstream<<"INGO: ClientEnvironment::addActiveObject(): "
+			<<"added (id="<<object->getId()<<")"<<std::endl;
+	m_active_objects.insert(object->getId(), object);
+	object->addToScene(m_smgr);
+	return object->getId();
 }
 
-core::list<Player*> Environment::getPlayers()
+void ClientEnvironment::addActiveObject(u16 id, u8 type,
+		const std::string &init_data)
 {
-	return m_players;
+	ClientActiveObject* obj = ClientActiveObject::create(type);
+	if(obj == NULL)
+	{
+		dstream<<"WARNING: ClientEnvironment::addActiveObject(): "
+				<<"id="<<id<<" type="<<type<<": Couldn't create object"
+				<<std::endl;
+		return;
+	}
+	
+	obj->setId(id);
+
+	addActiveObject(obj);
+
+	obj->initialize(init_data);
 }
 
-core::list<Player*> Environment::getPlayers(bool ignore_disconnected)
+void ClientEnvironment::removeActiveObject(u16 id)
 {
-	core::list<Player*> newlist;
-	for(core::list<Player*>::Iterator
-			i = m_players.begin();
-			i != m_players.end(); i++)
+	dstream<<"ClientEnvironment::removeActiveObject(): "
+			<<"id="<<id<<std::endl;
+	ClientActiveObject* obj = getActiveObject(id);
+	if(obj == NULL)
 	{
-		Player *player = *i;
-		
-		if(ignore_disconnected)
-		{
-			// Ignore disconnected players
-			if(player->peer_id == 0)
-				continue;
-		}
-
-		newlist.push_back(player);
+		dstream<<"WARNING: ClientEnvironment::removeActiveObject(): "
+				<<"id="<<id<<" not found"<<std::endl;
+		return;
 	}
-	return newlist;
+	obj->removeFromScene();
+	delete obj;
+	m_active_objects.remove(id);
 }
 
-void Environment::printPlayers(std::ostream &o)
+void ClientEnvironment::processActiveObjectMessage(u16 id,
+		const std::string &data)
 {
-	o<<"Players in environment:"<<std::endl;
-	for(core::list<Player*>::Iterator i = m_players.begin();
-			i != m_players.end(); i++)
+	ClientActiveObject* obj = getActiveObject(id);
+	if(obj == NULL)
 	{
-		Player *player = *i;
-		o<<"Player peer_id="<<player->peer_id<<std::endl;
+		dstream<<"WARNING: ClientEnvironment::processActiveObjectMessage():"
+				<<" got message for id="<<id<<", which doesn't exist."
+				<<std::endl;
+		return;
 	}
+	obj->processMessage(data);
 }
 
-#ifndef SERVER
-void Environment::updateMeshes(v3s16 blockpos)
-{
-	m_map->updateMeshes(blockpos, m_daynight_ratio);
-}
+/*
+	Callbacks for activeobjects
+*/
 
-void Environment::expireMeshes(bool only_daynight_diffed)
+void ClientEnvironment::damageLocalPlayer(u8 damage)
 {
-	m_map->expireMeshes(only_daynight_diffed);
+	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);
 }
-#endif
 
-void Environment::setDayNightRatio(u32 r)
+/*
+	Client likes to call these
+*/
+	
+void ClientEnvironment::getActiveObjects(v3f origin, f32 max_d,
+		core::array<DistanceSortedActiveObject> &dest)
 {
-	m_daynight_ratio = r;
+	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);
+	}
 }
 
-u32 Environment::getDayNightRatio()
+ClientEnvEvent ClientEnvironment::getClientEvent()
 {
-	return m_daynight_ratio;
+	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
+
+